Add Chapter 29 for tech debt cleanup with the parser splitmain

Keep Chapter 28b intact and carry the grammar-oriented parser package, Var move, IterPeeps move, and parser regression tests into Chapter 29. Defer privacy and exclude its experimental tests and fixture changes.

Register the chapter in the indexes, IntelliJ modules and run configurations, Maven reactor, roadmap, and linear-history publisher. Windows and Linux each pass 573 tests, release builds, 199 allocation replays, and 29 native checks.

1 files changed, 495 insertions, 0 deletions

diff --git a/chapter29/src/test/java/com/seaofnodes/simple/Chapter19Test.java b/chapter29/src/test/java/com/seaofnodes/simple/Chapter19Test.java
new file mode 100644
index 00000000..d5fe207a
--- /dev/null
+++ b/chapter29/src/test/java/com/seaofnodes/simple/Chapter19Test.java
@@ -0,0 +1,495 @@
+package com.seaofnodes.simple;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+
+import com.seaofnodes.simple.codegen.CodeGen.Phase;
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.io.IOException;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter19Test {
+    @Test public void testNarrowStores() {
+        // Return the allocation so Load forwarding cannot hide a bad Store.
+        for( String type : new String[]{"u8","i8","u16","i16","u32","i32","int","f32","flt"} ) {
+            boolean flt = type.equals("f32") || type.equals("flt");
+            String init = flt ? "flt v=arg; " : "";
+            if( type.equals("f32") ) init+="f32 w=v; ";
+            String value = type.equals("f32") ? "w" : flt ? "v" : "arg";
+            for( boolean array : new boolean[]{false,true} ) {
+                String src = array
+                    ? "var a=new "+type+"[1]; a[0]="+value+"; return a;"
+                    : "struct S { "+type+" x; }; var s=new S; s.x="+value+"; return s;";
+                CodeGen code = new CodeGen(init+src).driver(CodeGen.Phase.TypeCheck);
+                long[] args = flt ? new long[]{0,1,-1,16777217,-16777217}
+                    : new long[]{0,1,-1,0x180,0x18000,0x180000000L,Long.MIN_VALUE,Long.MAX_VALUE};
+                for( long arg : args ) {
+                    Object expected = switch( type ) {
+                    case "u8"  -> arg & 0xffL;
+                    case "i8"  -> (long)(byte)arg;
+                    case "u16" -> arg & 0xffffL;
+                    case "i16" -> (long)(short)arg;
+                    case "u32" -> arg & 0xffffffffL;
+                    case "i32" -> (long)(int)arg;
+                    case "f32" -> (double)(float)arg;
+                    case "flt" -> (double)arg;
+                    default    -> arg;
+                    };
+                    String msg = type+" array="+array+" arg="+arg;
+                    String printed = array
+                        ? (type.equals("u8") ? ""+(char)(long)(Long)expected : (type.equals("int") ? "i64" : type)+"[ "+expected+"]")
+                        : "Test.S{x="+expected+"}";
+                    assertEquals(msg,printed,Eval2.eval(code,arg));
+                }
+            }
+        }
+    }
+
+    @Test public void testPrintingFunctionLookup() {
+        var code = new CodeGen("return 0;").parse();
+        var tfp = TypeFunPtr.make1((byte)2,false,new Type[]{TypeInteger.constant(987654)},TypeInteger.constant(123456),30);
+        var con = ConstantNode.raw(tfp);
+        var call = new CallNode(null,code._start,con,con);
+        // Diagnostic lookup may construct/intern the return-erased linker key.
+        con.toString();
+        org.junit.Assert.assertNull(call.name());
+
+        var fun = new FunNode(null,tfp,"printerTarget",null);
+        fun._name = "printerTarget";
+        fun.addDef(code._start);
+        code.link(fun);
+        var otherReturn = tfp.makeFrom(TypeInteger.constant(654321));
+        org.junit.Assert.assertSame(fun,code._link(otherReturn));
+        org.junit.Assert.assertTrue(con.toString().contains("printerTarget"));
+        assertEquals("printerTarget",call.name());
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen("""
+return 0;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  2));
+    }
+
+
+    @Test
+    public void testString() {
+        String src =
+"""
+struct String {
+    u8[~] !cs;
+    int _hashCode;
+    new String = { u8[~] s -> cs=s; };
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    for( int i=0; i< self.cs#; i++ )
+        hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+hashCode(new String("Hello, World!"));
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched);
+        assertEquals("Stop[ return Phi(Region,123456789,(!=0)Phi(Loop,0,(.[]+((Phi_hash<<5)-Phi_hash)))); return MEM[ 2:___ 3:___ 4:___ 5:.cs=Parm_s(Test.String.String,*[]u8[final]); 6:._hashCode=0;]; return MEM[ 2:___ 3:___ 4:___ 5:___ 6:._hashCode=0;]; return Test.String; return Phi(Region,0,1,0,1); return Phi(Region,(!=0)._hashCode,Phi(Region,123456789,(!=0)Phi(Loop,0,(.[]+((Phi_hash<<5)-Phi_hash))))); ]", code.print());
+        assertEquals("4029215624828139541", Eval2.eval(code,  2));
+    }
+
+    @Test
+    public void testTernaryStoreCall() {
+        String src =
+"""
+struct String {
+    u8[~] !cs;
+    int _hashCode;
+    new String = { u8[~] s -> cs=s; };
+};
+
+val f = { !String self -> 7; };
+
+val hashCode = { !String self ->
+    self._hashCode
+    ? 3
+    : (self._hashCode = f(self));
+};
+
+hashCode(new String("Hello"));
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched);
+        assertFalse(code.print().contains("return Top"));
+        assertEquals("7", Eval2.eval(code, 2));
+    }
+
+    @Test
+    public void testBasic0() {
+        CodeGen code = new CodeGen("return 0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testBasic1() {
+        CodeGen code = new CodeGen("return arg+1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (inc,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic2() {
+        CodeGen code = new CodeGen("return -17;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return -17;", code.print());
+    }
+
+
+    @Test
+    public void testBasic3() {
+        CodeGen code = new CodeGen("return arg==1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (set==,(cmp,arg));", code.print());
+    }
+
+    @Test
+    public void testBasic4() {
+        CodeGen code = new CodeGen("return arg<<1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (shli,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic5() {
+        CodeGen code = new CodeGen("return arg >> 1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (sari,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic6() {
+        CodeGen code = new CodeGen("return arg >>> 1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (shri,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic7() {
+        CodeGen code = new CodeGen("return arg / 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (div,arg,2);", code.print());
+    }
+
+    @Test
+    public void testBasic8() {
+        CodeGen code = new CodeGen("return arg * 6;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (muli,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic9() {
+        CodeGen code = new CodeGen("return arg & 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (andi,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic10() {
+        CodeGen code = new CodeGen("return arg | 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (ori,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic11() {
+        CodeGen code = new CodeGen("return arg ^ 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (xori,arg);", code.print());
+    }
+
+    @Test
+    public void testBasic12() {
+        CodeGen code = new CodeGen("return arg + 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (addf,(cvtf,arg),2.0f);", code.print());
+    }
+
+    @Test
+    public void testBasic13() {
+        CodeGen code = new CodeGen("return arg - 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (subf,(cvtf,arg),2.0f);", code.print());
+    }
+
+    @Test
+    public void testBasic14() {
+        CodeGen code = new CodeGen("return arg * 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mulf,(cvtf,arg),2.0f);", code.print());
+    }
+
+    @Test
+    public void testBasic15() {
+        CodeGen code = new CodeGen("return arg / 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mulf,(cvtf,arg),0.5f);", code.print());
+    }
+
+    @Test
+    public void testBasic16() {
+        CodeGen code = new CodeGen(
+"""
+int arg1 =  arg + 1;
+return arg1 / arg;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (div,(inc,arg),arg);", code.print());
+    }
+
+    @Test
+    public void testBasic17() {
+        CodeGen code = new CodeGen(
+"""
+int arg1 =  arg + 1;
+return arg1 * arg;
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mul,(inc,arg),arg);", code.print());
+    }
+
+    @Test
+    public void testToFloat() {
+        CodeGen code = new CodeGen("""
+int a = arg;
+return a + 2.0;
+"""
+        ).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (addf,(cvtf,arg),2.0f);", code.print());
+    }
+
+    @Test
+    public void testIfStmt() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+if (arg == 1)
+    a = arg+2;
+else {
+    a = arg-3;
+}
+return a;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Region,(addi,arg),(addi,arg));", code.print());
+    }
+
+    @Test
+    public void testIfMerge2() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg+1;
+int b=arg+2;
+if( arg==1 )
+    b=b+a;
+else
+    a=b+1;
+return a+b;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (add,(add,Phi(Region,(shli,arg),arg),arg),Phi(Region,4,5));", code.print());
+    }
+
+    @Test
+    public void testLoop() {
+        CodeGen code = new CodeGen(
+"""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return sum;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Loop,0,(add,Phi_sum,Phi(Loop,0,(inc,Phi_i))));", code.print());
+    }
+
+    @Test
+    public void testAlloc1() {
+        CodeGen code = new CodeGen(
+"""
+struct _S { int a; !_S? !c; };
+return new _S;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Test._S;", code.print());
+    }
+
+    @Test
+    public void testLea1() {
+        CodeGen code = new CodeGen("int x = arg/3; return arg+x+7;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testLea2() {
+        CodeGen code = new CodeGen("int x = arg/3; return arg+x*4+7;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testLea3() {
+        CodeGen code = new CodeGen("int x = arg/3; return x*4+arg;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testAlloc2() {
+        CodeGen code = new CodeGen("int[] !xs = new int[3]; xs[arg]=1; return xs[arg&1];");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testAlloc3() {
+        CodeGen code = new CodeGen("int[] !xs = new int[3]; xs[arg]=1; return xs[arg&1]+3;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testArray1() {
+        CodeGen code = new CodeGen(
+"""
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<ary#; i++ )
+    ary[i] = i;
+// Fill [0,1,3,6,10,...]
+for( int i=0; i<ary#-1; i++ )
+    ary[i+1] += ary[i];
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testArray2() {
+        CodeGen code = new CodeGen(
+"""
+flt[] !A = new flt[arg], !B = new flt[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<A#; i++ )
+    A[i] = i;
+for( int i=0; i<A#; i++ )
+    B[i] += A[i];
+return 0;
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testArray3() {
+        CodeGen code = new CodeGen(
+"""
+byte[] !A = new byte[arg];
+for( int i=0; i<A#; i++ )
+    A[i]++;
+return A[1];
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testNewton() throws IOException {
+        String src =
+"""
+val _test_sqrt = { flt x ->
+    flt epsilon = 1e-15;
+    flt guess = x;
+    while( 1 ) {
+        flt next = (x/guess + guess)/2;
+        if( guess-epsilon <= next & next <= guess+epsilon ) return guess;
+        //if( guess==next ) return guess;
+        guess = next;
+    }
+};
+flt farg = arg;
+return _test_sqrt(farg);
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Loop,(cvtf,arg),(mulf,(addf,Phi_guess,(divf,cvtf,Phi_guess)),0.5f));", code.print());
+    };
+
+
+    @Test
+    public void sieveOfEratosthenes() {
+        String src =
+"""
+val sieve = { int N ->
+    // The main Sieve array
+    bool[] !ary = new bool[N];
+    // The primes less than N
+    u32[] !primes = new u32[N>>1];
+    // Number of primes so far, searching at index p
+    int nprimes = 0, p=2;
+    // Find primes while p^2 < N
+    while( p*p < N ) {
+        // skip marked non-primes
+        while( ary[p] ) p++;
+        // p is now a prime
+        primes[nprimes++] = p;
+        // Mark out the rest non-primes
+        for( int i = p + p; i < ary#; i+= p )
+            ary[i] = true;
+        p++;
+    }
+
+    // Now just collect the remaining primes, no more marking
+    for( ; p < N; p++ )
+        if( !ary[p] )
+            primes[nprimes++] = p;
+
+    // Copy/shrink the result array
+    u32[] !rez = new u32[nprimes];
+    for( int j=0; j < nprimes; j++ )
+        rez[j] = primes[j];
+    return rez;
+};
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("Stop[ return { sieve}; return []u32; ]", code.print());
+        //assertEquals("{ ptr i64 -> *[]u32 #[ 3]}",Eval2.eval(code, 20));
+    }
+
+
+    @Test
+    public void testFcn1() {
+        CodeGen code = new CodeGen(
+"""
+val _fcn = arg ? { int x -> x*x; } : { int x -> x+x; };
+return _fcn(2)*10 + _fcn(3);
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("Stop[ return (add,#2,(muli,#2)); return (mul,Parm_x($fun3,[2-3]),x); return (shli,Parm_x($fun4,[2-3])); ]", code.print());
+    }
+
+    @Test
+    public void testFcn2() {
+        CodeGen code = new CodeGen(
+"""
+val _sq = { int x -> x*x; };
+return _sq(arg) + _sq(3);
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (addi,(mul,arg,arg));", code.print());
+    }
+}