From 0dcd3513a633479ce228f24826db4f09e4c0fc8b Mon Sep 17 00:00:00 2001 From: Cliff Click Date: Mon, 16 Nov 2026 14:25:14 -0800 Subject: Phi fix Fix Phi/Add refactoring peephole to canonicalize regardless of peephole order. Treat class fcns as having `self` be the class pointer --- chapter32/README.md | 103 +++++++++++++++++++++ chapter32/docs/32-grammar.md | 10 +- .../java/com/seaofnodes/simple/node/CallNode.java | 15 ++- .../java/com/seaofnodes/simple/node/PhiNode.java | 39 ++++++-- .../com/seaofnodes/simple/node/RegionNode.java | 3 +- .../com/seaofnodes/simple/node/SummaryNode.java | 11 ++- .../com/seaofnodes/simple/parser/Expressions.java | 3 + .../com/seaofnodes/simple/parser/Functions.java | 14 ++- .../com/seaofnodes/simple/parser/References.java | 55 ++++------- .../java/com/seaofnodes/simple/Chapter05Test.java | 35 +++++++ .../java/com/seaofnodes/simple/Chapter20Test.java | 4 +- .../java/com/seaofnodes/simple/Chapter21Test.java | 8 +- .../java/com/seaofnodes/simple/Chapter22Test.java | 6 +- .../seaofnodes/simple/GlobalAssignmentTest.java | 71 ++++++++++++++ .../java/com/seaofnodes/simple/ReceiverTest.java | 93 +++++++++++++++++++ .../seaofnodes/simple/SeparateCompilationTest.java | 2 +- 16 files changed, 405 insertions(+), 67 deletions(-) create mode 100644 chapter32/src/test/java/com/seaofnodes/simple/GlobalAssignmentTest.java create mode 100644 chapter32/src/test/java/com/seaofnodes/simple/ReceiverTest.java (limited to 'chapter32') diff --git a/chapter32/README.md b/chapter32/README.md index f06b404f..7a814966 100644 --- a/chapter32/README.md +++ b/chapter32/README.md @@ -460,6 +460,109 @@ must be rebuilt; an old header produces an explicit rebuild error. For an existing chapter32 build, `make clean` followed by `make -j 8 release` rebuilds the generated artifacts. Rebuild any separately maintained Simple libraries too. +## Receiver backport and spill investigation + +The shared class receiver is taught in +[chapter 28a](../chapter28a/README.md#globals-use-the-same-receiver-as-fields), +with imported summaries in [chapter 28b](../chapter28b/README.md). +Those fixes are carried through the later snapshots. Phi factoring after +strength reduction starts in +[chapter 5](../chapter05/README.md#factoring-after-strength-reduction), using +multiply-by-two there and shift-by-one where that representation is introduced. + +The receiver investigation also exposed a missed notification in +[RegionNode](src/main/java/com/seaofnodes/simple/node/RegionNode.java): flattening +regions adds Phi inputs, so their definitions must be queued too. A newly added +precise memory user can require its bulk-memory input to split immediately. +That prerequisite accompanies the receiver backport. + +The following measurements describe the chapter32 investigation before backporting. + +Validation: all 817 test executions pass on Windows with log8 verification and +Linux with the default log10. A focused 62-test run passes with log1, checking +every progress step. Native callbacks, imported receivers, FileIO, and ARM/RISC-V +execution remain covered. + +There is a compilation/code-size cost to review. The following Windows comparison +uses the preceding uncommitted assignment fix as its baseline, assertions enabled, +two JVM processors, seed 456, and each compiler's freshly built libraries. Times +are medians of four warm rounds after discarding the first round; this is a small +local sample, not a timing guarantee. Sys sizes sum its 22 object files. + +| Compile | Time, ms (before → after) | Peepholes (before → after) | `.text` bytes (before → after) | +| --- | ---: | ---: | ---: | +| sys | 961 → 977 | 185,960 → 208,552 | 37,725 → 40,355 | +| Clock | 256 → 381 | 86,873 → 106,615 | 6,717 → 7,053 | +| Breakout | 553 → 593 | 158,712 → 174,500 | 14,868 → 15,031 | +| TicTacToe | 161 → 177 | 56,222 → 63,774 | 4,251 → 4,411 | + +The small String and HelloWorld examples also retain additional initialization +checks, and their spill expectations have been updated. The receiver-only change +exposed an existing ordering sensitivity in Sieve: across seeds 120–127, both +compilers produced seven 28-split/343-weight results and one 26-split/215-weight +result, with the smaller result moving from seed 126 to 121. + +The spill investigation separates compile time from generated moves: Clock's +weighted split score improves from 785 to 762. These scores count all retained +SplitNodes, including register copies, with weight `8^loopDepth`; they are not +counts of stack spills. Sieve's 215-to-343 change is two extra register copies +inside its depth-two loop. Early `p+p` strength reduction in +[AddNode](src/main/java/com/seaofnodes/simple/node/AddNode.java) turns the entry +value into `p<<1` before [PhiNode](src/main/java/com/seaofnodes/simple/node/PhiNode.java) +can factor `Phi(p+p,i+p)` into `Phi(p,i)+p`. + +Phi factoring now views `x<<1` as `x+x` when matching mixed Add/Shl arms. It uses +the existing factoring checks and trial graph, without expanding a shift into +an Add that would immediately strength-reduce again. Pure shift arms retain +ordinary shift factoring. Multiply-by-two already reduces to this shift, so it +is covered too. This is a local canonicalization: peeling one `x` from `k*x` for +arbitrary k would require a new `(k-1)*x` expression, with less clear cost and +rewrite-order benefits. The implementation stops at doubling. + +All eight Sieve seeds now produce 26 splits and score 215, with every-step +verification; the spill expectation is 215. Direct graph tests check factoring +before and after strength reduction, either arm order, and rejection of a +different shift count. The 819-test Windows sweep passes with log8 verification +(the Sieve group rerun after updating its expectation), and 64 focused tests +pass with log1. Native and emulator Sieve results are checked too. + +The largest individual sys increase in the receiver-only comparison was +`Canvas._circle`, from 455 to 517. +Allocation keeps the loop-invariant boolean in a general register and the pixel +pointer in an XMM register; recovering the pointer adds a transfer at each pixel +store. The baseline makes the opposite choice. Both ranges receive the default +score 1000 in [IFG.pickRiskyScore](src/main/java/com/seaofnodes/simple/codegen/IFG.java), +leaving their selection sensitive to ordering. An isolated trial giving SetX86 +candidates one extra priority point brings `_circle` to 454 and total sys to +8869, versus baseline 8719 and current 8932. Other sys functions' weighted scores +are unchanged by that trial. This identifies an allocator sensitivity; the +opcode-specific preference is diagnostic, not an adopted heuristic. + +With Phi factoring fixed, sys's weighted score is 8850 and `_circle` returns to +455 through another ordering change. Clock stays at 762, Breakout changes from +3387 to 3393, and TicTacToe stays at 1468. A bounded allocator follow-up tried +three cheap refinements of the default score: breaking ties toward fewer excess +neighbors (degree minus available colors), toward more excess neighbors, and a +bonus for cheap single-def/single-use splits based on loop depth. Sys scored +9039, 8844, and 8850 respectively; the three games were unchanged. The tiny +six-point gain does not justify adopting the degree tie-break on this evidence. +The production allocator remains unchanged; no additional graph walks or +searches were added. + +Backporting retains each chapter's allocator. Code-quality expectations are +therefore checked locally: chapter21's RISC-V Sieve score changes from 92 to +164, despite the chapter32 improvement above, and chapter31's forward-field +scanner test changes from 23 to 31 on x86-64/Win64. Execution checks remain in +place; these earlier snapshots do not inherit the later allocator experiments. +Chapter31 also groups `TimeTest` with its sys tests: its wide-library compile +passes in a fresh JVM, but following the large catch-all suite exhausted that +snapshot's existing 16-bit type IDs. This keeps the checks and the older type +implementation intact; it does not remove the compiler's type-ID limit. + +The saved baseline, comparison drivers, measurements, and verification logs are +under `build/receiver-profile/`. Proving initialization checks redundant is the +main follow-up suggested by these measurements. + ## Build and test From `chapter32`, using the existing offline dependency caches: diff --git a/chapter32/docs/32-grammar.md b/chapter32/docs/32-grammar.md index 2628f566..4a794341 100644 --- a/chapter32/docs/32-grammar.md +++ b/chapter32/docs/32-grammar.md @@ -69,6 +69,7 @@ constructorParameter : type '^'? bindingModifier? IDENTIFIER ; // A method is an ordinary fixed function binding in a struct definition. // The compiler supplies self; it is not written in parameterList. // Function types and expressions both receive their implicit receiver here. +// Global functions use their owning class singleton as self. methodDeclaration : 'val' bindingModifier? memberName '=' functionExpression ';' ; memberName : IDENTIFIER | primitiveType ; @@ -254,10 +255,11 @@ one-pass IR builder: - A statement beginning with `{` might be a block or a function-type binding. `Declarations` and `Types` use speculative parsing and cursor restore; qualified type lookup also stops before a suffix that belongs to an expression. -- Bare assignment, field assignment, and compound updates share the grammar's - precedence but use different IR paths. `References` decides between an SSA - local, a constructor field's local value, and an actual memory access. A - function-valued field may also supply an implicit receiver to a call. +- `References` resolves bare fields through their receiver, so assignments, + reads, and updates share the field-access path. Locals use SSA; class + initializer declarations retain their Scope values until initializer exit. + Global functions receive their owning class singleton as `self`, including + when invoked through a callback. Instance methods receive their object. - `for` updates are scanned first and parsed after the body, where their effects belong. Explicit constructor bodies are scanned first and parsed after field discovery, so later fields have local slots. Both use `Lexer.skipTo`, which diff --git a/chapter32/src/main/java/com/seaofnodes/simple/node/CallNode.java b/chapter32/src/main/java/com/seaofnodes/simple/node/CallNode.java index 3b2dc75b..5506621b 100644 --- a/chapter32/src/main/java/com/seaofnodes/simple/node/CallNode.java +++ b/chapter32/src/main/java/com/seaofnodes/simple/node/CallNode.java @@ -7,6 +7,7 @@ import com.seaofnodes.simple.parser.Parser; import com.seaofnodes.simple.codegen.CodeGen; import com.seaofnodes.simple.codegen.Iter; import com.seaofnodes.simple.type.Type; +import com.seaofnodes.simple.type.TypePtr; import com.seaofnodes.simple.type.TypeMemPtr; import com.seaofnodes.simple.type.TypeFunPtr; import com.seaofnodes.simple.type.TypeMem; @@ -95,13 +96,15 @@ public class CallNode extends CFGNode { // A broad scalar target can refine to a function pointer during Iter. // It cannot yet promise that the call exposes nothing. if( _type!=Type.CONTROL ) return TypeMem.BOT; - if( !(fptr()._type instanceof TypeFunPtr) ) + if( !(fptr()._type instanceof TypeFunPtr tfp) ) return fptr()._type.isHigh() ? TypeMem.START : TypeMem.BOT; if( Intrinsic.pure(this) ) return TypeMem.START; if( !external() ) return TypeMem.START; Type input = dep.addDepForwards(mem())._type; TypeMem escaped = input instanceof TypeMem m ? m : input.isHigh() ? TypeMem.TOP : TypeMem.BOT; - for( int i = 2; i0 && tfp.arg(0)==TypePtr.PTR ? 3 : 2; i0 && sig.arg(0)==TypePtr.PTR ? 3 : 2; + } @Override boolean _upgradeType(HashMap types) { TypeTuple state = (TypeTuple)_state.upgradeType(types); if( state==_state ) return false; diff --git a/chapter32/src/main/java/com/seaofnodes/simple/parser/Expressions.java b/chapter32/src/main/java/com/seaofnodes/simple/parser/Expressions.java index ffc96f57..f791a34c 100644 --- a/chapter32/src/main/java/com/seaofnodes/simple/parser/Expressions.java +++ b/chapter32/src/main/java/com/seaofnodes/simple/parser/Expressions.java @@ -36,6 +36,9 @@ final class Expressions { { P.pos(old); return parseExpression(); } P.references.checkAssignment(def,site); + // All fields use the same receiver-based lvalue path. + if( P.references.fieldSelf(def)!=null ) + { P.pos(old); return parseExpression(); } return P.references.assign(def,parseAssignment()); } diff --git a/chapter32/src/main/java/com/seaofnodes/simple/parser/Functions.java b/chapter32/src/main/java/com/seaofnodes/simple/parser/Functions.java index 84bd509e..a7726521 100644 --- a/chapter32/src/main/java/com/seaofnodes/simple/parser/Functions.java +++ b/chapter32/src/main/java/com/seaofnodes/simple/parser/Functions.java @@ -36,7 +36,7 @@ final class Functions { Type self = P.types.implicitSelfType(); if( P.structs.inStructDeclaration() ) self = self.makeRO(); ts.push(self); - ids.push(self == TypePtr.PTR ? "#self" : "self"); + ids.push("self"); // Parse other arguments P._lexer.skipWhiteSpace(); @@ -130,6 +130,10 @@ final class Functions { P._lexer.skipWhiteSpace(); Lexer nameLoc=P.loc(); String id = P.requireId(); + // Older free functions may explicitly name a source argument + // "self". It shadows the implicit class receiver, not its ABI slot. + if( id=="self" && ts.at(0)==TypePtr.PTR && ids.at(0)=="self" ) + ids.set(0,"#self"); if( ids.find(id)!=-1 ) throw Parser.error("Duplicate parameter '"+id+"'",nameLoc); ts .push(t ); // Push type/arg pairs ids.push(id); @@ -359,6 +363,14 @@ final class Functions { if( i == 0 && ids[0].equals("self") && !FunNode.isInit(funName) && !(sig.ret() instanceof TypeMem) && t instanceof TypeMemPtr ptr ) t = ptr.withAccess(false); + // The body sees its owning class receiver. PTR remains in the + // signature as the ABI marker for a receiver with no machine slot. + if( i==0 && t==TypePtr.PTR ) { + TypeStruct clz = ((TypeMemPtr)fun.defaultArg(i))._obj; + // A file can add globals after its struct declaration closes. + // Keep this view open until SCCP installs the completed class. + t = TypeMemPtr.make((byte)2,TypeStruct.make(clz._name,true,clz._fields),true); + } // Args take a default input if called from Start/external-world Type seed = i == 0 && t instanceof TypeMemPtr ? t : fun.defaultArg(i); Node parm = new ParmNode(ids[i],i+2,t,fun,ConstantNode.seed(seed).peephole()).peephole(); diff --git a/chapter32/src/main/java/com/seaofnodes/simple/parser/References.java b/chapter32/src/main/java/com/seaofnodes/simple/parser/References.java index 7724103e..91cf6859 100644 --- a/chapter32/src/main/java/com/seaofnodes/simple/parser/References.java +++ b/chapter32/src/main/java/com/seaofnodes/simple/parser/References.java @@ -93,23 +93,9 @@ final class References { // Check for a function-escaping variable; these require true // closures. Final constants are OK; final vars require a hidden var // argument; not-final fields can just use an explicit struct arg. - if( kx < fx && !P.structs.inExplicitConstructor() && // Out of scope - !(var._final && rvalue._type.isConstant()) ) { // Not a final constant - if( kx > 0 ) // Global scope is OK, only ever one of these (not one per function invoke) - throw Parser.error("Variable '"+var._name+"' is out of function scope and must be a final constant",site); - - // var.idx==2 is self argument, 3 is args, 4 or more are now static globals - if( var._idx >= 4 ) { - // Read from global scope. - // Surely a nicer way to get the top-level scope compile name? - Var clzptr = P._scope.var( 2 ); - // Get the most recent sharpen global - TypeStruct clz = (TypeStruct) Parser.TYPES.get( ((TypeMemPtr) clzptr.type())._obj._name ); - TypeMemPtr clztmp = TypeMemPtr.make( (byte) 2, clz, true ); - return parseField( P.con( clztmp ), id,pre ); - //return parseField(_scope.in(2),id); - } - } + if( kx>0 && kx """; // Return the public hashCode wrapper; keep its helper private. testCPU(src,"x86_64_v2", "SystemV",28,null); - testCPU(src,"riscv" , "SystemV",8,null); - testCPU(src,"arm" , "SystemV",6,null); + testCPU(src,"riscv" , "SystemV",11,null); + testCPU(src,"arm" , "SystemV",11,null); } @Test diff --git a/chapter32/src/test/java/com/seaofnodes/simple/Chapter21Test.java b/chapter32/src/test/java/com/seaofnodes/simple/Chapter21Test.java index 347f2ce4..7a59adb0 100644 --- a/chapter32/src/test/java/com/seaofnodes/simple/Chapter21Test.java +++ b/chapter32/src/test/java/com/seaofnodes/simple/Chapter21Test.java @@ -386,8 +386,8 @@ val hashCode = { !String self -> """; // Return the public hashCode wrapper; keep its helper private. testCPU(src,"x86_64_v2", "SystemV",28,null); - testCPU(src,"riscv" , "SystemV",8,null); - testCPU(src,"arm" , "SystemV",6,null); + testCPU(src,"riscv" , "SystemV",11,null); + testCPU(src,"arm" , "SystemV",11,null); } @Test public void testStringExport() throws IOException { @@ -533,8 +533,8 @@ val sieve = { int N -> String sprimes = sb.p("]").toString(); // Compile, link against native C; expect the above string of primes to be printed out by C - // Load/Phi hoisting now requires the pointer before the loop entry. - TestC.runC(src, "sieve", sprimes,216); + // Phi factoring also recognizes p<<1 after p+p strength reduction. + TestC.runC(src, "sieve", sprimes,215); // Evaluate on RISC5 emulator; expect return of an array of primes in // the simulated heap. diff --git a/chapter32/src/test/java/com/seaofnodes/simple/Chapter22Test.java b/chapter32/src/test/java/com/seaofnodes/simple/Chapter22Test.java index c9791de4..f9146ae6 100644 --- a/chapter32/src/test/java/com/seaofnodes/simple/Chapter22Test.java +++ b/chapter32/src/test/java/com/seaofnodes/simple/Chapter22Test.java @@ -302,17 +302,17 @@ val p = { u8[~] str -> p("Hello, World!"); return 0; """; - TestC.runSF(src,"helloWorld", "Hello, World!",2); + TestC.runSF(src,"helloWorld", "Hello, World!",4); // Evaluate on RISC5 emulator - EvalRisc5 R5 = TestRisc5.build( src, "helloWorld", 0, 5, false); + EvalRisc5 R5 = TestRisc5.build( src, "helloWorld", 0, 8, false); int trap = R5.step(100); assertEquals(0,trap); assertEquals(0,R5.regs[riscv.A0]); assertEquals("Hello, World!",R5._stdout.toString()); // Evaluate on ARM emulator - EvalArm64 arm = TestArm64.build("helloWorld", src,0, 5, false); + EvalArm64 arm = TestArm64.build("helloWorld", src,0, 8, false); trap = arm.step(100); assertEquals(0,trap); assertEquals(0,arm.regs[0]); diff --git a/chapter32/src/test/java/com/seaofnodes/simple/GlobalAssignmentTest.java b/chapter32/src/test/java/com/seaofnodes/simple/GlobalAssignmentTest.java new file mode 100644 index 00000000..51ed10c6 --- /dev/null +++ b/chapter32/src/test/java/com/seaofnodes/simple/GlobalAssignmentTest.java @@ -0,0 +1,71 @@ +package com.seaofnodes.simple; + +import com.seaofnodes.simple.codegen.CodeGen; +import com.seaofnodes.simple.parser.Parser; +import org.junit.Test; +import static org.junit.Assert.*; + +public class GlobalAssignmentTest { + private static final String SOURCE = """ + int value=1; + int writes=0; + u8 small=0; + val set={int n -> value=n; return value;}; + val set_noInline={int n -> + if( n<0 ) value=3; + else value=n; + return value; + }; + val rhs_noInline={ -> writes=writes+1; return value+1;}; + val shadow={int value -> value=42; return value;}; + struct Writer { + int seen; + new Writer={int n -> value=n; seen=value;}; + }; + struct InitWriter { int seen=(value=17); }; + val main={ -> + if( set(5)!=5 || value!=5 ) return 1; + if( set_noInline(-1)!=3 || value!=3 ) return 2; + if( set_noInline(8)!=8 || value!=8 ) return 3; + int result=(value=rhs_noInline()); + if( result!=9 || value!=9 || writes!=1 ) return 4; + value=writes=11; + if( value!=11 || writes!=11 ) return 5; + if( shadow(0)!=42 || value!=11 ) return 6; + int wide=(small=257); + if( wide!=257 || small!=1 ) return 7; + val constructed=new Writer(13); + if( value!=13 || constructed.seen!=13 ) return 8; + val initialized=new InitWriter; + // Default expressions run at declaration time, not per instance. + if( value!=13 || initialized.seen!=17 ) return 9; + return 0; + }; + return main(); + """; + + @Test public void storesGlobalMemory() throws Exception { + assertEquals("0",Eval2.eval(new CodeGen(SOURCE).driver(CodeGen.Phase.TypeCheck),0)); + TestC.runSF(SOURCE,"global_assignment","",-1); + } + + @Test public void rejectsFinalGlobal() { + try { + new CodeGen("val value=1; val set={ -> value=2; }; return set();") + .driver(CodeGen.Phase.TypeCheck); + fail("Assigned a final global"); + } catch( Parser.ParseException e ) { + assertEquals("Cannot reassign final 'value'",e.getMessage()); + } + } + + @Test public void rejectsIncompatibleGlobalValue() { + try { + new CodeGen("struct S { int x; }; int value=1; val set={ -> value=new S; }; set(); return value;") + .driver(CodeGen.Phase.TypeCheck); + fail("Stored an object in an integer global"); + } catch( Parser.ParseException expected ) { + assertTrue(expected.getMessage(),expected.getMessage().contains("not of declared type")); + } + } +} diff --git a/chapter32/src/test/java/com/seaofnodes/simple/ReceiverTest.java b/chapter32/src/test/java/com/seaofnodes/simple/ReceiverTest.java new file mode 100644 index 00000000..83bf6768 --- /dev/null +++ b/chapter32/src/test/java/com/seaofnodes/simple/ReceiverTest.java @@ -0,0 +1,93 @@ +package com.seaofnodes.simple; + +import com.seaofnodes.simple.codegen.*; +import com.seaofnodes.simple.type.TypeInteger; +import com.seaofnodes.simple.util.Ary; +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.Test; +import static org.junit.Assert.*; + +public class ReceiverTest { + @Test public void classAndInstanceFields() throws Exception { + String source=""" + int total=1; + val forward={ -> late(); }; + val early={ -> total; }; + val late={ -> early(); }; + val add_noInline={int n -> self.total=self.total+n; return total;}; + val read_noInline={ -> self.total; }; + val nested={ -> + val inc={ -> self.total++; }; + inc(); + return total; + }; + struct Counter { + int total=100; + val read=read_noInline; + }; + struct Writer { + int count=2; + val step={ -> self.count++; total=count; return total; }; + }; + val table=new u16[~2]{7,9}; + val lookup={u8 c -> c<2 ? table[c] : 0;}; + val main={ -> + total=1; + if( forward()!=1 ) return 4; + if( lookup(1)!=9 || lookup(2)!=0 ) return 5; + if( add_noInline(5)!=6 || nested()!=7 ) return 1; + val counter=new Counter; + if( counter.read()!=7 || counter.total!=100 ) return 2; + val a=new Writer, b=new Writer; + if( a.step()!=3 || total!=3 || a.count!=3 || b.count!=2 ) return 3; + return 0; + }; + return main(); + """; + assertEquals("0",Eval2.eval(new CodeGen(source).driver(CodeGen.Phase.TypeCheck),0)); + TestC.runSF(source,"class_instance_receivers","",-1); + } + + @Test public void importedCallbackKeepsItsClass() throws Exception { + Path build=Path.of("build/objs/receivers"); + Files.createDirectories(build); + Path lib=Files.createTempDirectory(build,"classes-"); + new CodeGen(null,lib.toString(),null,"Owner", + "int value=7; val get_noInline={ -> self.value; };",123,true,TypeInteger.BOT) + .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false); + new CodeGen(null,lib.toString(),null,"Forwarder", + "int value=99; val apply_noInline={ {int} action -> action()+self.value; };",123,true,TypeInteger.BOT) + .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false); + var paths=new Ary<>(new String[]{lib.toString()}); + String source="return Forwarder.apply_noInline(Owner.get_noInline)==106 ? 0 : 1;"; + CodeGen code=new CodeGen(null,null,paths,"ReceiverClient",source,123,true,TypeInteger.BOT) + .driver(CodeGen.Phase.TypeCheck); + assertEquals("0",Eval2.eval(code,0)); + TestC.run(source,"imported_receivers",paths,TestC.CALL_CONVENTION,null,null,"",-1); + } + + @Test public void classReceiverHasNoNativeArgument() throws Exception { + String source=""" + int base=10; + val calc={int a,int b,int c,int d,int e,int f,int g -> + self.base+a+2*b+3*c+4*d+5*e+6*f+7*g; + }; + val callback_noInline={int n -> self.base+n;}; + { {int -> i64} int -> i64 } invoke="C"; + val viaC={int n -> invoke(callback_noInline,n);}; + """; + Path build=Path.of("build/objs/receivers"); + Files.createDirectories(build); + Path driver=build.resolve("native_receiver.c"); + Files.writeString(driver,""" + typedef long long (__attribute__((CALL_CONV)) *action_t)(int); + __attribute__((CALL_CONV)) long long invoke(action_t action, int n) { return action(n); } + __attribute__((CALL_CONV)) extern long long calc(int,int,int,int,int,int,int); + __attribute__((CALL_CONV)) extern long long viaC(int); + int main(void) { return calc(1,2,3,4,5,6,7)!=150 || viaC(5)!=15; } + """); + TestC.run(source,"native_receiver",null,TestC.CALL_CONVENTION, + TestC.CALL_CONVENTION.equals("win64") ? "ms_abi" : "sysv_abi",driver.toString(),"",-1); + } +} diff --git a/chapter32/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java b/chapter32/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java index 404201e3..cc4e552f 100644 --- a/chapter32/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java +++ b/chapter32/src/test/java/com/seaofnodes/simple/SeparateCompilationTest.java @@ -16,7 +16,7 @@ public class SeparateCompilationTest { Path lib=Files.createTempDirectory(build,"wide-memory-"); StringBuilder source=new StringBuilder("int f0=7;\n"); for( int i=1; i<300; i++ ) source.append("int f").append(i).append("=0;\n"); - source.append("val touch={int n -> f299+=n; return f0+f299;};"); + source.append("val touch={int n -> f299=n; return f0+f299;};"); new CodeGen(null,lib.toString(),null,"Wide",source.toString(),123,true,TypeInteger.BOT) .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false); var paths=new Ary<>(new String[]{lib.toString()}); -- cgit v1.2.3