summaryrefslogtreecommitdiff
path: root/chapter31/src
diff options
context:
space:
mode:
Diffstat (limited to 'chapter31/src')
-rw-r--r--chapter31/src/main/c/simple_crt.c13
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java6
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/ElfWriter.java15
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java4
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/Serialize.java6
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/StaticData.java10
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/ArrayInitNode.java28
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java24
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/CallEndNode.java4
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/CallNode.java3
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/EscapeNode.java6
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/Intrinsic.java119
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/MemOpNode.java3
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/Node.java4
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/BitCastARM.java23
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java1
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/BitCastRISC.java23
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/SplitRISC.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java1
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/BitCastX86.java23
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/NegFX86.java25
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java6
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/Allocations.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/ArrayInitializers.java10
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/Conversions.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/print/ASMPrinter.java11
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/Type.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAry.java147
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryB.java20
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryI.java16
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/TypeFloat.java8
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/type/TypeStruct.java11
-rw-r--r--chapter31/src/main/smp/sys.smp1
-rw-r--r--chapter31/src/main/smp/sys/adt/bitset.smp4
-rw-r--r--chapter31/src/main/smp/sys/ary.smp4
-rw-r--r--chapter31/src/main/smp/sys/aryi64.smp6
-rw-r--r--chapter31/src/main/smp/sys/aryu8.smp8
-rw-r--r--chapter31/src/main/smp/sys/draw.smp6
-rw-r--r--chapter31/src/main/smp/sys/draw/Button.smp38
-rw-r--r--chapter31/src/main/smp/sys/draw/Canvas.smp74
-rw-r--r--chapter31/src/main/smp/sys/libc.smp8
-rw-r--r--chapter31/src/main/smp/sys/math.smp15
-rw-r--r--chapter31/src/main/smp/sys/rt/simple_args.smp2
-rw-r--r--chapter31/src/main/smp/sys/text.smp74
-rw-r--r--chapter31/src/main/smp/sys/time.smp162
-rw-r--r--chapter31/src/main/smp/sys/time/Timers.smp40
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java2
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ArrayInitTest.java36
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/AssemblyDumpTest.java61
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java163
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/BulkMemPhiTest.java25
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java2
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ConstantArrayTest.java123
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ConvertNodeTest.java2
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/Eval2.java7
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/FloatNegationNativeTest.java21
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java69
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/IntrinsicTest.java188
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/TypeTest.java20
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java24
61 files changed, 1437 insertions, 328 deletions
diff --git a/chapter31/src/main/c/simple_crt.c b/chapter31/src/main/c/simple_crt.c
index 438ae5f9..39708629 100644
--- a/chapter31/src/main/c/simple_crt.c
+++ b/chapter31/src/main/c/simple_crt.c
@@ -6,6 +6,19 @@
#include <termios.h>
#include <unistd.h>
+// Fixed-semantics compiler intrinsics. Keep these definitions for indirect
+// calls; direct calls may inline to representation-preserving register moves.
+int64_t simple_f64_bits(double value) {
+ int64_t bits;
+ memcpy(&bits, &value, sizeof(bits));
+ return bits;
+}
+double simple_f64_from_bits(int64_t bits) {
+ double value;
+ memcpy(&value, &bits, sizeof(value));
+ return value;
+}
+
// errno may be thread-local or a macro calling a platform accessor.
int32_t simple_errno(void) { return errno; }
int32_t simple_set_errno(int32_t error) { errno = error; return -1; }
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
index b4c93e1e..8618b47b 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
@@ -786,7 +786,11 @@ public class CodeGen {
public boolean _asmLittle=true;
public String asm() { return asm(new SB()).toString(); }
SB asm(SB sb) {
- ASMPrinter.print(sb,this);
+ if( _encodings.isEmpty() ) ASMPrinter.print(sb,this);
+ else for( var entry : _encodings.entrySet() ) {
+ sb.p("\n=== Compilation unit: ").p(entry.getKey()._cname).p(" ===\n");
+ ASMPrinter.print(sb,this,entry.getValue());
+ }
return sb;
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/ElfWriter.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/ElfWriter.java
index fcf5c287..c5b25be0 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/ElfWriter.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/ElfWriter.java
@@ -318,11 +318,15 @@ public class ElfWriter {
_strtab = new StringSection();
// place all the symbols
+ Encoding enc = _code._encoding;
int nlocals = 1/*null*/+9/*number of sections*/+1/*Simple section*/;
+ int debugLocals=0;
+ for( StaticData.ObjectData obj : enc._data.objects.values() )
+ if( !obj.external ) debugLocals+=obj.debugNames.size();
+ nlocals+=debugLocals;
SymbolSection symbols = new SymbolSection(nlocals);
// we've already constructed these entire sections in the encoding phase
- Encoding enc = _code._encoding;
// Append ELF-only thunks to a copy. Export must not change instruction
// offsets or the image used by the in-memory linker and emulators.
BAOS textBits = new BAOS(enc._bits.toByteArray(),enc._bits.size());
@@ -402,10 +406,17 @@ public class ElfWriter {
SimpleSection simple = new SimpleSection(_code._serial);
// Write the local section header symbols
- assert nlocals == 1+_sections._len;
+ assert nlocals == 1+_sections._len+debugLocals;
symbols.symbol("",0,0,0); // Null symbol at index 0
for( Section s : _sections )
symbols.symbol(s._name, s._index, SYM_BIND_LOCAL, SYM_TYPE_SECTION, 0, s.size());
+ // Local aliases describe the pooled object without changing linkage.
+ // Several source constants may name the same bytes.
+ for( StaticData.ObjectData obj : enc._data.objects.values() )
+ if( !obj.external )
+ for( String name : obj.debugNames )
+ symbols.symbol(name,obj.readOnly ? rodata._index : rwdata._index,
+ SYM_BIND_LOCAL,SYM_TYPE_OBJECT,obj.offset,obj.size);
int size = 64; // ELF header size
// size of all section data
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
index 985cd4d2..f4acb729 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
@@ -65,8 +65,10 @@ public class IterPeeps {
* Iterate peepholes and inlining to a fixed point
*/
public void iterate( CodeGen code ) {
+ assert !CodeGen.expensiveAssert(0) || (progressOnList(code, _work) && schedulableUses(code));
boolean didInline = false;
Ary<Node> defer = new Ary<>(Node.class);
+
while( true ) {
// Clean up everything that does not grow the code
iteratePeeps(code);
@@ -97,8 +99,6 @@ public class IterPeeps {
// Run all the code-reduction and type-lifting peeps as possible
private void iteratePeeps( CodeGen code ) {
- assert !CodeGen.expensiveAssert(0) || (progressOnList(code, _work) && schedulableUses(code));
-
Node n;
while( (n = _work.pop()) != null ) {
if( n.isDead() ) continue;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
index 3991cd48..1b335c50 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
@@ -215,7 +215,7 @@ public class RegAlloc {
_deferredLoopSelf.clear();
for( byte round=0; !graphColor(round); round++ ) {
split(round);
- if( round >= 7 ) {
+ if( round >= 10 ) {
FunNode fun = _cfg.at(0).fun();
throw new IllegalStateException("Register allocation failed after eight rounds in "+
(fun==null ? "<root>" : fun.label()));
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/Serialize.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/Serialize.java
index 79bebe1f..b168c4af 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/Serialize.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/Serialize.java
@@ -448,7 +448,11 @@ public class Serialize {
// TYPES names the mutable array declaration. Read-only arrays in
// imported signatures keep their own types, but must not replace that
// declaration: closeOver looks up its mutable variant by name.
- if( ts.isAry() ) ts = ts.replace(ts.field("[]").makeFrom(false));
+ if( ts.isConAry() ) {
+ TypeConAry ary=(TypeConAry)ts.field("[]")._t;
+ ts=TypeStruct.makeAry(ts._name,TypeInteger.U32,ts.field("#")._alias,
+ ary.storageType(),ts.field("[]")._alias,false);
+ } else if( ts.isAry() ) ts = ts.replace(ts.field("[]").makeFrom(false));
Parser.TYPES.put(ts._name,ts);
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/StaticData.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/StaticData.java
index 5d1a519b..3d3a40dd 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/StaticData.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/StaticData.java
@@ -14,7 +14,10 @@ public final class StaticData {
public final String symbol;
public final boolean readOnly, external;
public final int alignment, size;
+ // Source names are aliases, not part of the object's pooling identity.
+ final TreeSet<String> debugNames = new TreeSet<>();
public int offset;
+ public String label() { return debugNames.isEmpty() ? symbol : String.join(", ",debugNames); }
ObjectData(Type t, String name, boolean ro, boolean ext) {
type=t; symbol=name; readOnly=ro; external=ext;
alignment=t.alignment();
@@ -73,7 +76,12 @@ public final class StaticData {
// Register before following fields: class objects may refer to each other.
if( !obj.external && t instanceof TypeStruct ts )
for( Field f : ts._fields )
- if( !f._extern && f._t.isConstant() ) target(f._t);
+ if( !f._extern && f._t.isConstant() ) {
+ target(f._t);
+ if( clz && f._final && f._t instanceof TypeMemPtr ptr &&
+ pointerConstant(ptr) && !isClass(ptr._obj) )
+ object(ptr._obj).debugNames.add(ts._name.substring(TypeStruct.CLZ.length())+"."+f._fname);
+ }
return obj;
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/ArrayInitNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/ArrayInitNode.java
index 30f86ac6..c6ae90ea 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/ArrayInitNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/ArrayInitNode.java
@@ -22,7 +22,33 @@ public final class ArrayInitNode extends Node {
}
@Override public String label() { return "ArrayInit"; }
@Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p("arrayInit(").n(in(2)).p(")"); }
- @Override public Type compute() { return in(0)._type==Type.CONTROL ? in(2)._type : Type.TOP; }
+ @Override public Type compute() {
+ if( in(0)._type != Type.CONTROL ) return Type.TOP;
+ Type ptr = in(2)._type;
+ if( _count < 0 ) return ptr;
+ // A list is strict in all its inputs. Wait for every input before
+ // choosing a constant payload or falling to the ordinary array type.
+ // Otherwise one SCCP worklist order can return PtrTop (or an array)
+ // before another unresolved input sends the result back up to Top.
+ if( ptr.isHigh() || in(3)._type.isHigh() ) return Type.TOP;
+ for( int i = 4; i < nIns(); i++ )
+ if( in(i)._type.isHigh() ) return Type.TOP;
+ if( !(ptr instanceof TypeMemPtr tmp) ) return ptr;
+ Field body = tmp._obj.field("[]");
+ if( body == null || !body._final || !(body._t instanceof TypeInteger storage) ) return ptr;
+ if( !(in(3)._type instanceof TypeInteger length) || !length.isConstant() || length.value() != _count ) return ptr;
+ long[] values = new long[_count];
+ for( int i = 0; i < _count; i++ ) {
+ Type value = in(i+4)._type;
+ if( !(value instanceof TypeInteger integer) || !integer.isConstant() ) return ptr;
+ values[i] = integer.value();
+ }
+ TypeConAry contents = TypeConAry.make(storage,values);
+ TypeStruct array = TypeStruct.makeAry(tmp._obj._name,tmp._obj.field("#")._alias,body._alias,contents);
+ // The surrounding ReadOnlyNode supplies the public view. Keep this
+ // node's access flags consistent when its contents cease to be constant.
+ return TypeMemPtr.make((byte)2,array,true).withAccess(tmp._ro);
+ }
@Override public Node idealize() { return null; }
@Override public Parser.ParseException err() {
if( in(0)._type==Type.XCONTROL ) return null;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
index 130b631c..b49163e7 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
@@ -261,15 +261,35 @@ public class BulkMemPhiNode extends PhiNode {
mphi = new MemPhiNode(ScopeNode.memName(alias),alias);
mphi.addDef(region());
// Due to cycles, must set before calling peephole
- // Splitting preserves the bulk Phi's established escape bound. Starting
- // at BOT would temporarily invent escapes when the new slice is merged.
+ // An escaped slice must preserve the bulk Phi's established bound.
+ // An unescaped slice was excluded from that summary: include the
+ // facts hidden in predecessor slices before wiring any cyclic Phis.
TypeMem old = (TypeMem)_type;
+ if( !XInt.bit(old._escAs,alias) )
+ old = (TypeMem)old.meet(sliceBound(this,alias,new BitSet()));
mphi.setType(TypeMem.make(alias,old._t,old._one,old._clz,false,old._escFs,old._escAs));
for( int i=1; i<nIns(); i++ )
mphi.addDef(CodeGen.CODE.add(preciseInput(in(i),alias)));
return CodeGen.CODE.add(mphi);
}
+ // A bulk summary ignores unescaped slots in MemMerge inputs. Follow the
+ // same slots that splitting will expose, including across loop backedges.
+ // A visited cycle contributes TOP; its incoming definitions supply the bound.
+ private static TypeMem sliceBound(Node mem, int alias, BitSet visit) {
+ if( visit.get(mem._nid) ) return TypeMem.TOP;
+ visit.set(mem._nid);
+ if( mem instanceof MemMergeNode merge )
+ return sliceBound(merge.alias(alias),alias,visit);
+ if( mem instanceof BulkMemPhiNode bulk ) {
+ TypeMem bound = TypeMem.TOP;
+ for( int i = 1; i < bulk.nIns(); i++ )
+ bound = (TypeMem)bound.meet(sliceBound(bulk.in(i),alias,visit));
+ return bound;
+ }
+ return mem._type instanceof TypeMem bound ? bound : TypeMem.BOT;
+ }
+
MemPhiNode _findPhi(int alias) {
for( Node use : region().outs() )
if( use instanceof MemPhiNode mphi && mphi._alias==alias )
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/CallEndNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/CallEndNode.java
index b5156c2d..108dd024 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/CallEndNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/CallEndNode.java
@@ -85,6 +85,8 @@ public class CallEndNode extends CFGNode implements MultiNode {
return ftype.isHigh() ? TypeTuple.STATE.dual() : TypeTuple.STATE;
// Mid-fold, just take the inlined callee's return.
if( _folding ) return in(1)._type;
+ TypeTuple intrinsic=Intrinsic.compute(call,this);
+ if( intrinsic!=null ) return intrinsic;
// The outside continuation reads Start directly: Call can remain
// CONTROL while its possible returned identities change.
@@ -135,6 +137,8 @@ public class CallEndNode extends CFGNode implements MultiNode {
}
public byte maybeInline() {
+ byte intrinsic=Intrinsic.tryInline(this);
+ if( intrinsic>0 ) return intrinsic;
byte inline = inlineCandidate(false);
if( CodeGen.CODE._midAssert )
return inline;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/CallNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/CallNode.java
index ac5e4eee..690acfb9 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/CallNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/CallNode.java
@@ -97,6 +97,7 @@ public class CallNode extends CFGNode {
if( _type!=Type.CONTROL ) return TypeMem.BOT;
if( !(fptr()._type instanceof TypeFunPtr) )
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;
@@ -241,6 +242,8 @@ public class CallNode extends CFGNode {
return Parser.error("Expected a function, but found " + fptr()._type, _loc);
if( !tfp.notNull() )
return Parser.error( "Might be null calling "+tfp, _loc);
+ Parser.ParseException intrinsic=Intrinsic.err(this);
+ if( intrinsic!=null ) return intrinsic;
if( nargs() != tfp.nargs() )
return Parser.error( "Expecting "+(tfp.nargs()-1)+" arguments, but found "+(nargs()-1), _loc);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/EscapeNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
index 57340609..a8a6151c 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
@@ -64,6 +64,10 @@ public class EscapeNode extends TypeNode {
@Override
public Type compute() {
+ // A static constant array has no private heap writes to publish.
+ // This depends on its type, regardless of which node produced it.
+ if( self()!=null && self()._type instanceof TypeMemPtr ptr &&
+ ptr.isConstant() && ptr._obj.isConAry() ) return pub()._type;
if( priv()._type.isHigh() ) return TypeMem.TOP;
if( pub ()._type.isHigh() ) return TypeMem.TOP;
TypeMem mpriv = (TypeMem)priv()._type;
@@ -100,6 +104,8 @@ public class EscapeNode extends TypeNode {
}
@Override public Node idealize() {
+ if( self()._type instanceof TypeMemPtr ptr && ptr.isConstant() && ptr._obj.isConAry() )
+ return pub();
// Sharpen private memory input
if( priv() instanceof MemMergeNode mmm ) {
setDef(2,mmm.alias(fld()._alias));
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/Intrinsic.java b/chapter31/src/main/java/com/seaofnodes/simple/node/Intrinsic.java
new file mode 100644
index 00000000..82626507
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/Intrinsic.java
@@ -0,0 +1,119 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.parser.Parser;
+import com.seaofnodes.simple.type.*;
+
+// Fixed-semantics C functions. Recognition, effects and expansion live here;
+// Call/CallEnd only delegate. These symbols also have ordinary C definitions
+// for calls whose target is not known at compile time.
+public final class Intrinsic {
+ private Intrinsic() {}
+
+ private enum Op {
+ F64_BITS("simple_f64_bits",TypeFloat.F64,TypeInteger.BOT,true),
+ F64_FROM_BITS("simple_f64_from_bits",TypeInteger.BOT,TypeFloat.F64,true);
+
+ final String symbol;
+ final Type arg, ret;
+ final boolean pure;
+ Op(String symbol, Type arg, Type ret, boolean pure) {
+ this.symbol=symbol; this.arg=arg; this.ret=ret; this.pure=pure;
+ }
+ boolean signature(TypeFunPtr fp) {
+ // Slot zero is the implicit receiver, omitted by the C ABI.
+ return fp.nargs()==2 && fp.arg(1)==arg && fp.ret()==ret;
+ }
+ Expansion expand(CallNode call) {
+ Node value=switch(this) {
+ case F64_BITS -> new F64BitsNode(call.arg(3)).peephole();
+ case F64_FROM_BITS -> new F64FromBitsNode(call.arg(3)).peephole();
+ };
+ return new Expansion(call.ctrl(),call.mem(),value);
+ }
+ }
+
+ private static Op lookup(CallNode call) {
+ if( !(call.fptr()._type instanceof TypeFunPtr fp) || !fp.notNull() || !fp.isConstant() ) return null;
+ String symbol=CodeGen.CODE.externFunc(fp.fidx());
+ if( symbol==null ) return null; // A Simple function with this name is ordinary code.
+ for( Op op : Op.values() ) if( op.symbol.equals(symbol) ) return op;
+ return null;
+ }
+
+ public static Parser.ParseException err(CallNode call) {
+ Op op=lookup(call);
+ return op==null || op.signature(call.tfp()) ? null : Parser.error(
+ "Intrinsic '"+op.symbol+"' requires { "+op.arg.str()+" -> "+op.ret.str()+" }",call._loc);
+ }
+
+ // Both initial operations are pure and expose no references. Future atomic
+ // operations need their own memory/escape semantics, not this passthrough.
+ public static boolean pure(CallNode call) {
+ Op op=lookup(call);
+ return op!=null && op.pure && op.signature(call.tfp());
+ }
+
+ public static TypeTuple compute(CallNode call, Node dep) {
+ if( !pure(call) ) return null;
+ return TypeTuple.make(Type.CONTROL,dep.addDep(call.mem())._type,call.tfp().ret());
+ }
+
+ // An expansion replaces the complete call state, even for a pure value op.
+ private record Expansion(Node control, Node memory, Node value) {
+ void replace(CallEndNode end) {
+ Node[] state={control,memory,value};
+ for( Node n : state ) n.keep();
+ end.keep();
+ for( Node use : end._outputs.asAry() ) {
+ if( use==null ) continue; // Our temporary keep.
+ assert use instanceof Proj;
+ use.subsume(state[((Proj)use).idx()]);
+ }
+ end.unkill();
+ for( Node n : state ) n.unkill();
+ CodeGen.CODE.invalidateIDepthCaches();
+ }
+ }
+
+ // Same cheap-inlining worklist as ordinary functions, but no body/Return,
+ // cloning, size heuristic, or import loading is needed.
+ public static byte tryInline(CallEndNode end) {
+ if( end.folding() || !(end.in(0) instanceof CallNode call) ) return 0;
+ Op op=lookup(call);
+ if( op==null || !op.signature(call.tfp()) || call.nargs()!=call.tfp().nargs() ||
+ !end.goodArgs(call,call.tfp()) ) return 0;
+ if( !CodeGen.CODE._midAssert ) op.expand(call).replace(end);
+ return 1;
+ }
+
+ public abstract static class BitCastNode extends Node {
+ BitCastNode(Node value) { super(null,value); }
+ public abstract boolean toBits();
+ @Override public Type compute() {
+ Type input=in(1)._type;
+ Type result=toBits() ? TypeInteger.BOT : TypeFloat.F64;
+ if( input.isHigh() ) return result.dual();
+ if( toBits() && input instanceof TypeFloat f && f.isConstant() )
+ return TypeInteger.constant(Double.doubleToRawLongBits(f.value()));
+ if( !toBits() && input instanceof TypeInteger i && i.isConstant() )
+ return TypeFloat.constant(Double.longBitsToDouble(i.value()));
+ return result;
+ }
+ @Override public Node idealize() {
+ return in(1) instanceof BitCastNode cast && cast.toBits()!=toBits() ? cast.in(1) : null;
+ }
+ }
+ public static final class F64BitsNode extends BitCastNode {
+ public F64BitsNode(Node value) { super(value); }
+ @Override public boolean toBits() { return true; }
+ @Override public Tag serialTag() { return Tag.F64Bits; }
+ @Override protected String format() { return "f64Bits(%1)"; }
+ }
+ public static final class F64FromBitsNode extends BitCastNode {
+ public F64FromBitsNode(Node value) { super(value); }
+ @Override public boolean toBits() { return false; }
+ @Override public Tag serialTag() { return Tag.F64FromBits; }
+ @Override protected String format() { return "f64FromBits(%1)"; }
+ }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/MemOpNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/MemOpNode.java
index 35183380..bce11b50 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/MemOpNode.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/MemOpNode.java
@@ -94,7 +94,8 @@ public abstract class MemOpNode extends TypeNode {
if( !(ptr()._type instanceof TypeMemPtr tmp) )
return Type.BOTTOM;
Field fld = tmp._obj.field(_name);
- return fld == null || fld._t == null ? Type.BOTTOM : fld._t;
+ return fld == null || fld._t == null ? Type.BOTTOM :
+ fld._t instanceof TypeConAry ary ? ary.storageType() : fld._t;
}
@Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return _printMach(p); }
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
index 2815dfba..d4c0794c 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -77,7 +77,7 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
New,Never,Not,Or,Parm,Phi,Proj,PtrToInt,
ReadOnly,Return,Region,RoundF32,
Sar,Shl,Shr,Start,StartCU,StopCU,Stop,Store,Sub,
- ToInteger,ToFloat,XCtrl,Xor;
+ ToInteger,ToFloat,XCtrl,Xor,F64Bits,F64FromBits;
public static final Tag[] VALS = values();
public Node make( BAOS bais, String[] strs, Type[] types, GlobalBits fileAliases, GlobalBits aliases ) {
return switch(this) {
@@ -103,6 +103,8 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
case Sub -> new SubNode(null,null,(byte)bais.packed1());
case ToFloat-> new ToFloatNode(null);
case ToInteger-> new ToIntegerNode(null);
+ case F64Bits-> new Intrinsic.F64BitsNode(null);
+ case F64FromBits-> new Intrinsic.F64FromBitsNode(null);
case XCtrl -> new XCtrlNode();
case Xor -> { int mode=bais.packed1(); assert mode==1; yield new XorNode(null,null,null); }
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/BitCastARM.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/BitCastARM.java
new file mode 100644
index 00000000..ec57b3f8
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/BitCastARM.java
@@ -0,0 +1,23 @@
+package com.seaofnodes.simple.node.cpus.arm;
+
+import com.seaofnodes.isa.Arm64;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.util.SB;
+
+// A representation move, with no arithmetic, rounding, or flag changes.
+public class BitCastARM extends MachConcreteNode implements MachNode {
+ private final boolean _toBits;
+ BitCastARM(Intrinsic.BitCastNode cast) { super(cast); _toBits=cast.toBits(); }
+ @Override public String op() { return _toBits ? "f64bits" : "f64frombits"; }
+ @Override public RegMask regmap(int i) { assert i==1; return _toBits ? arm.DMASK : arm.RMASK; }
+ @Override public RegMask outregmap() { return _toBits ? arm.WMASK : arm.DMASK; }
+ @Override public void encoding(Encoding enc) {
+ enc.add4(Arm64.f_mov_general(Arm64.OP_FMOV,0b01,0,_toBits ? 0b110 : 0b111,
+ enc.reg(in(1))-(_toBits ? arm.D_OFFSET : 0),
+ enc.reg(this)-(_toBits ? 0 : arm.D_OFFSET)));
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" = bits ").p(code.reg(in(1)));
+ }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
index ee7b0fc3..2d47edf5 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
@@ -350,6 +350,7 @@ public class arm extends Machine {
case StoreNode st -> st(st);
case SubNode sub -> sub.mode()==2 ? new SubFARM(sub) : sub(sub);
case ToFloatNode tfn -> new I2F8ARM(tfn);
+ case Intrinsic.BitCastNode cast -> new BitCastARM(cast);
case ToIntegerNode cvt -> new F8ToIARM(cvt);
case XorNode xor -> xor(xor);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/BitCastRISC.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/BitCastRISC.java
new file mode 100644
index 00000000..141ff7d5
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/BitCastRISC.java
@@ -0,0 +1,23 @@
+package com.seaofnodes.simple.node.cpus.riscv;
+
+import com.seaofnodes.isa.RiscV;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.util.SB;
+
+// A representation move, with no arithmetic, rounding, or flag changes.
+public class BitCastRISC extends MachConcreteNode implements MachNode {
+ private final boolean _toBits;
+ BitCastRISC(Intrinsic.BitCastNode cast) { super(cast); _toBits=cast.toBits(); }
+ @Override public String op() { return _toBits ? "f64bits" : "f64frombits"; }
+ @Override public RegMask regmap(int i) { assert i==1; return _toBits ? riscv.FMASK : riscv.RMASK; }
+ @Override public RegMask outregmap() { return _toBits ? riscv.WMASK : riscv.FMASK; }
+ @Override public void encoding(Encoding enc) {
+ enc.add4(RiscV.r_type(RiscV.OP_FP,
+ enc.reg(this)-(_toBits ? 0 : riscv.F_OFFSET),0,
+ enc.reg(in(1))-(_toBits ? riscv.F_OFFSET : 0),0,_toBits ? 0b1110001 : 0b1111001));
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" = bits ").p(code.reg(in(1)));
+ }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/SplitRISC.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/SplitRISC.java
index d455337b..de754393 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/SplitRISC.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/SplitRISC.java
@@ -47,7 +47,7 @@ public class SplitRISC extends SplitNode {
// FPR->FPR
src -= riscv.F_OFFSET;
dst -= riscv.F_OFFSET;
- enc.add4(RiscV.r_type(RiscV.OP_FP, dst, 0b000, src, src, 0b0010101)); // dst = FMIN(src,src)
+ enc.add4(RiscV.r_type(RiscV.OP_FP, dst, 0b000, src, src, 0b0010001)); // FSGNJ.D preserves NaN bits.
} else if(!srcX && dstX) {
//GPR->FPR
// fmv.d.x
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
index 378955a5..976d1a52 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
@@ -254,6 +254,7 @@ public class riscv extends Machine {
case StoreNode st -> st(st);
case SubNode sub -> sub.mode()==2 ? new SubFRISC(sub) : sub(sub);
case ToFloatNode tfn -> i2f8(tfn);
+ case Intrinsic.BitCastNode cast -> new BitCastRISC(cast);
case ToIntegerNode cvt -> new F8ToIRISC(cvt);
case XorNode xor -> xor(xor);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/BitCastX86.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/BitCastX86.java
new file mode 100644
index 00000000..bf550032
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/BitCastX86.java
@@ -0,0 +1,23 @@
+package com.seaofnodes.simple.node.cpus.x86_64_v2;
+
+import com.seaofnodes.isa.X86;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.util.SB;
+
+// A representation move, with no arithmetic, rounding, or flag changes.
+public class BitCastX86 extends MachConcreteNode implements MachNode {
+ private final boolean _toBits;
+ BitCastX86(Intrinsic.BitCastNode cast) { super(cast); _toBits=cast.toBits(); }
+ @Override public String op() { return _toBits ? "f64bits" : "f64frombits"; }
+ @Override public RegMask regmap(int i) { assert i==1; return _toBits ? x86_64_v2.XMASK : x86_64_v2.RMASK; }
+ @Override public RegMask outregmap() { return _toBits ? x86_64_v2.WMASK : x86_64_v2.XMASK; }
+ @Override public void encoding(Encoding enc) {
+ X86.move(enc,!_toBits,_toBits,
+ enc.reg(this)-(_toBits ? 0 : x86_64_v2.XMM_OFFSET),
+ enc.reg(in(1))-(_toBits ? x86_64_v2.XMM_OFFSET : 0));
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" = bits ").p(code.reg(in(1)));
+ }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/NegFX86.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/NegFX86.java
new file mode 100644
index 00000000..61662fd2
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/NegFX86.java
@@ -0,0 +1,25 @@
+package com.seaofnodes.simple.node.cpus.x86_64_v2;
+
+import com.seaofnodes.isa.X86;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeFloat;
+import com.seaofnodes.simple.util.SB;
+
+// Flip the sign bit, preserving signed zero, infinities, and NaN payloads.
+public class NegFX86 extends MachConcreteNode implements MachNode {
+ NegFX86(MinusNode neg) {
+ super(neg);
+ addDef(new FltX86(new ConstantNode(TypeFloat.constant(-0.0)),null));
+ }
+ @Override public String op() { return "negf"; }
+ @Override public RegMask regmap(int i) { assert i==1 || i==2; return x86_64_v2.XMASK; }
+ @Override public RegMask outregmap() { return x86_64_v2.XMASK; }
+ @Override public int twoAddress() { return 1; }
+ @Override public void encoding(Encoding enc) {
+ X86.sse(enc,0x66,0x0F57,false,enc.reg(this)-x86_64_v2.XMM_OFFSET,enc.reg(in(2))-x86_64_v2.XMM_OFFSET);
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" ^= ").p(code.reg(in(2))).p(" // sign bit");
+ }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
index aed8ee4c..dc15b185 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
@@ -294,6 +294,7 @@ public class x86_64_v2 extends Machine {
public Node instSelect(Node n) {
return switch (n) {
case AddNode add -> add(add);
+ case Intrinsic.BitCastNode cast -> new BitCastX86(cast);
case AndNode and -> and(and);
case BoolNode bool -> cmp(bool);
case CLInitNode init -> new CLInitNode(init);
@@ -310,10 +311,7 @@ public class x86_64_v2 extends Machine {
case IfNode iff -> jmp(iff);
case LoadNode ld -> ld(ld);
case MemMergeNode mem -> new MemMergeNode(mem);
- case MinusNode neg -> {
- if( neg.mode()==2 ) throw Utils.TODO();
- yield new NegX86(neg);
- }
+ case MinusNode neg -> neg.mode()==2 ? new NegFX86(neg) : new NegX86(neg);
case MulNode mul -> mul.mode()==2 ? new MulFX86(mul) : mul(mul);
case NewNode nnn -> new NewX86(nnn);
case NotNode not -> new NotX86(not);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/Allocations.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/Allocations.java
index 5c6b5765..64234045 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/Allocations.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/Allocations.java
@@ -124,7 +124,7 @@ final class Allocations {
TypeStruct ts = P.types.typeAry(TypeInteger.U8,true);
int lenAlias = ts.field("#" )._alias;
int elemAlias = ts.field("[]")._alias;
- TypeConAryB body = TypeConAryB.make(s);
+ TypeConAry body = TypeConAry.make(s);
TypeInteger slen = TypeInteger.constant(s.length);
// Make a TMP, not-null (byte)2, singleton (true) (requires text
// strings are hash-interned), with a TypeStruct having a constant
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/ArrayInitializers.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/ArrayInitializers.java
index 70eeae1f..079853cd 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/ArrayInitializers.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/ArrayInitializers.java
@@ -66,13 +66,15 @@ final class ArrayInitializers {
}
}
+ Node result=new ArrayInitNode(P.ctrl(),mem,self,len,
+ generator ? -1 : values.size(),site,values).peephole().keep();
Node prior=P.mem();
- P.mem(P.mergeAlias(prior,length._alias,new EscapeNode(length,self,slen.unkeep(),prior).peephole()));
+ P.mem(P.mergeAlias(prior,length._alias,new EscapeNode(length,result,slen.unkeep(),prior).peephole()));
prior=P.mem();
- P.mem(P.mergeAlias(prior,body._alias,new EscapeNode(body,self,mem,prior).peephole()));
- Node result=new ArrayInitNode(P.ctrl(),mem.unkeep(),self.unkeep(),len.unkeep(),
- generator ? -1 : values.size(),site,values).peephole();
+ P.mem(P.mergeAlias(prior,body._alias,new EscapeNode(body,result,mem,prior).peephole()));
+ mem.unkeep(); self.unkeep(); len.unkeep();
for( Node value : values ) value.unkeep();
+ result.unkeep();
return readonly ? new ReadOnlyNode(result).peephole() : result;
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/Conversions.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/Conversions.java
index fa11311d..72247ca6 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/Conversions.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/Conversions.java
@@ -37,7 +37,7 @@ final class Conversions {
case TypeFloat tf -> TypeFloat.F64;
case TypeMemPtr tmp -> tmp.makeVar();
case TypeFunPtr tfp -> tfp;
- case TypeConAry<?> a -> a;
+ case TypeConAry a -> a;
case TypePtr ptr -> TypePtr.PTR;
case TypeScalar ts -> TypeScalar.BOT;
default -> t;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/print/ASMPrinter.java b/chapter31/src/main/java/com/seaofnodes/simple/print/ASMPrinter.java
index bdd887e6..e4d1659d 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/print/ASMPrinter.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/print/ASMPrinter.java
@@ -16,13 +16,16 @@ import java.util.Map;
public final class ASMPrinter extends AssemblyAdapter<Node> {
private final CodeGen _code;
private final Encoding _enc;
- private ASMPrinter(CodeGen code) {
+ private ASMPrinter(CodeGen code, Encoding enc) {
super(new IRPrinter());
_code=code;
- _enc=code._encoding;
+ _enc=enc;
}
public static SB print(SB sb, CodeGen code) {
- return sb.p(new com.seaofnodes.print.ASMPrinter<>(new ASMPrinter(code)).print());
+ return print(sb,code,code._encoding);
+ }
+ public static SB print(SB sb, CodeGen code, Encoding enc) {
+ return sb.p(new com.seaofnodes.print.ASMPrinter<>(new ASMPrinter(code,enc)).print());
}
@Override public ArrayList<Node> blocks() {
var blocks=new ArrayList<Node>();
@@ -89,7 +92,7 @@ public final class ASMPrinter extends AssemblyAdapter<Node> {
var data=new ArrayList<Data>();
for( var obj : _enc._data.entries() )
if( !obj.external && obj.readOnly==ro )
- data.add(new Data(obj,obj.symbol+": "+obj.type.str(),obj.alignment,obj.size));
+ data.add(new Data(obj,obj.label()+": "+obj.type.str(),obj.alignment,obj.size));
return data;
}
// Retain this diagnostic entry point for checking that pool printing never lays out types.
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/Type.java b/chapter31/src/main/java/com/seaofnodes/simple/type/Type.java
index 0f655f49..2e228494 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/Type.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/type/Type.java
@@ -531,7 +531,7 @@ public class Type /*implements Cloneable*/ {
// tag-space except for the first tag-space which uses 1 tag for
// multiple Types instead of 1 Type having multiple tags. Has to
// be ordered to match _type enum.
- for( Type t : new Type[]{Type.XNIL,TypeScalar.BOT,TypePtr.PTR,TypeInteger.BOT,TypeFloat.F64,TypeConAryB.ABC,TypeRPC.BOT,TypeMemPtr.BOT,TypeFunPtr.BOT,TypeMem.BOT,Field.BOT,TypeStruct.BOT,TypeTuple.BOT} )
+ for( Type t : new Type[]{Type.XNIL,TypeScalar.BOT,TypePtr.PTR,TypeInteger.BOT,TypeFloat.F64,TypeConAry.ABC,TypeRPC.BOT,TypeMemPtr.BOT,TypeFunPtr.BOT,TypeMem.BOT,Field.BOT,TypeStruct.BOT,TypeTuple.BOT} )
TAGOFFS[t._type+1] = TAGOFFS[t._type] + t.TAGOFF();
assert TAGOFFS[TMAX] <= 255;
return TAGOFFS;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAry.java b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAry.java
index 9cb23e09..c10f09aa 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAry.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAry.java
@@ -1,33 +1,48 @@
package com.seaofnodes.simple.type;
import com.seaofnodes.simple.util.BAOS;
-import com.seaofnodes.simple.util.Utils;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.HashMap;
/**
- * Represents a constant array of primitives
+ * Constant integer contents with an explicit storage width and signedness.
*/
-public abstract class TypeConAry<A> extends TypeScalar {
+public final class TypeConAry extends TypeScalar {
boolean _any;
byte _widen;
- // One of byte or int array
- public final A _ary;
+ private final TypeInteger _storage;
+ private final long[] _ary;
- TypeConAry( boolean any, byte widen, A ary ) { super(TCONARY); _any = any; _widen = widen; _ary = ary; }
+ private TypeConAry(boolean any, byte widen, TypeInteger storage, long[] ary) {
+ super(TCONARY);
+ _any=any; _widen=widen; _storage=storage; _ary=ary;
+ }
+ static final TypeConAry ABC=make("abc");
+ static final TypeConAry ABCD=make("abcd");
public static void gather(ArrayList<Type> ts) {
- ts.add(TypeConAryB.make(""));
- ts.add(TypeConAryB.ABC);
- ts.add(TypeConAryB.ABCD);
- ts.add(TypeConAryI.I123);
+ ts.add(make(""));
+ ts.add(ABC);
+ ts.add(ABCD);
+ ts.add(make(TypeInteger.I32,new long[]{1,2,3}));
+ ts.add(make(TypeInteger.U16,new long[]{0,65535}));
+ ts.add(make(TypeInteger.BOT,new long[]{Long.MIN_VALUE,Long.MAX_VALUE}));
+ for( TypeInteger storage : STORAGE ) {
+ ts.add(make(storage,new long[0]));
+ ts.add(make(storage,new long[]{0,1}));
+ }
}
// Fresh, uninterned type sharing this array; xdual must not intern.
- abstract TypeConAry<A> _make(boolean any, byte widen);
+ private TypeConAry _make(boolean any, byte widen) {
+ return new TypeConAry(any,widen,_storage,_ary);
+ }
- @Override TypeConAry<A> xdual() { return _make( !_any, (byte)(3-_widen) ); }
+ @Override TypeConAry xdual() { return _make( !_any, (byte)(3-_widen) ); }
@Override Type xmeet(Type t) {
TypeConAry ary = (TypeConAry)t; // Invariant
+ if( len()==0 ) return emptyMeet(ary);
+ if( ary.len()==0 ) return ary.emptyMeet(this);
// Same base array but different?
if( _equals(ary) )
// Return array with larger widen
@@ -37,15 +52,7 @@ public abstract class TypeConAry<A> extends TypeScalar {
}
Type ymeet( TypeInteger ti ) {
- // Empty arrays have no observed elements: use the storage bounds.
- // Check both endpoints just as the loop checks a nonempty body;
- // retaining high integer inputs here preserves lattice duality.
- if( len()==0 ) {
- TypeInteger bound=emptyElem();
- if( !ti.isa(TypeInteger.make(bound._min,bound._min,ti._widen)) ||
- !ti.isa(TypeInteger.make(bound._max,bound._max,ti._widen)) )
- return ti.meet(bound);
- }
+ if( len()==0 ) return emptyMeet(ti);
// if i can isa *each* element, then maybe can keep.
// no good to i.isa(elem()) because fails the dual
for( int j=0; j<len(); j++ )
@@ -56,12 +63,21 @@ public abstract class TypeConAry<A> extends TypeScalar {
}
private boolean _equals(TypeConAry ary) {
- int len = len();
- if( len != ary.len() ) return false;
- for( int i=0; i<len; i++ )
- if( at8(i) != ary.at8(i) )
- return false;
- return true;
+ return _storage==ary._storage && (len()!=0 || _any==ary._any) && Arrays.equals(_ary,ary._ary);
+ }
+ @Override boolean eq(Type t) { return t instanceof TypeConAry ary && _widen==ary._widen && _equals(ary); }
+ @Override int hash() { return Arrays.hashCode(_ary)^_storage.hashCode()^(len()==0 && _any ? 1231 : 0); }
+ @Override public String str() {
+ boolean text=_storage==TypeInteger.U8;
+ for( long value : _ary )
+ if( value<32 || value>126 ) { text=false; break; }
+ if( !text ) {
+ String range=elem().str();
+ return range.startsWith("[") ? range : "["+range+"]";
+ }
+ byte[] bytes = new byte[len()];
+ for( int i=0; i<bytes.length; i++ ) bytes[i]=(byte)_ary[i];
+ return "[\""+new String(bytes)+"\"]";
}
@Override public boolean isHigh() { return this==TOP; }
@@ -70,8 +86,6 @@ public abstract class TypeConAry<A> extends TypeScalar {
// Meet-over-elements type
public Type elem() {
- if( _ary==null )
- return _any ? Type.TOP : BOTTOM;
int len = len();
long min = Long.MAX_VALUE;
if( len==0 ) return emptyElem();
@@ -83,23 +97,80 @@ public abstract class TypeConAry<A> extends TypeScalar {
return TypeInteger.make(min,max,_widen);
}
private TypeInteger emptyElem() {
- return log_size()==0 ? TypeInteger.make(0,255,_widen)
- : TypeInteger.make(Integer.MIN_VALUE,Integer.MAX_VALUE,_widen);
+ TypeInteger storage=storageType();
+ return _any ? TypeInteger.make(storage._min,storage._max,_widen)
+ : TypeInteger.make(storage._max,storage._min,_widen);
+ }
+ // Keep the empty payload distinct from its element bound. It sits just
+ // above the storage dual; its own dual sits just below the storage bound.
+ // This makes it a subtype of every constant array within those bounds,
+ // while preserving meet/join symmetry with ordinary integer ranges.
+ private Type emptyMeet(Type t) {
+ Type bound=emptyElem();
+ if( t.isa(bound) && (_any || t!=bound) ) return this;
+ return bound.meet(t);
}
- public abstract long at8(int idx);
- public abstract int len();
- @Override public abstract int log_size();
- public void write( BAOS baos ) { throw Utils.TODO("Should not reach here: abstract constant array cannot be written"); }
+ public TypeInteger storageType() { return _storage; }
+ public long at8(int idx) { return _ary[idx]; }
+ public int len() { return _ary.length; }
+ @Override public int log_size() { return _storage.log_size(); }
+ public void write( BAOS baos ) {
+ for( int i=0; i<len(); i++ ) {
+ long value=at8(i);
+ for( int b=0; b<(1<<log_size()); b++ ) baos.write((byte)(value >>> (8*b)));
+ }
+ }
+
+ /** Canonical contents, independent of the node which discovered them. */
+ public static TypeConAry make(TypeInteger storage, long[] values) {
+ long[] copy=values.clone();
+ int shift=64-(8<<storage.log_size());
+ for( int i=0; i<copy.length; i++ )
+ copy[i]=storage._min<0 ? (copy[i]<<shift)>>shift : copy[i]&storage._max;
+ return new TypeConAry(false,(byte)0,storage,copy).intern();
+ }
+ public static TypeConAry make(byte[] bytes) {
+ long[] values=new long[bytes.length];
+ for( int i=0; i<bytes.length; i++ ) values[i]=bytes[i]&255;
+ return new TypeConAry(false,(byte)0,TypeInteger.U8,values).intern();
+ }
+ public static TypeConAry make(String s) { return make(s.getBytes()); }
+
+ // Keep the existing byte-array tag and encoding. An impossible Java array
+ // length escapes to a typed payload, without renumbering later type tags.
+ private static final int TYPED = -1;
+ private static final TypeInteger[] STORAGE={TypeInteger.BOOL,TypeInteger.I8,TypeInteger.U8,
+ TypeInteger.I16,TypeInteger.U16,TypeInteger.I32,TypeInteger.U32,TypeInteger.BOT};
// Reserve tags for u8 array
@Override int TAGOFF() { return 1; }
@Override public void packed( BAOS baos, HashMap<String,Integer> strs ) {
- assert log_size()==0 && !_any;
baos.write(TAGOFFS[TCONARY]+0);
+ if( storageType()!=TypeInteger.U8 || _any || _widen!=0 ) {
+ baos.packed4(TYPED);
+ int kind=0;
+ while( kind<STORAGE.length && STORAGE[kind]!=storageType() ) kind++;
+ assert kind<STORAGE.length;
+ baos.packed1(kind);
+ baos.packed1((_any ? 4 : 0)|_widen);
+ }
baos.packed4(len());
- baos.write((byte[])_ary);
+ write(baos);
}
static TypeConAry packed( int tag, BAOS bais ) {
- return TypeConAryB.make(bais.read(new byte[bais.packed4()]));
+ int len=bais.packed4();
+ if( len!=TYPED ) return make(bais.read(new byte[len]));
+ TypeInteger storage=STORAGE[bais.packed1()];
+ int flags=bais.packed1();
+ long[] values=new long[bais.packed4()];
+ int size=1<<storage.log_size();
+ for( int i=0; i<values.length; i++ ) {
+ long value=0;
+ for( int b=0; b<size; b++ ) value|=(long)bais.read() << (8*b);
+ if( storage._min<0 && size<8 ) value=(value << (64-size*8)) >> (64-size*8);
+ values[i]=value;
+ }
+ TypeConAry ary=make(storage,values);
+ return flags==0 ? ary : ary._make((flags&4)!=0,(byte)(flags&3)).intern();
}
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryB.java b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryB.java
deleted file mode 100644
index 84be5fb2..00000000
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryB.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.seaofnodes.simple.type;
-
-import com.seaofnodes.simple.util.BAOS;
-import java.util.Arrays;
-
-public class TypeConAryB extends TypeConAry<byte[]> {
- private TypeConAryB(boolean any, byte widen, byte[] bs) { super(any,widen,bs); }
- @Override TypeConAryB _make( boolean any, byte widen ) { return new TypeConAryB(any,widen,_ary); }
- public static TypeConAryB make( byte[] bs ) { return new TypeConAryB(false,(byte)0,bs).intern(); }
- public static TypeConAryB make( String s ) { return make(s.getBytes()); }
- static final TypeConAryB ABC = make("abc");
- static final TypeConAryB ABCD = make("abcd");
- @Override public long at8(int idx) { return _ary[idx]&255; }
- @Override public int len() { return _ary.length; }
- @Override public int log_size() { return 0; }
- @Override public String str() { return "[\""+new String(_ary)+"\"]"; }
- @Override boolean eq(Type t) { return t instanceof TypeConAryB ary && _widen==ary._widen && Arrays.equals(_ary,ary._ary); }
- @Override int hash() { return Arrays.hashCode(_ary); }
- @Override public void write( BAOS baos ) { baos.write(_ary); }
-}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryI.java b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryI.java
deleted file mode 100644
index b1b061de..00000000
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeConAryI.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.seaofnodes.simple.type;
-
-import java.util.Arrays;
-
-public class TypeConAryI extends TypeConAry<int[]> {
- private TypeConAryI(boolean any, byte widen, int[] bs) { super(any,widen,bs); }
- public static TypeConAryI make( int[] bs ) { return new TypeConAryI(false,(byte)0,bs).intern(); }
- @Override TypeConAryI _make( boolean any, byte widen ) { return new TypeConAryI(any,widen,_ary); }
- static final TypeConAryI I123 = make(new int[]{1,2,3});
- @Override public long at8(int idx) { return _ary[idx]; }
- @Override public int len() { return _ary.length; }
- @Override public int log_size() { return 2; }
- @Override public String str() { return "[i32]"; }
- @Override boolean eq(Type t) { return t instanceof TypeConAryI ary && _widen==ary._widen && Arrays.equals(_ary,ary._ary); }
- @Override int hash() { return Arrays.hashCode(_ary); }
-}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeFloat.java b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
index d410e9cf..8d04fcbf 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
@@ -107,7 +107,7 @@ public class TypeFloat extends TypeScalar {
else {
assert isConstant();
baos.write(TAGOFFS[_type] + 2);
- baos.packed8(Double.doubleToLongBits(_con));
+ baos.packed8(Double.doubleToRawLongBits(_con));
}
}
@@ -121,12 +121,12 @@ public class TypeFloat extends TypeScalar {
}
@Override
- int hash() { return (int)(Double.hashCode(_con) ^ _sz ^ (1<<17)); }
+ int hash() { return Long.hashCode(Double.doubleToRawLongBits(_con)) ^ _sz ^ (1<<17); }
@Override
public boolean eq( Type t ) {
TypeFloat i = (TypeFloat)t; // Contract
- // Allow NaN to check for equality
- return _sz==i._sz && Double.doubleToLongBits(_con)==Double.doubleToLongBits(i._con);
+ // Representation conversions observe NaN signs/payloads and signed zero.
+ return _sz==i._sz && Double.doubleToRawLongBits(_con)==Double.doubleToRawLongBits(i._con);
}
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeStruct.java b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
index 7c9758bd..11ba3cc4 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
@@ -146,8 +146,7 @@ public class TypeStruct extends Type {
Type len = TypeInteger.constant(con.len());
return make(name,false,
Field.make("#" ,len , lenAlias,true),
- Field.make("[]" ,con.elem(),bodyAlias,true),
- Field.make("[con]",con ,bodyAlias,true));
+ Field.make("[]" ,con ,bodyAlias,true));
}
public TypeStruct makeInit() {
@@ -190,6 +189,9 @@ public class TypeStruct extends Type {
}
@Override TypeStruct _close( String name, HashMap<String, Type> TYPES ) {
assert (name==null) != (TYPES==null); // One or the other
+ // Primitive constant contents are already closed. Looking up their
+ // shared array name would discard the length and payload on import.
+ if( isConAry() ) return this;
String namePlusFinal = isAry() ? (_name+(_fields[1]._final ? "~" : "!")).intern() : _name;
TypeStruct ts = (TypeStruct)VISIT.get(namePlusFinal);
if( ts!=null ) return ts;
@@ -251,7 +253,7 @@ public class TypeStruct extends Type {
public static final TypeStruct TEST= make("test",false,Field.TEST);
private static final TypeStruct ARY = makeAry("[]i64",TypeInteger.U32,-1,TypeInteger.BOT,-2,false);
private static final TypeStruct STR = makeAry("[]u8" ,TypeInteger.U32,-1,TypeInteger.U8 ,-4,false);
- private static final TypeStruct ABC = makeAry("[]u8",-1,-4,TypeConAryB.ABC);
+ private static final TypeStruct ABC = makeAry("[]u8",-1,-4,TypeConAry.ABC);
// Representative unresolved forms for the exhaustive lattice tests:
// bare forward ref, forward ref constrained by a field use, and definition.
private static final TypeStruct FREF0 = forward("%FREF");
@@ -462,6 +464,7 @@ public class TypeStruct extends Type {
@Override public int log_size() { throw Utils.TODO("Should not reach here: structs have no scalar log size"); }
@Override public int size() { return offset(_fields.length); }
@Override public int alignment() {
+ if( isAry() ) return Math.max(2,aryScale()); // The length is always u32.
int align = 0;
for( Field f : _fields )
if( !f._extern ) align = Math.max(align, f._t.alignment());
@@ -607,7 +610,7 @@ public class TypeStruct extends Type {
int align = _fields[1]._t.alignment();
_offs[1] = (4 + ((1<<align)-1)) & -(1<<align);
if( _fields[1]._t instanceof TypeConAry ary ) // Array length is well-defined for constants, not defined for runtime arrays
- _offs[2] = _offs[1]+ary.len();
+ _offs[2] = _offs[1]+(ary.len()<<ary.log_size());
} else {
int[] cnts = new int[5]; // Count of fields at log field size
diff --git a/chapter31/src/main/smp/sys.smp b/chapter31/src/main/smp/sys.smp
index f7889c05..3fb8d94b 100644
--- a/chapter31/src/main/smp/sys.smp
+++ b/chapter31/src/main/smp/sys.smp
@@ -8,6 +8,7 @@ val aryi64 = aryi64; // Variable sized array of i64
val aryu8 = aryu8; // Variable sized array of u8
val char = char; // Character utilities
val integer = integer; // Integer bounds
+val math = math; // Floating-point representation primitives
val io = io; // IO library
val gfx = gfx; // Optional pixel window (MiniFB)
val draw = draw; // Software raster drawing in Simple
diff --git a/chapter31/src/main/smp/sys/adt/bitset.smp b/chapter31/src/main/smp/sys/adt/bitset.smp
index d02cd2fe..a51a63e1 100644
--- a/chapter31/src/main/smp/sys/adt/bitset.smp
+++ b/chapter31/src/main/smp/sys/adt/bitset.smp
@@ -20,7 +20,7 @@ struct bitset {
if( x < len ) return self;
while( x >= len ) len *= 2;
var bits = new i64[len];
- for( int i=0; i<_bits#; i++ )
+ for( int i = 0; i < _bits#; i++ )
bits[i] = _bits[i];
_bits = bits;
return self;
@@ -51,7 +51,7 @@ struct bitset {
};
val clear = { ->
- for( int i=0; i<_bits#; i++ ) _bits[i] = 0;
+ for( int i = 0; i < _bits#; i++ ) _bits[i] = 0;
return self;
};
};
diff --git a/chapter31/src/main/smp/sys/ary.smp b/chapter31/src/main/smp/sys/ary.smp
index 11ddb7a0..b94ffa8f 100644
--- a/chapter31/src/main/smp/sys/ary.smp
+++ b/chapter31/src/main/smp/sys/ary.smp
@@ -19,7 +19,7 @@ val copy = { u8[] dst, u32 doff, u8[~] src, u32 soff, u32 len ->
if( doff > dst# || soff > src# ) return dst;
if( len > dst# - doff ) len = dst# - doff;
if( len > src# - soff ) len = src# - soff;
- for( u32 i=0; i<len; i++ )
+ for( u32 i = 0; i < len; i++ )
dst[i+doff] = src[i+soff];
return dst;
};
@@ -33,7 +33,7 @@ val cmp = { u8[~] src1, u32 off1, u8[~] src2, u32 off2, u32 len ->
u32 len1 = len > left1 ? left1 : len;
u32 len2 = len > left2 ? left2 : len;
u32 max = len1 > len2 ? len2 : len1;
- for( u32 i=0; i<max; i++ )
+ for( u32 i = 0; i < max; i++ )
if( src1[off1+i] != src2[off2+i] )
return src1[off1+i] - src2[off2+i]; // Bytes determine compare
return len1 - len2; // Length determines compare
diff --git a/chapter31/src/main/smp/sys/aryi64.smp b/chapter31/src/main/smp/sys/aryi64.smp
index b9f1fbed..aba1b459 100644
--- a/chapter31/src/main/smp/sys/aryi64.smp
+++ b/chapter31/src/main/smp/sys/aryi64.smp
@@ -14,7 +14,7 @@ struct aryi64 {
u32 newlen = ary.capacity(buf#,len+len2);
if( !newlen ) libc._exit(1); // Length exceeds the array representation.
i64[] !buf2 = new i64[newlen];
- for( u32 i=0; i<len; i++ )
+ for( u32 i = 0; i < len; i++ )
buf2[i] = buf[i];
buf = buf2;
self;
@@ -32,7 +32,7 @@ struct aryi64 {
val str = { ->
// TODO: clunky default constructor syntax
var str = new aryu8().add('[');
- for( u32 i=0; i<len; i++ )
+ for( u32 i = 0; i < len; i++ )
str.num(buf[i]).add(',').add(' ');
if( len ) str.undo(2);
return str.add(']');
@@ -79,7 +79,7 @@ val copy = { i64[] dst, u32 doff, i64[~] src, u32 soff, u32 len ->
if( doff > dst# || soff > src# ) return dst;
if( len > dst# - doff ) len = dst# - doff;
if( len > src# - soff ) len = src# - soff;
- for( u32 i=0; i<len; i++ )
+ for( u32 i = 0; i < len; i++ )
dst[i+doff] = src[i+soff];
return dst;
};
diff --git a/chapter31/src/main/smp/sys/aryu8.smp b/chapter31/src/main/smp/sys/aryu8.smp
index 76d47ec5..3f462898 100644
--- a/chapter31/src/main/smp/sys/aryu8.smp
+++ b/chapter31/src/main/smp/sys/aryu8.smp
@@ -27,7 +27,7 @@ struct aryu8 {
// Add all of a plain array to the aryu8
val addAry = { u8[~] xs ->
- u32 n=xs#;
+ u32 n = xs#;
_grow(n);
ary.copy(buf,len,xs,0,n);
len += n;
@@ -60,7 +60,7 @@ val atoi = { u8[~] str ->
while( x < str# && str[x] <= ' ' ) x++;
if( x == str# ) return 0;
bool neg = false;
- if( str[x]=='-' ) { neg=true; x++; }
+ if( str[x] == '-' ) { neg = true; x++; }
i64 n = 0;
while( x < str# && '0' <= str[x] <= '9' )
n = n*10 + str[x++]-'0';
@@ -71,5 +71,5 @@ val atoi = { u8[~] str ->
{ u8[~] -> u8[] } str0 = { u8[~] str ->
if( str# == sys.integer.MAX_U32 ) libc._exit(1);
// Copy, terminate and return
- return new u8[str#+1]{i64 i -> i<str# ? str[i] : '\0'; };
-}; \ No newline at end of file
+ return new u8[str#+1]{i64 i -> i < str# ? str[i] : '\0'; };
+};
diff --git a/chapter31/src/main/smp/sys/draw.smp b/chapter31/src/main/smp/sys/draw.smp
index 61b250d3..2a8b6117 100644
--- a/chapter31/src/main/smp/sys/draw.smp
+++ b/chapter31/src/main/smp/sys/draw.smp
@@ -7,9 +7,9 @@ u32 BLUE = 0x0000ff;
// Components are clamped to bytes rather than wrapping.
val rgb = { int r, int g, int b ->
- r = r<0 ? 0 : r>255 ? 255 : r;
- g = g<0 ? 0 : g>255 ? 255 : g;
- b = b<0 ? 0 : b>255 ? 255 : b;
+ r = r < 0 ? 0 : r > 255 ? 255 : r;
+ g = g < 0 ? 0 : g > 255 ? 255 : g;
+ b = b < 0 ? 0 : b > 255 ? 255 : b;
u32 color = (r<<16) | (g<<8) | b;
return color;
};
diff --git a/chapter31/src/main/smp/sys/draw/Button.smp b/chapter31/src/main/smp/sys/draw/Button.smp
index edf01119..c90ed2d3 100644
--- a/chapter31/src/main/smp/sys/draw/Button.smp
+++ b/chapter31/src/main/smp/sys/draw/Button.smp
@@ -3,36 +3,36 @@
struct Button {
int x, y, width, height;
u8[~] !label;
- bool !enabled=true, !hovered=false, !pressed=false;
- bool !_held=false, !_armed=false;
+ bool !enabled = true, !hovered = false, !pressed = false;
+ bool !_held = false, !_armed = false;
new Button = { int px, int py, int w, int h, u8[~] text ->
- x=px; y=py; width=w; height=h; label=text;
+ x = px; y = py; width = w; height = h; label = text;
};
val contains = { i64 px, i64 py ->
- if( width<=0 || height<=0 ) return false;
- i64 right=x, bottom=y; right+=width; bottom+=height;
- if( px<x || py<y || px>=right || py>=bottom ) return false;
+ if( width <= 0 || height <= 0 ) return false;
+ i64 right = x, bottom = y; right += width; bottom += height;
+ if( px < x || py < y || px >= right || py >= bottom ) return false;
return true;
};
val update = { i64 px, i64 py, bool down ->
- hovered=false;
- if( enabled ) hovered=contains(px,py);
- if( !enabled ) _armed=false;
- if( down && !_held ) _armed=hovered;
- var clicked=false;
- if( !down ) if( _held ) if( _armed ) if( hovered ) clicked=true;
- if( !down ) _armed=false;
- _held=down;
- pressed=false;
- if( down ) if( _armed ) if( hovered ) pressed=true;
+ hovered = false;
+ if( enabled ) hovered = contains(px,py);
+ if( !enabled ) _armed = false;
+ if( down && !_held ) _armed = hovered;
+ var clicked = false;
+ if( !down ) if( _held ) if( _armed ) if( hovered ) clicked = true;
+ if( !down ) _armed = false;
+ _held = down;
+ pressed = false;
+ if( down ) if( _armed ) if( hovered ) pressed = true;
return clicked;
};
val draw = { !sys.draw.Canvas screen, int scale, u32 foreground, u32 background, u32 active ->
screen.fillRect(x,y,width,height,enabled && (hovered || pressed) ? active : background);
screen.rect(x,y,width,height,2,enabled ? foreground : active);
- if( scale>0 ) {
- i64 textWidth=label#; textWidth=(textWidth*4-1)*scale;
- if( textWidth<=width-8 && 5*scale<=height-8 )
+ if( scale > 0 ) {
+ i64 textWidth = label#; textWidth = (textWidth*4-1)*scale;
+ if( textWidth <= width-8 && 5*scale <= height-8 )
screen.text(x+(width-textWidth)/2,y+(height-5*scale)/2+(pressed ? 1 : 0),
label,scale,enabled ? foreground : active);
}
diff --git a/chapter31/src/main/smp/sys/draw/Canvas.smp b/chapter31/src/main/smp/sys/draw/Canvas.smp
index 5bd7d68e..2fbcf6ea 100644
--- a/chapter31/src/main/smp/sys/draw/Canvas.smp
+++ b/chapter31/src/main/smp/sys/draw/Canvas.smp
@@ -6,39 +6,39 @@ struct Canvas {
new Canvas = { int w, int h ->
i64 count = w;
count *= h;
- if( w<=0 || h<=0 || count>sys.integer.MAX_I32 ) libc._exit(1);
+ if( w <= 0 || h <= 0 || count > sys.integer.MAX_I32 ) libc._exit(1);
width = w;
height = h;
pixels = new u32[count];
};
val clear = { u32 color ->
- for( int i=0; i<pixels#; i++ ) pixels[i] = color;
+ for( int i = 0; i < pixels#; i++ ) pixels[i] = color;
return self;
};
val pixel = { i64 x, i64 y, u32 color ->
- if( 0<=x<width && 0<=y<height ) pixels[y*width+x] = color;
+ if( 0 <= x < width && 0 <= y < height ) pixels[y*width+x] = color;
return self;
};
// Integer coordinates, top-left origin. Rectangle extents are half-open.
val fillRect = { i64 x, i64 y, i64 w, i64 h, u32 color ->
- if( w<=0 || h<=0 ) return self;
+ if( w <= 0 || h <= 0 ) return self;
i64 right = x; right += w;
i64 bottom = y; bottom += h;
- if( right<=0 || bottom<=0 || x>=width || y>=height ) return self;
- int x0 = x<0 ? 0 : x, y0 = y<0 ? 0 : y;
- int x1 = right>width ? width : right, y1 = bottom>height ? height : bottom;
- for( int py=y0; py<y1; py++ )
- for( int px=x0; px<x1; px++ ) pixels[py*width+px] = color;
+ if( right <= 0 || bottom <= 0 || x >= width || y >= height ) return self;
+ int x0 = x < 0 ? 0 : x, y0 = y < 0 ? 0 : y;
+ int x1 = right > width ? width : right, y1 = bottom > height ? height : bottom;
+ for( int py = y0; py < y1; py++ )
+ for( int px = x0; px < x1; px++ ) pixels[py*width+px] = color;
return self;
};
// Outline stays inside the rectangle. Wide borders become a filled rect.
val rect = { i64 x, i64 y, i64 w, i64 h, i64 thickness, u32 color ->
- if( w<=0 || h<=0 || thickness<=0 ) return self;
- if( thickness>=w || thickness>=h || thickness>=w-thickness || thickness>=h-thickness )
+ if( w <= 0 || h <= 0 || thickness <= 0 ) return self;
+ if( thickness >= w || thickness >= h || thickness >= w-thickness || thickness >= h-thickness )
return fillRect(x,y,w,h,color);
fillRect(x,y,w,thickness,color);
fillRect(x,y+h-thickness,w,thickness,color);
@@ -54,23 +54,23 @@ struct Canvas {
return _circle(cx,cy,radius,thickness,false,color);
};
val _circle = { i64 cx, i64 cy, int radius, int thickness, bool filled, u32 color ->
- if( radius<0 || (!filled && thickness<=0) ) return self;
+ if( radius < 0 || (!filled && thickness <= 0) ) return self;
i64 left = cx; left -= radius;
i64 top = cy; top -= radius;
i64 right = cx; right += radius;
i64 bottom = cy; bottom += radius;
- if( right<0 || bottom<0 || left>=width || top>=height ) return self;
- int x0 = left<0 ? 0 : left, y0 = top<0 ? 0 : top;
- int x1 = right>=width ? width-1 : right, y1 = bottom>=height ? height-1 : bottom;
+ if( right < 0 || bottom < 0 || left >= width || top >= height ) return self;
+ int x0 = left < 0 ? 0 : left, y0 = top < 0 ? 0 : top;
+ int x1 = right >= width ? width-1 : right, y1 = bottom >= height ? height-1 : bottom;
i64 outer2 = radius;
outer2 *= radius;
i64 inner = filled ? -1 : radius-thickness;
- for( int py=y0; py<=y1; py++ )
- for( int px=x0; px<=x1; px++ ) {
+ for( int py = y0; py <= y1; py++ )
+ for( int px = x0; px <= x1; px++ ) {
i64 dx = px; dx -= cx;
i64 dy = py; dy -= cy;
i64 d2 = dx*dx+dy*dy;
- if( d2<=outer2 && (inner<=0 || d2>inner*inner) ) pixels[py*width+px] = color;
+ if( d2 <= outer2 && (inner <= 0 || d2 > inner*inner) ) pixels[py*width+px] = color;
}
return self;
};
@@ -78,17 +78,17 @@ struct Canvas {
// Round caps; a zero-length segment is a dot. Only the clipped bounding
// box is scanned. Floating distances avoid overflowing coordinate squares.
val line = { i64 x0, i64 y0, i64 x1, i64 y1, i64 thickness, u32 color ->
- if( thickness<=0 ) return self;
+ if( thickness <= 0 ) return self;
i64 pad = thickness/2+1;
- i64 left = x0<x1 ? x0 : x1; left -= pad;
- i64 top = y0<y1 ? y0 : y1; top -= pad;
- i64 right = x0>x1 ? x0 : x1; right += pad;
- i64 bottom = y0>y1 ? y0 : y1; bottom += pad;
- if( right<0 || bottom<0 || left>=width || top>=height ) return self;
- int bx0 = left<0 ? 0 : left, by0 = top<0 ? 0 : top;
- int bx1 = right>=width ? width-1 : right, by1 = bottom>=height ? height-1 : bottom;
- for( int py=by0; py<=by1; py++ )
- for( int px=bx0; px<=bx1; px++ )
+ i64 left = x0 < x1 ? x0 : x1; left -= pad;
+ i64 top = y0 < y1 ? y0 : y1; top -= pad;
+ i64 right = x0 > x1 ? x0 : x1; right += pad;
+ i64 bottom = y0 > y1 ? y0 : y1; bottom += pad;
+ if( right < 0 || bottom < 0 || left >= width || top >= height ) return self;
+ int bx0 = left < 0 ? 0 : left, by0 = top < 0 ? 0 : top;
+ int bx1 = right >= width ? width-1 : right, by1 = bottom >= height ? height-1 : bottom;
+ for( int py = by0; py <= by1; py++ )
+ for( int px = bx0; px <= bx1; px++ )
if( _onLine(px,py,x0,y0,x1,y1,thickness) ) pixels[py*width+px] = color;
return self;
};
@@ -96,14 +96,14 @@ struct Canvas {
// Small 3x5 bitmap font for game labels. Lowercase maps to uppercase.
// Newline returns to x; unsupported characters draw a question mark.
val text = { i64 x, i64 y, u8[~] str, int scale, u32 color ->
- if( scale<=0 ) return self;
+ if( scale <= 0 ) return self;
i64 px = x, py = y;
- for( int i=0; i<str#; i++ ) {
+ for( int i = 0; i < str#; i++ ) {
u8 c = str[i];
- if( c=='\n' ) { px=x; py+=6*scale; continue; }
+ if( c == '\n' ) { px = x; py += 6*scale; continue; }
int bits = _glyph(c);
- for( int row=0; row<5; row++ )
- for( int col=0; col<3; col++ )
+ for( int row = 0; row < 5; row++ )
+ for( int col = 0; col < 3; col++ )
if( (bits >> (14-row*3-col)) & 1 )
fillRect(px+col*scale,py+row*scale,scale,scale,color);
px += 4*scale;
@@ -130,7 +130,7 @@ val _glyphs = new u16[~96]{
};
val _glyph = { u8 c ->
- return 32<=c<128 ? _glyphs[c-32] : 061202;
+ return 32 <= c < 128 ? _glyphs[c-32] : 061202;
};
// Pixel coverage for a round-ended segment, separate from traversal.
@@ -140,10 +140,10 @@ val _onLine = { i64 px, i64 py, i64 x0, i64 y0, i64 x1, i64 y1, i64 thickness ->
f64 vx = px; vx -= x0;
f64 vy = py; vy -= y0;
f64 length2 = dx*dx+dy*dy;
- bool point = x0==x1 && y0==y1;
+ bool point = x0 == x1 && y0 == y1;
f64 t = point ? 0.0 : (vx*dx+vy*dy)/length2;
- t = t<0 ? 0.0 : t>1 ? 1.0 : t;
+ t = t < 0 ? 0.0 : t > 1 ? 1.0 : t;
f64 ex = vx-t*dx, ey = vy-t*dy;
f64 half = thickness/2.0;
- return ex*ex+ey*ey<=half*half;
+ return ex*ex+ey*ey <= half*half;
};
diff --git a/chapter31/src/main/smp/sys/libc.smp b/chapter31/src/main/smp/sys/libc.smp
index 7122bbd8..8e417461 100644
--- a/chapter31/src/main/smp/sys/libc.smp
+++ b/chapter31/src/main/smp/sys/libc.smp
@@ -53,9 +53,9 @@ i32 EOVERFLOW = "C";
// addr len prot flags fd off -> void*
{ i64 i64 i32 i32 i32 i32 -> i64 } mmap = "C";
// mmap flags
-i32 PROT_EXEC = 4;
-i32 PROT_READ = 1;
-i32 PROT_WRITE= 2;
-i32 PROT_NONE = 0;
+i32 PROT_EXEC = 4;
+i32 PROT_READ = 1;
+i32 PROT_WRITE = 2;
+i32 PROT_NONE = 0;
i32 MAP_PRIVATE = 2;
i32 MAP_ANON = 32;
diff --git a/chapter31/src/main/smp/sys/math.smp b/chapter31/src/main/smp/sys/math.smp
new file mode 100644
index 00000000..a5e1887c
--- /dev/null
+++ b/chapter31/src/main/smp/sys/math.smp
@@ -0,0 +1,15 @@
+// Mathematical constants, rounded to the nearest f64 value.
+val PI = 3.141592653589793;
+val E = 2.718281828459045;
+
+// Fixed-semantics C bindings recognized by the compiler's intrinsic inliner.
+// These preserve all 64 bits, including signed zero and NaN payloads.
+// They are NOT numeric conversions (ordinary typed assignments still are).
+{ f64 -> i64 } simple_f64_bits = "C";
+{ i64 -> f64 } simple_f64_from_bits = "C";
+val f64Bits = simple_f64_bits;
+val f64FromBits = simple_f64_from_bits;
+
+
+val max = { f64 x, f64 y -> return x > y ? x : y; };
+val min = { f64 x, f64 y -> return x < y ? x : y; };
diff --git a/chapter31/src/main/smp/sys/rt/simple_args.smp b/chapter31/src/main/smp/sys/rt/simple_args.smp
index f2890c1c..8bfcc1a7 100644
--- a/chapter31/src/main/smp/sys/rt/simple_args.smp
+++ b/chapter31/src/main/smp/sys/rt/simple_args.smp
@@ -11,7 +11,7 @@ val simple_args = { i64 argc, i64 argv ->
// Zero-filled reference arrays require nullable elements. Every slot is
// filled before returning; the native entry bridge publishes u8[~][].
val args = new u8[~]?[argc];
- for( i64 i=0; i<argc; i++ ) {
+ for( i64 i = 0; i < argc; i++ ) {
i64 src = simple_argv(argv,i);
i64 len = strlen(src);
if( len < 0 || len > _MAX_U32 ) return null;
diff --git a/chapter31/src/main/smp/sys/text.smp b/chapter31/src/main/smp/sys/text.smp
index 2c4b44ff..43698f22 100644
--- a/chapter31/src/main/smp/sys/text.smp
+++ b/chapter31/src/main/smp/sys/text.smp
@@ -9,71 +9,71 @@ val end = { aryu8 b ->
};
val _pad = { !aryu8 b, i64 n, u8 c ->
- for( i64 i=0; i<n; i++ ) b.add(c);
+ for( i64 i = 0; i < n; i++ ) b.add(c);
b;
};
val string = { !aryu8 b, u8[~] s, i64 spec, i64 width, i64 precision ->
- i64 len=s#;
- if( precision>=0 && precision<len ) len=precision;
- i64 pad=width-len;
+ i64 len = s#;
+ if( precision >= 0 && precision < len ) len = precision;
+ i64 pad = width-len;
if( !(spec&256) ) _pad(b,pad,' ');
- for( i64 i=0; i<len; i++ ) b.add(s[i]);
+ for( i64 i = 0; i < len; i++ ) b.add(s[i]);
if( spec&256 ) _pad(b,pad,' ');
b;
};
val integer = { !aryu8 b, i64 value, i64 spec, i64 width, i64 precision ->
- i64 kind=spec&255;
- if( kind=='b' ) return string(b,value ? "true" : "false",spec,width,-1);
- if( kind=='c' ) {
+ i64 kind = spec&255;
+ if( kind == 'b' ) return string(b,value ? "true" : "false",spec,width,-1);
+ if( kind == 'c' ) {
if( !(spec&256) ) _pad(b,width-1,' ');
- u8 c=value;
+ u8 c = value;
b.add(c);
if( spec&256 ) _pad(b,width-1,' ');
return b;
}
- bool signed=kind==0 || kind=='d' || kind=='i';
- i64 base=kind=='o' ? 8 : (kind=='x' || kind=='X' ? 16 : 10);
- u8[~] alphabet=kind=='X' ? "0123456789ABCDEF" : "0123456789abcdef";
- val digits=new u8[22]; // Maximum: 22 octal digits for a 64-bit integer.
- i64 count=0, n=value;
+ bool signed = kind == 0 || kind == 'd' || kind == 'i';
+ i64 base = kind == 'o' ? 8 : (kind == 'x' || kind == 'X' ? 16 : 10);
+ u8[~] alphabet = kind == 'X' ? "0123456789ABCDEF" : "0123456789abcdef";
+ val digits = new u8[22]; // Maximum: 22 octal digits for a 64-bit integer.
+ i64 count = 0, n = value;
// Signed decimal stays nonpositive, including the minimum i64.
- if( signed && n>0 ) n=-n;
- if( n==0 && precision!=0 ) digits[count++]='0';
- while( n!=0 ) {
- i64 q=0, r=0;
- if( signed ) { q=n/base; r=q*base-n; }
+ if( signed && n > 0 ) n = -n;
+ if( n == 0 && precision != 0 ) digits[count++] = '0';
+ while( n != 0 ) {
+ i64 q = 0, r = 0;
+ if( signed ) { q = n/base; r = q*base-n; }
else {
// Unsigned division without a u64 type. Halving first makes
// the dividend nonnegative; the remainder needs at most one fix.
- q=((n>>>1)/base)*2;
- r=n-q*base;
- if( r>=base ) { q++; r-=base; }
+ q = ((n>>>1)/base)*2;
+ r = n-q*base;
+ if( r >= base ) { q++; r -= base; }
}
- digits[count++]=alphabet[r];
- n=q;
+ digits[count++] = alphabet[r];
+ n = q;
}
- u8[~] !prefix="";
+ u8[~] !prefix = "";
if( signed ) {
- if( value<0 ) prefix="-";
- else if( spec&512 ) prefix="+";
- else if( spec&1024 ) prefix=" ";
- } else if( (spec&2048) && value!=0 ) {
- if( kind=='x' ) prefix="0x";
- if( kind=='X' ) prefix="0X";
+ if( value < 0 ) prefix = "-";
+ else if( spec&512 ) prefix = "+";
+ else if( spec&1024 ) prefix = " ";
+ } else if( (spec&2048) && value != 0 ) {
+ if( kind == 'x' ) prefix = "0x";
+ if( kind == 'X' ) prefix = "0X";
}
- i64 zeros=precision>count ? precision-count : 0;
+ i64 zeros = precision > count ? precision-count : 0;
// Alternate octal always begins with a zero, including precision-zero 0.
- if( kind=='o' && (spec&2048) && zeros==0 && (count==0 || digits[count-1]!='0') ) zeros=1;
- i64 pad=width-prefix#-zeros-count;
- bool left=(spec&256)!=0;
- bool zero=(spec&4096)!=0 && precision<0 && !left;
+ if( kind == 'o' && (spec&2048) && zeros == 0 && (count == 0 || digits[count-1] != '0') ) zeros = 1;
+ i64 pad = width-prefix#-zeros-count;
+ bool left = (spec&256) != 0;
+ bool zero = (spec&4096) != 0 && precision < 0 && !left;
if( !left && !zero ) _pad(b,pad,' ');
b.addAry(prefix);
if( zero ) _pad(b,pad,'0');
_pad(b,zeros,'0');
- while( count>0 ) b.add(digits[--count]);
+ while( count > 0 ) b.add(digits[--count]);
if( left ) _pad(b,pad,' ');
b;
};
diff --git a/chapter31/src/main/smp/sys/time.smp b/chapter31/src/main/smp/sys/time.smp
index 1706990e..a3e9b3a2 100644
--- a/chapter31/src/main/smp/sys/time.smp
+++ b/chapter31/src/main/smp/sys/time.smp
@@ -24,7 +24,7 @@ i64 MIN = -_DAYS_BEFORE_EPOCH*DAY; // 0001-01-01T00:00:00.000Z
i64 MAX = (_DAYS_BEFORE_YEAR_10000-_DAYS_BEFORE_EPOCH)*DAY-1; // 9999-12-31T23:59:59.999Z
// Access to the underlying LIBC functions
-int ISO=0, CLOCK12=1, CLOCK24=2, ELAPSED=3, DATE=4, CLOCK24_SECONDS=5;
+int ISO = 0, CLOCK12 = 1, CLOCK24 = 2, ELAPSED = 3, DATE = 4, CLOCK24_SECONDS = 5;
{ i64 } simple_time_now = "C";
{ i64 } simple_time_mono = "C";
{ i64 } simple_time_nano = "C";
@@ -40,7 +40,7 @@ val sleepUntil = { i64 deadline_ms -> simple_time_sleep(deadline_ms,1); };
// Signed duration conversions. Overflow returns -1; reverse conversions truncate
// toward zero. An exact duration day is 24 hours, independent of DST.
val _scale = { i64 n, i64 unit ->
- if( n>sys.integer.MAX_I64/unit || n<sys.integer.MIN_I64/unit ) return -1;
+ if( n > sys.integer.MAX_I64/unit || n < sys.integer.MIN_I64/unit ) return -1;
return n*unit;
};
val seconds = { i64 n -> _scale(n,SECOND); };
@@ -56,31 +56,31 @@ val toNanos = { i64 ms -> _scale(ms,NANOS_PER_MS); };
// Clamp to zero once due, and saturate for widely separated i64 readings.
val remaining = { i64 deadline_ms, i64 current_ms ->
- if( deadline_ms<=current_ms ) return 0;
- if( current_ms<0 && deadline_ms>sys.integer.MAX_I64+current_ms ) return sys.integer.MAX_I64;
+ if( deadline_ms <= current_ms ) return 0;
+ if( current_ms < 0 && deadline_ms > sys.integer.MAX_I64+current_ms ) return sys.integer.MAX_I64;
return deadline_ms-current_ms;
};
val _mod = { i64 n, i64 unit -> n-n/unit*unit; };
-val leap = { int year -> _mod(year,4)==0 && (_mod(year,100)!=0 || _mod(year,400)==0); };
+val leap = { int year -> _mod(year,4) == 0 && (_mod(year,100) != 0 || _mod(year,400) == 0); };
val monthDays = { int year, int month ->
- if( month<1 || month>12 ) return 0;
- return month==2 ? (leap(year) ? 29 : 28) :
- month==4 || month==6 || month==9 || month==11 ? 30 : 31;
+ if( month < 1 || month > 12 ) return 0;
+ return month == 2 ? (leap(year) ? 29 : 28) :
+ month == 4 || month == 6 || month == 9 || month == 11 ? 30 : 31;
};
// Gregorian civil dates, expressed using 400-year eras; no per-year loops.
val _days = { i64 year, i64 month, i64 day ->
- year -= month<=2 ? 1 : 0;
- i64 era=year/400, y=year-era*400;
- i64 mp=month+(month>2 ? -3 : 9);
+ year -= month <= 2 ? 1 : 0;
+ i64 era = year/400, y = year-era*400;
+ i64 mp = month+(month > 2 ? -3 : 9);
return era*_DAYS_PER_ERA+y*365+y/4-y/100+(153*mp+2)/5+day-1-_MARCH_EPOCH_DAYS;
};
val valid = { int year, int month, int day, int hour, int minute, int second, int millisecond ->
- return year>=1 && year<=9999 && month>=1 && month<=12 && day>=1 && day<=monthDays(year,month) &&
- hour>=0 && hour<=23 && minute>=0 && minute<=59 && second>=0 && second<=59 &&
- millisecond>=0 && millisecond<=999;
+ return year >= 1 && year <= 9999 && month >= 1 && month <= 12 && day >= 1 && day <= monthDays(year,month) &&
+ hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59 &&
+ millisecond >= 0 && millisecond <= 999;
};
val makeUTC = { int year, int month, int day, int hour, int minute, int second, int millisecond ->
@@ -89,41 +89,41 @@ val makeUTC = { int year, int month, int day, int hour, int minute, int second,
};
val utc = { i64 instant ->
- val d=DateTime.empty();
- if( instant<MIN || instant>MAX ) return d;
- i64 day=instant/DAY, rest=_mod(instant,DAY);
- if( rest<0 ) { rest+=DAY; day--; }
- i64 z=day+_MARCH_EPOCH_DAYS, era=z/_DAYS_PER_ERA, doe=z-era*_DAYS_PER_ERA;
- i64 y=(doe-doe/(_DAYS_PER_4_YEARS-1)+doe/_DAYS_PER_CENTURY-doe/(_DAYS_PER_ERA-1))/365;
- i64 doy=doe-(365*y+y/4-y/100), mp=(5*doy+2)/153;
- d.day=doy-(153*mp+2)/5+1;
- d.month=mp+(mp<10 ? 3 : -9);
- d.year=y+era*400+(d.month<=2 ? 1 : 0);
- d.hour=rest/HOUR; d.minute=_mod(rest/MINUTE,60);
- d.second=_mod(rest/SECOND,60); d.millisecond=_mod(rest,SECOND);
- d.weekday=_mod(day+4,7);
- if( d.weekday<0 ) d.weekday+=7;
+ val d = DateTime.empty();
+ if( instant < MIN || instant > MAX ) return d;
+ i64 day = instant/DAY, rest = _mod(instant,DAY);
+ if( rest < 0 ) { rest += DAY; day--; }
+ i64 z = day+_MARCH_EPOCH_DAYS, era = z/_DAYS_PER_ERA, doe = z-era*_DAYS_PER_ERA;
+ i64 y = (doe-doe/(_DAYS_PER_4_YEARS-1)+doe/_DAYS_PER_CENTURY-doe/(_DAYS_PER_ERA-1))/365;
+ i64 doy = doe-(365*y+y/4-y/100), mp = (5*doy+2)/153;
+ d.day = doy-(153*mp+2)/5+1;
+ d.month = mp+(mp < 10 ? 3 : -9);
+ d.year = y+era*400+(d.month <= 2 ? 1 : 0);
+ d.hour = rest/HOUR; d.minute = _mod(rest/MINUTE,60);
+ d.second = _mod(rest/SECOND,60); d.millisecond = _mod(rest,SECOND);
+ d.weekday = _mod(day+4,7);
+ if( d.weekday < 0 ) d.weekday += 7;
return d;
};
val local = { i64 instant ->
- val d=DateTime.empty();
- val f=new i64[10];
- i64 ptr=f;
- if( simple_time_local(instant,ptr)!=0 ) return d;
- d.year=f[0]; d.month=f[1]; d.day=f[2];
- d.hour=f[3]; d.minute=f[4]; d.second=f[5]; d.millisecond=f[6];
- d.weekday=f[7]; d.offsetSeconds=f[8]; d.daylight=f[9]!=0;
+ val d = DateTime.empty();
+ val f = new i64[10];
+ i64 ptr = f;
+ if( simple_time_local(instant,ptr) != 0 ) return d;
+ d.year = f[0]; d.month = f[1]; d.day = f[2];
+ d.hour = f[3]; d.minute = f[4]; d.second = f[5]; d.millisecond = f[6];
+ d.weekday = f[7]; d.offsetSeconds = f[8]; d.daylight = f[9] != 0;
return d;
};
val zoneName = { i64 instant ->
- val bytes=new u8[128];
- i64 ptr=bytes;
- int n=simple_time_zone(instant,ptr,bytes#);
- if( n<0 ) return "";
- val b=new aryu8();
- for( int i=0; i<n; i++ ) b.add(bytes[i]);
+ val bytes = new u8[128];
+ i64 ptr = bytes;
+ int n = simple_time_zone(instant,ptr,bytes#);
+ if( n < 0 ) return "";
+ val b = new aryu8();
+ for( int i = 0; i < n; i++ ) b.add(bytes[i]);
return text.end(b);
};
@@ -133,28 +133,28 @@ val _digits = { !aryu8 b, i64 n, int width ->
val _format = { i64 instant, int style, bool localZone ->
val d = localZone ? local(instant) : utc(instant);
- if( d.year==0 || style<0 || style>5 || style==3 ) return "<invalid time>";
+ if( d.year == 0 || style < 0 || style > 5 || style == 3 ) return "<invalid time>";
val b = new aryu8();
- if( style==4 ) {
+ if( style == 4 ) {
_digits(b,d.day,2).add('/'); _digits(b,d.month,2).add('/'); _digits(b,_mod(d.year,100),2);
} else {
- if( style==0 ) {
+ if( style == 0 ) {
_digits(b,d.year,4).add('-'); _digits(b,d.month,2).add('-'); _digits(b,d.day,2).add('T');
}
- int hour=d.hour;
- if( style==1 ) { hour=_mod(hour,12); if( hour==0 ) hour=12; }
- _digits(b,hour,style==1 ? 1 : 2).add(':'); _digits(b,d.minute,2);
- if( style==0 || style==5 ) { b.add(':'); _digits(b,d.second,2); }
- if( style==1 ) b.addAry(d.hour<12 ? "am" : "pm");
- if( style==0 ) {
+ int hour = d.hour;
+ if( style == 1 ) { hour = _mod(hour,12); if( hour == 0 ) hour = 12; }
+ _digits(b,hour,style == 1 ? 1 : 2).add(':'); _digits(b,d.minute,2);
+ if( style == 0 || style == 5 ) { b.add(':'); _digits(b,d.second,2); }
+ if( style == 1 ) b.addAry(d.hour < 12 ? "am" : "pm");
+ if( style == 0 ) {
b.add('.'); _digits(b,d.millisecond,3);
- if( d.offsetSeconds==0 ) b.add('Z');
+ if( d.offsetSeconds == 0 ) b.add('Z');
else {
- i64 offset=d.offsetSeconds;
- b.add(offset<0 ? '-' : '+');
- if( offset<0 ) offset=-offset;
+ i64 offset = d.offsetSeconds;
+ b.add(offset < 0 ? '-' : '+');
+ if( offset < 0 ) offset = -offset;
_digits(b,offset/3600,2).add(':'); _digits(b,_mod(offset/60,60),2);
- if( _mod(offset,60)!=0 ) { b.add(':'); _digits(b,_mod(offset,60),2); }
+ if( _mod(offset,60) != 0 ) { b.add(':'); _digits(b,_mod(offset,60),2); }
}
}
}
@@ -162,58 +162,58 @@ val _format = { i64 instant, int style, bool localZone ->
};
val elapsed = { i64 ms ->
- val b=new aryu8();
+ val b = new aryu8();
// Nonpositive arithmetic handles the minimum i64 without negating it.
- if( ms<0 ) b.add('-'); else ms=-ms;
+ if( ms < 0 ) b.add('-'); else ms = -ms;
_digits(b,-(ms/MINUTE),2).add(':');
_digits(b,-_mod(ms/SECOND,60),2).add('.'); _digits(b,-_mod(ms,SECOND),3);
return text.end(b);
};
val format = { i64 instant, int style ->
- if( style==ELAPSED ) return elapsed(instant);
+ if( style == ELAPSED ) return elapsed(instant);
return _format(instant,style,false);
};
val formatLocal = { i64 instant, int style ->
- if( style==ELAPSED ) return elapsed(instant);
+ if( style == ELAPSED ) return elapsed(instant);
return _format(instant,style,true);
};
val _number = { u8[~] s, i64 at, int count ->
- if( at<0 || count<1 || at+count>s# ) return -1;
- int n=0;
- for( int i=0; i<count; i++ ) {
- int c=s[at+i];
- if( c<'0' || c>'9' ) return -1;
- n=n*10+c-'0';
+ if( at < 0 || count < 1 || at+count > s# ) return -1;
+ int n = 0;
+ for( int i = 0; i < count; i++ ) {
+ int c = s[at+i];
+ if( c < '0' || c > '9' ) return -1;
+ n = n*10+c-'0';
}
return n;
};
// Keep suffix validation separate from calendar construction.
val _parseZone = { u8[~] s, int at, i64 instant ->
- if( at<0 || at>=s# ) return -1;
- i64 offset=0;
- if( s[at]=='Z' ) { if( at+1!=s# ) return -1; }
+ if( at < 0 || at >= s# ) return -1;
+ i64 offset = 0;
+ if( s[at] == 'Z' ) { if( at+1 != s# ) return -1; }
else {
- int sign=s[at]=='+' ? 1 : s[at]=='-' ? -1 : 0;
- if( !sign || (s#!=at+6 && s#!=at+9) || s[at+3]!=':' ) return -1;
- int oh=_number(s,at+1,2), om=_number(s,at+4,2), os=0;
- if( s#==at+9 ) { if( s[at+6]!=':' ) return -1; os=_number(s,at+7,2); }
- if( oh<0 || oh>23 || om<0 || om>59 || os<0 || os>59 ) return -1;
- offset=sign*(oh*HOUR+om*MINUTE+os*SECOND);
+ int sign = s[at] == '+' ? 1 : s[at] == '-' ? -1 : 0;
+ if( !sign || (s# != at+6 && s# != at+9) || s[at+3] != ':' ) return -1;
+ int oh = _number(s,at+1,2), om = _number(s,at+4,2), os = 0;
+ if( s# == at+9 ) { if( s[at+6] != ':' ) return -1; os = _number(s,at+7,2); }
+ if( oh < 0 || oh > 23 || om < 0 || om > 59 || os < 0 || os > 59 ) return -1;
+ offset = sign*(oh*HOUR+om*MINUTE+os*SECOND);
}
- instant-=offset;
- return instant<MIN || instant>MAX ? -1 : instant;
+ instant -= offset;
+ return instant < MIN || instant > MAX ? -1 : instant;
};
// Strict ISO absolute instants only. -1 is reserved for failure (and therefore
// cannot distinguish the valid instant one millisecond before Unix epoch).
val parse = { u8[~] s ->
- if( s#<20 || s[4]!='-' || s[7]!='-' || s[10]!='T' || s[13]!=':' || s[16]!=':' ) return -1;
- int y=_number(s, 0,4), m =_number(s, 5,2), d =_number(s, 8,2);
- int h=_number(s,11,2), min=_number(s,14,2), sec=_number(s,17,2);
- bool fraction=s[19]=='.';
- int ms=fraction ? _number(s,20,3) : 0;
+ if( s# < 20 || s[4] != '-' || s[7] != '-' || s[10] != 'T' || s[13] != ':' || s[16] != ':' ) return -1;
+ int y = _number(s, 0,4), m = _number(s, 5,2), d = _number(s, 8,2);
+ int h = _number(s,11,2), min = _number(s,14,2), sec = _number(s,17,2);
+ bool fraction = s[19] == '.';
+ int ms = fraction ? _number(s,20,3) : 0;
if( !valid(y,m,d,h,min,sec,ms) ) return -1;
return _parseZone(s,fraction ? 23 : 19,makeUTC(y,m,d,h,min,sec,ms));
};
diff --git a/chapter31/src/main/smp/sys/time/Timers.smp b/chapter31/src/main/smp/sys/time/Timers.smp
index eca32d15..7cca2e9c 100644
--- a/chapter31/src/main/smp/sys/time/Timers.smp
+++ b/chapter31/src/main/smp/sys/time/Timers.smp
@@ -14,37 +14,37 @@ struct Timers {
// Add a new timer
{ i64 i64 i64 -> u32 } _add = { i64 current_ms, i64 delay_ms, i64 period_ms ->
- if( current_ms<0 || delay_ms<0 || current_ms>sys.integer.MAX_I64-delay_ms || _next==0 ) return 0;
+ if( current_ms < 0 || delay_ms < 0 || current_ms > sys.integer.MAX_I64-delay_ms || _next == 0 ) return 0;
// Ugly linear scan for an available slot
- int slot=0;
- while( slot<_ids# && _ids[slot]!=0 ) slot++;
+ int slot = 0;
+ while( slot < _ids# && _ids[slot] != 0 ) slot++;
// Double size for lots of timers
- if( slot==_ids# ) {
- if( _ids#>sys.integer.MAX_I32/2 ) return 0;
+ if( slot == _ids# ) {
+ if( _ids# > sys.integer.MAX_I32/2 ) return 0;
val ids = new u32[_ids#*2];
val due_ms = new i64[_ids#*2], periods_ms = new i64[_ids#*2];
- for( int i=0; i<_ids#; i++ ) { ids[i]=_ids[i]; due_ms[i]=_due_ms[i]; periods_ms[i]=_period_ms[i]; }
- _ids=ids; _due_ms=due_ms; _period_ms=periods_ms;
+ for( int i = 0; i < _ids#; i++ ) { ids[i] = _ids[i]; due_ms[i] = _due_ms[i]; periods_ms[i] = _period_ms[i]; }
+ _ids = ids; _due_ms = due_ms; _period_ms = periods_ms;
// Retry against the newly published arrays after growing.
return _add(current_ms,delay_ms,period_ms);
}
// Next available timer id
u32 id = _next;
- _next = id==sys.integer.MAX_U32 ? 0 : id+1;
- _ids[slot]=id; _due_ms[slot]=current_ms+delay_ms; _period_ms[slot]=period_ms;
+ _next = id == sys.integer.MAX_U32 ? 0 : id+1;
+ _ids[slot] = id; _due_ms[slot] = current_ms+delay_ms; _period_ms[slot] = period_ms;
return id;
};
// Explicit-clock versions make game logic and tests deterministic.
{ i64 i64 -> u32 } afterAt = { i64 current_ms, i64 delay_ms -> _add(current_ms,delay_ms,0); };
- { i64 i64 -> u32 } everyAt = { i64 current_ms, i64 period_ms -> period_ms<=0 ? 0 : _add(current_ms,period_ms,period_ms); };
+ { i64 i64 -> u32 } everyAt = { i64 current_ms, i64 period_ms -> period_ms <= 0 ? 0 : _add(current_ms,period_ms,period_ms); };
{ i64 -> u32 } after = { i64 delay_ms -> afterAt(time.monotonic(),delay_ms ); };
{ i64 -> u32 } every = { i64 period_ms -> everyAt(time.monotonic(),period_ms); };
// Remove a timer
val cancel = { u32 id ->
- if( id==0 ) return false;
- for( int i=0; i<_ids#; i++ ) if( _ids[i]==id ) { _ids[i]=0; return true; }
+ if( id == 0 ) return false;
+ for( int i = 0; i < _ids#; i++ ) if( _ids[i] == id ) { _ids[i] = 0; return true; }
return false;
};
@@ -52,8 +52,8 @@ struct Timers {
val nextDeadline = { ->
i64 next_ms = -1;
// Ugly linear scan again, but short
- for( int i=0; i<_ids#; i++ )
- if( _ids[i]!=0 && (next_ms<0 || _due_ms[i] < next_ms) ) next_ms = _due_ms[i];
+ for( int i = 0; i < _ids#; i++ )
+ if( _ids[i] != 0 && (next_ms < 0 || _due_ms[i] < next_ms) ) next_ms = _due_ms[i];
return next_ms;
};
@@ -63,16 +63,16 @@ struct Timers {
// Repeats skip missed ticks and retain their phase, avoiding bursts/drift.
{ i64 -> u32 } poll = { i64 current_ms ->
int slot = -1;
- for( int i=0; i<_ids#; i++ )
- if( _ids[i]!=0 && _due_ms[i]<=current_ms && (slot<0 || _due_ms[i]<_due_ms[slot] ||
- (_due_ms[i]==_due_ms[slot] && _ids[i]<_ids[slot])) ) slot=i;
- if( slot<0 ) return 0;
+ for( int i = 0; i < _ids#; i++ )
+ if( _ids[i] != 0 && _due_ms[i] <= current_ms && (slot < 0 || _due_ms[i] < _due_ms[slot] ||
+ (_due_ms[i] == _due_ms[slot] && _ids[i] < _ids[slot])) ) slot = i;
+ if( slot < 0 ) return 0;
u32 id = _ids[slot];
i64 period_ms = _period_ms[slot];
- if( period_ms==0 ) _ids[slot]=0;
+ if( period_ms == 0 ) _ids[slot] = 0;
else {
i64 steps = (current_ms-_due_ms[slot])/period_ms;
- if( steps>=(sys.integer.MAX_I64-_due_ms[slot])/period_ms ) _ids[slot]=0;
+ if( steps >= (sys.integer.MAX_I64-_due_ms[slot])/period_ms ) _ids[slot] = 0;
else _due_ms[slot] += (steps+1)*period_ms;
}
return id;
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
index 1e6c6fc0..b29c9706 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
@@ -65,7 +65,7 @@ public class ArithNodeTest {
TypePtr.gather(inputs);
TypeMemPtr.gather(inputs);
TypeFunPtr.gather(inputs);
- inputs.add(TypeConAryB.make(new byte[]{1,2,3}));
+ inputs.add(TypeConAry.make(new byte[]{1,2,3}));
for( long value : new long[]{Long.MIN_VALUE,Long.MIN_VALUE+1,-1,1,Long.MAX_VALUE} )
inputs.add(TypeInteger.constant(value));
for( double value : new double[]{-0.0,0.0,-1.0,1.0,16777216.0,16777217.0,Double.NaN,Double.NEGATIVE_INFINITY,Double.POSITIVE_INFINITY} )
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ArrayInitTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ArrayInitTest.java
index 6cba5ee3..d298828e 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/ArrayInitTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ArrayInitTest.java
@@ -1,10 +1,46 @@
package com.seaofnodes.simple;
import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.ArrayInitNode;
+import com.seaofnodes.simple.node.ConstantNode;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.Ary;
+import java.util.ArrayList;
import org.junit.Test;
import static org.junit.Assert.*;
public class ArrayInitTest {
+ @Test public void constantListComputeIsMonotone() {
+ CodeGen code = new CodeGen("return 0;").parse();
+ TypeStruct layout = TypeStruct.makeAry("[]i32",TypeInteger.U32,2,TypeInteger.I32,3,true);
+ Type array = TypeMemPtr.make(layout);
+ Node ctrl = ConstantNode.seed(Type.CONTROL);
+ Node ptr = ConstantNode.seed(Type.TOP);
+ Node len = ConstantNode.seed(Type.TOP);
+ Node x = ConstantNode.seed(Type.TOP), y = ConstantNode.seed(Type.TOP);
+ ArrayInitNode init = new ArrayInitNode(ctrl,code.ZERO,ptr,len,2,null,new Ary<>(new Node[]{x,y}));
+ Type[][] inputs = {
+ {Type.TOP,TypeMemPtr.TOP,array},
+ {Type.TOP,TypeInteger.TOP,TypeInteger.TWO,TypeInteger.U32},
+ {Type.TOP,TypeInteger.TOP,TypeInteger.constant(5),TypeInteger.BOT},
+ {Type.TOP,TypeInteger.TOP,TypeInteger.constant(6),TypeInteger.BOT}
+ };
+ var states = new ArrayList<Type[]>();
+ for( Type p : inputs[0] )
+ for( Type l : inputs[1] )
+ for( Type a : inputs[2] )
+ for( Type b : inputs[3] ) {
+ ptr._type = p; len._type = l; x._type = a; y._type = b;
+ states.add(new Type[]{p,l,a,b,init.compute()});
+ }
+ for( Type[] before : states )
+ for( Type[] after : states )
+ if( before[0].isa(after[0]) && before[1].isa(after[1]) &&
+ before[2].isa(after[2]) && before[3].isa(after[3]) )
+ assertTrue("Array initializer rose from "+before[4]+" to "+after[4],before[4].isa(after[4]));
+ }
+
private static void value(String src, long expected) {
CodeGen code=new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
assertEquals(Long.toString(expected),Eval2.eval(code,0,100000));
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/AssemblyDumpTest.java b/chapter31/src/test/java/com/seaofnodes/simple/AssemblyDumpTest.java
new file mode 100644
index 00000000..0e4c230a
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/AssemblyDumpTest.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.BAOS;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HexFormat;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class AssemblyDumpTest {
+ @Test public void libraryUnitsAndGlyphs() throws Exception {
+ Path root=Path.of("build/objs/assembly-dump");
+ Files.createDirectories(root);
+ Path build=Files.createTempDirectory(root,"sys-");
+ CodeGen code=new CodeGen("src/main/smp",build.toString(),null,"sys",null,123,true,TypeInteger.BOT)
+ .driver(CodeGen.Phase.Serialize,TestC.CPU_PORT,TestC.CALL_CONVENTION)
+ .driver(CodeGen.Phase.Encoding,TestC.CPU_PORT,TestC.CALL_CONVENTION);
+ var entry=code._encoding;
+ String before=code.asm();
+ assertSame("Dumping another unit must not change the active encoding",entry,code._encoding);
+ for( var unit : code._compunits.values() )
+ if( unit._src!=null ) {
+ String heading="=== Compilation unit: "+unit._cname+" ===";
+ assertEquals("Exactly one heading for "+unit._cname,2,before.split(heading,-1).length);
+ }
+ int start=before.indexOf("=== Compilation unit: sys.draw.Canvas ===");
+ assertTrue(start>=0);
+ int end=before.indexOf("=== Compilation unit:",start+1);
+ String canvas=before.substring(start,end<0 ? before.length() : end);
+ assertTrue(canvas.contains("Constant Pool"));
+ assertTrue(canvas.contains("sys.draw.Canvas._glyphs: []u16"));
+ TypeMemPtr ptr=(TypeMemPtr)code._compunits.get("sys/draw/Canvas")._clz.field("_glyphs")._t;
+ TypeConAry glyphs=(TypeConAry)ptr._obj.field("[]")._t;
+ assertEquals(96,glyphs.len());
+ BAOS bytes=new BAOS();
+ glyphs.write(bytes);
+ assertTrue("The complete font follows its u32 length header",
+ canvas.contains("60000000"+HexFormat.of().formatHex(bytes.toByteArray())));
+ code.exportELF(false,false);
+ com.seaofnodes.simple.codegen.PrintRegTestSupport.checkDataAliases(
+ build.resolve("sys/draw/Canvas.o"),196,"sys.draw.Canvas._glyphs");
+ assertSame(entry,code._encoding);
+ assertEquals("Export must not truncate the dump to its entry unit",before,code.asm());
+ Files.writeString(build.resolve("sys.asm"),before);
+ }
+
+ @Test public void combinedEncodingAndEarlierPhase() {
+ for( String cpu : new String[]{"x86_64_v2","arm","riscv"} ) {
+ CodeGen code=new CodeGen("val a=new u16[~]{5,6,7}; return a[arg&1];")
+ .driver(CodeGen.Phase.RegAlloc,cpu,"SystemV");
+ assertFalse(code.asm().contains("Constant Pool"));
+ code.driver(cpu,"SystemV",true,false);
+ String dump=code.asm();
+ assertFalse(dump.contains("=== Compilation unit:"));
+ assertTrue(dump.contains("Constant Pool"));
+ assertTrue(dump.contains("03000000050006000700"));
+ }
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java b/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java
new file mode 100644
index 00000000..efdb1dd7
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java
@@ -0,0 +1,163 @@
+package com.seaofnodes.simple;
+
+import java.awt.image.BufferedImage;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import javax.imageio.ImageIO;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+// Exercise the actual Simple game and rasterizer in native code, without a window.
+public class BreakoutTest {
+ private static String game() throws Exception {
+ String source = Files.readString(Path.of("docs/examples/Breakout.smp"));
+ // Physics/rendering tests supply their own entry point. Input and
+ // sound are exercised by GraphicsTest with the complete program.
+ int end = source.indexOf("// Short, fading triangle waves");
+ assertTrue("Breakout physics/rendering section",end >= 0);
+ String physics = source.substring(0,end);
+ // The shared square-root helper now follows the input code.
+ int sqrt = source.indexOf("val _sqrt =");
+ if( sqrt >= end ) {
+ int close = source.indexOf("\n};",sqrt);
+ assertTrue("Square-root helper end",close >= 0);
+ physics += source.substring(sqrt,close+4);
+ }
+ return physics;
+ }
+
+ @Test public void paddleLivesAndPause() throws Exception {
+ TestC.runSYS(game()+"""
+ val main={ ->
+ val g=new Game;
+ if( g.remaining!=192 || g.score!=0 || g.lives!=3 || g.phase!=READY ) return 1;
+ _tick(g,1);
+ if( g.paddle<510.39 || g.paddle>510.41 || g.x!=g.paddle ) return 2;
+ g._paddle(-100.0); if( g.paddle != 80.0 ) return 3;
+ g._paddle(2000.0); if( g.paddle != 928.0 ) return 4;
+ _reset(g);
+ g.x=g.paddle-50.0; _rebound(g);
+ if( g.dx > -0.78 || g.dy>=0.0 ) return 5;
+ g.x=g.paddle+50.0; _rebound(g);
+ if( g.dx < 0.78 || g.dy>=0.0 ) return 6;
+ g.x=g.paddle; _rebound(g);
+ if( g.dy > -0.99 || g.dx*g.dx+g.dy*g.dy<0.999999 ) return 7;
+ _serve(g); g.paused=true;
+ f64 x=g.x, y=g.y, paddle=g.paddle;
+ _tick(g,1);
+ if( g.x!=x || g.y!=y || g.paddle!=paddle ) return 8;
+ g.paused=false;
+ for( int i=0; i<3; i++ ) {
+ _serve(g); g.x=40.0; g.y=723.0; g.dx=0.0; g.dy=1.0;
+ _tick(g,0);
+ if( g.lives!=2-i || g.backWall || g.sound!=5 ) return 9;
+ }
+ if( g.phase!=LOST ) return 10;
+ _serve(g); if( g.phase!=LOST ) return 11;
+ _reset(g);
+ if( g.phase!=READY || g.lives!=3 || g.boosted || g.paused || g.speed!=320.0 ) return 12;
+ return 0;
+ };
+ ""","breakoutControls","",-1);
+ }
+
+ @Test public void collisionsAndBoost() throws Exception {
+ TestC.runSYS(game()+"""
+ val main={ ->
+ val g=new Game;
+ _serve(g);
+ g.x=29.1; g.y=400.0; g.dx=-1.0; g.dy=0.0;
+ _tick(g,0);
+ if( g.dx<=0.0 || g.x<29.0 || g.sound!=1 ) return 1;
+ g.x=978.9; g.dx=1.0; _tick(g,0);
+ if( g.dx>=0.0 || g.x>979.0 ) return 2;
+ // Front of the bottom row: one point, no acceleration or boost.
+ g.x=44.0; g.y=330.0; g.dx=0.0; g.dy=-1.0;
+ _tick(g,0);
+ if( g.bricks[168]!=0 || g.score!=1 || g.dy<=0.0 || g.boosted || g.soundDepth!=1 ) return 3;
+ // Top of a brick alone does not arm the back-wall bonus.
+ g.x=44.0; g.y=146.0; g.dy=1.0;
+ _tick(g,0);
+ if( g.bricks[0]!=0 || g.score!=9 || g.speed!=565.0 || g.boosted || g.soundDepth!=8 ) return 4;
+ // Back wall arms it; hitting a side still must not trigger it.
+ g.x=84.0; g.y=89.1; g.dy=-1.0;
+ _tick(g,0);
+ if( !g.backWall || g.dy<=0.0 || g.boosted ) return 5;
+ g.x=60.0; g.y=160.0; g.dx=1.0; g.dy=0.0;
+ _tick(g,0);
+ if( g.bricks[1]!=0 || g.dx>=0.0 || g.boosted ) return 6;
+ g.x=124.0; g.y=146.0; g.dx=0.0; g.dy=1.0;
+ _tick(g,0);
+ if( !g.boosted || g.speed<932.24 || g.speed>932.26 || g.dy>=0.0 || g.sound!=4 ) return 7;
+ // Another back hit cannot multiply the speed a second time.
+ g.x=164.0; g.y=146.0; g.dy=1.0;
+ _tick(g,0);
+ if( g.speed>932.26 || g.bricks[3]!=0 ) return 8;
+ // A boosted front hit cannot tunnel through the brick either.
+ g.x=84.0; g.y=331.0; g.dy=-1.0;
+ _tick(g,0);
+ if( g.bricks[169]!=0 || g.dy<=0.0 || g.speed<932.24 ) return 9;
+ // Actual paddle contact disarms the trip and chooses its angle.
+ g.x=g.paddle+50.0; g.y=668.0; g.dy=1.0; g.dx=0.0;
+ _tick(g,0);
+ if( g.dy>=0.0 || g.dx<0.78 || g.backWall || !g.boosted ) return 10;
+ // A lost ball clears both kinds of acceleration, preserving the wall/score.
+ int score=g.score, remaining=g.remaining;
+ g.x=40.0; g.y=723.0; g.dx=0.0; g.dy=1.0;
+ _tick(g,0);
+ if( g.phase!=READY || g.lives!=2 || g.speed!=320.0 || g.depth!=1 || g.boosted ) return 11;
+ if( g.score!=score || g.remaining!=remaining ) return 12;
+ _serve(g);
+ if( g.speed!=320.0 ) return 13;
+ // The new ball can earn its own boost.
+ g.sound=0; g.backWall=true;
+ g.x=204.0; g.y=146.0; g.dx=0.0; g.dy=1.0;
+ _tick(g,0);
+ if( !g.boosted || g.speed<932.24 || g.sound!=4 ) return 14;
+ return 0;
+ };
+ ""","breakoutCollisions","",-1);
+ }
+
+ @Test public void clearEveryBrickAndRender() throws Exception {
+ TestC.runSYS(game()+"""
+ val main={ ->
+ val g=new Game;
+ val c=new sys.draw.Canvas(WIDTH,HEIGHT);
+ _draw(c,g);
+ for( int row=0; row<ROWS; row++ )
+ if( c.pixels[(BRICK_TOP+row*BRICK_DY+4)*WIDTH+28]!=COLORS[row] ) return 1;
+ if( c.pixels[675*WIDTH+504]!=CYAN || c.pixels[663*WIDTH+504]!=WHITE ) return 2;
+ // Save a native-rendered preview for manual visual review.
+ int fd=sys.io.create("build/objs/breakout-preview.bgra");
+ i64 pixels=c.pixels;
+ if( fd<0 || sys.libc.write(fd,pixels,c.pixels#*4)!=c.pixels#*4 ) return 3;
+ sys.io.close(fd);
+ _serve(g);
+ // Drive through every brick's front, bottom row first.
+ for( int i=COLS*ROWS-1; i>=0; i-- ) {
+ g.x=LEFT+20.0+(i-i/COLS*COLS)*BRICK_DX;
+ g.y=BRICK_TOP+1.0+(i/COLS)*BRICK_DY+BRICK_H+RADIUS;
+ g.dx=0.0; g.dy=-1.0;
+ _tick(g,0);
+ if( g.bricks[i]!=0 ) return 4;
+ }
+ if( g.phase!=WON || g.remaining!=0 || g.score!=864 || g.sound!=6 ) return 5;
+ f64 y=g.y; _tick(g,0);
+ if( g.y!=y ) return 6;
+ _reset(g);
+ for( int i=0; i<g.bricks#; i++ ) if( g.bricks[i]!=1 ) return 7;
+ if( g.score!=0 || g.remaining!=192 ) return 8;
+ return 0;
+ };
+ ""","breakoutClear","",-1);
+ byte[] pixels=Files.readAllBytes(Path.of("build/objs/breakout-preview.bgra"));
+ assertEquals(1008*760*4,pixels.length);
+ var image=new BufferedImage(1008,760,BufferedImage.TYPE_INT_RGB);
+ var bytes=ByteBuffer.wrap(pixels).order(ByteOrder.LITTLE_ENDIAN);
+ for(int y=0;y<760;y++) for(int x=0;x<1008;x++) image.setRGB(x,y,bytes.getInt());
+ ImageIO.write(image,"png",Path.of("build/objs/breakout-preview.png").toFile());
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/BulkMemPhiTest.java b/chapter31/src/test/java/com/seaofnodes/simple/BulkMemPhiTest.java
index 31c0302b..fd816c68 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/BulkMemPhiTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/BulkMemPhiTest.java
@@ -4,10 +4,35 @@ import com.seaofnodes.simple.codegen.CodeGen;
import com.seaofnodes.simple.node.*;
import com.seaofnodes.simple.type.TypeInteger;
import com.seaofnodes.simple.type.TypeMem;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.XInt;
import org.junit.Test;
import static org.junit.Assert.*;
public class BulkMemPhiTest {
+ @Test public void testUnescapedSliceKeepsItsOwnEscapes() {
+ CodeGen code = new CodeGen("");
+ code._phase = CodeGen.Phase.Lower;
+ Node defaults = code.con(TypeMem.START);
+ Node method = code.con(TypeMem.make(55,Type.BOTTOM,false,false,false,XInt.make(4),XInt.EMPTY));
+ MemMergeNode fields = new MemMergeNode(null,defaults);
+ fields.alias(55,method);
+ fields.init();
+ assertSame("The bulk excludes this unescaped field",TypeMem.START,fields._type);
+ Node ctrl = new CProjNode(code._start,0,"Ctrl").init();
+ Node iff = new IfNode(ctrl,code.con(TypeInteger.BOOL)).init();
+ RegionNode region = new RegionNode(null,null,
+ new CProjNode(iff,0,"True").init(),
+ new CProjNode(iff,1,"False").init()).init();
+ BulkMemPhiNode bulk = new BulkMemPhiNode("$mem",region,fields,defaults).init();
+ MemMergeNode split = (MemMergeNode)bulk.idealize();
+ Node precise = split.alias(55);
+ assertTrue("A new slice must not inherit an escape bound that excludes its method",
+ precise.compute().isa(precise._type));
+ precise.peephole();
+ assertTrue(XInt.bit(((TypeMem)precise._type)._escFs,4));
+ }
+
// Reduced from Capitalize's Lower-phase failure. A precise MemMerge slot
// may still be supplied by bulk memory which covers the requested alias.
@Test public void testBulkInPreciseSlot() {
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java b/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
index 055ef518..85f273a1 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
@@ -477,7 +477,7 @@ public class Chapter25Test {
// Software drawing and the optional native graphics interface.
assertArrayEquals(new String[]{"sys/adt", "sys/ary",
- "sys/aryi64", "sys/aryu8", "sys/audio", "sys/char", "sys/draw", "sys/gfx", "sys/integer", "sys/io", "sys/libc", "sys/rt", "sys/scan", "sys/text", "sys/time"},sys_elf._deps);
+ "sys/aryi64", "sys/aryu8", "sys/audio", "sys/char", "sys/draw", "sys/gfx", "sys/integer", "sys/io", "sys/libc", "sys/math", "sys/rt", "sys/scan", "sys/text", "sys/time"},sys_elf._deps);
assertArrayEquals(new String[]{"sys"},sys_elf._units);
assertSame("class:sys" ,sys_elf._clz._name);
}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ConstantArrayTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ConstantArrayTest.java
new file mode 100644
index 00000000..c641487b
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ConstantArrayTest.java
@@ -0,0 +1,123 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.StaticData;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.parser.Parser;
+import com.seaofnodes.simple.type.*;
+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 ConstantArrayTest {
+ private static StaticData.ObjectData array(CodeGen code, TypeInteger storage, int len) {
+ var arrays=code._encoding._data.entries().stream().filter(o ->
+ o.type instanceof TypeStruct ts && ts.isConAry() &&
+ ts.field("[]")._t instanceof TypeConAry c && c.storageType()==storage && c.len()==len).toList();
+ assertEquals(1,arrays.size());
+ assertTrue(arrays.getFirst().readOnly);
+ return arrays.getFirst();
+ }
+
+ @Test public void typedDataAndSharing() throws Exception {
+ String source="""
+ val a=new u16[~]{025755,65535,65538};
+ val b=new u16[~]{025755,65535,65538};
+ val fresh={ -> new u16[~]{025755,65535,65538}; };
+ val main={ ->
+ if(a!=b || a!=fresh() || a#!=3 || a[0]!=025755 || a[1]!=65535 || a[2]!=2) return 1;
+ val bytes=new u8[~]{65,66,67};
+ if(bytes!="ABC") return 2;
+ val signed=new i16[~]{-32768,-1,32767};
+ if(signed[0]!=-32768 || signed[1]!=-1 || signed[2]!=32767) return 3;
+ val ints=new i32[~]{-2147483648,2147483647};
+ if(ints[0]!=-2147483648 || ints[1]!=2147483647) return 4;
+ val uints=new u32[~]{0,4294967295};
+ if(uints[1]!=4294967295) return 5;
+ val longs=new i64[~]{1<<63,0x7fffffffffffffff};
+ if(longs[0]!=(1<<63) || longs[1]!=0x7fffffffffffffff) return 6;
+ val empty=new u16[~]{};
+ if(empty#!=0) return 7;
+ return 0;
+ };
+ """;
+ TestC.runSF(source,"constantArrayWidths","",-1);
+ CodeGen code=new CodeGen(source).driver(CodeGen.Phase.Encoding,TestC.CPU_PORT,TestC.CALL_CONVENTION);
+ StaticData.ObjectData obj=array(code,TypeInteger.U16,3);
+ assertEquals("Test.a, Test.b",obj.label());
+ assertEquals(12,obj.size); // Four-byte length, six data bytes, alignment padding.
+ byte[] bytes=code._encoding._cpool.buf();
+ assertEquals(3,bytes[obj.offset]);
+ assertEquals(025755&255,bytes[obj.offset+4]&255);
+ assertEquals(025755>>>8,bytes[obj.offset+5]&255);
+ assertEquals(255,bytes[obj.offset+6]&255);
+ assertEquals(255,bytes[obj.offset+7]&255);
+ assertNull(code._stop.walk(n -> n instanceof NewNode ? n : null));
+ com.seaofnodes.simple.codegen.PrintRegTestSupport.checkDataAliases(
+ Path.of("build/objs/constantArrayWidths.o"),12,"constantArrayWidths.a","constantArrayWidths.b");
+ }
+
+ @Test public void arbitraryProducerUsesStaticData() {
+ for(String cpu:new String[]{"x86_64_v2","arm","riscv"}) {
+ CodeGen code=new CodeGen("u16[~]? unused=null; return 0;").parse();
+ TypeStruct layout=(TypeStruct)Parser.TYPES.get("[]u16");
+ TypeConAry contents=TypeConAry.make(TypeInteger.U16,new long[]{1,65535});
+ TypeStruct array=TypeStruct.makeAry(layout._name,layout.field("#")._alias,layout.field("[]")._alias,contents);
+ Type ptr=TypeMemPtr.make((byte)2,array,true).makeRO();
+ // No initializer or allocation node: only compute() supplies the type.
+ Node producer=new ReadOnlyNode(code.ZERO) {
+ @Override public String label() { return "constant-array producer"; }
+ @Override public Type compute() { return ptr; }
+ };
+ ReturnNode ret=code._stop.walk(n -> n instanceof ReturnNode r && r.fun().isClz() ? r : null);
+ assertNotNull(ret);
+ ret.setDef(2,producer.peephole());
+ code.add(ret);
+ code.driver(CodeGen.Phase.Encoding,cpu,"SystemV");
+ StaticData.ObjectData obj=array(code,TypeInteger.U16,2);
+ assertEquals(8,obj.size);
+ }
+ }
+
+ @Test public void sideEffectsAndMutableArrays() throws Exception {
+ CodeGen eval=new CodeGen("""
+ val same_noInline={u16[~] a -> a==new u16[~]{1,2};};
+ return same_noInline(new u16[~]{1,2});
+ """).driver(CodeGen.Phase.TypeCheck);
+ assertEquals("1",Eval2.eval(eval,0));
+ TestC.runSF("""
+ val next={int[] counter -> counter[0]++; return 7;};
+ val main={ ->
+ val count=new int[1];
+ val a=new int[~]{next(count),next(count)};
+ if(count[0]!=2 || a[0]!=7 || a[1]!=7) return 1;
+ val b=new int[]{7,7}, c=new int[]{7,7};
+ if(b==c) return 2;
+ int[~] view=b;
+ b[0]=9;
+ if(view[0]!=9 || c[0]!=7) return 3;
+ return 0;
+ };
+ ""","constantArrayEffects","",-1);
+ }
+
+ @Test public void importedTypedConstants() throws Exception {
+ Path root=Path.of("build/objs/separate");
+ Files.createDirectories(root);
+ Path lib=Files.createTempDirectory(root,"constant-arrays-");
+ new CodeGen(null,lib.toString(),null,"Table","""
+ val small=new u16[~]{1,65535};
+ val wide=new i64[~]{1<<63,0x7fffffffffffffff};
+ val uints=new u32[~]{4294967295};
+ val signed=new i32[~]{-2147483648};
+ """,126,true,TypeInteger.BOT).driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false);
+ var paths=new Ary<>(new String[]{lib.toString()});
+ CodeGen code=new CodeGen(null,"build/objs",paths,"TableClient","""
+ return Table.small[1]==65535 && Table.wide[0]==(1<<63) &&
+ Table.wide[1]==0x7fffffffffffffff && Table.uints[0]==4294967295 && Table.signed[0]==-2147483648;
+ """,126,true,TypeInteger.BOT).driver(CodeGen.Phase.TypeCheck);
+ assertEquals("1",Eval2.eval(code,0));
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ConvertNodeTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ConvertNodeTest.java
index 96d73f26..bdda3171 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/ConvertNodeTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ConvertNodeTest.java
@@ -28,7 +28,7 @@ public class ConvertNodeTest {
for( boolean arrayRO : new boolean[]{false,true} )
inputs.add(TypeMemPtr.make(TypeStruct.makeAry("[]test",len,-1,
TypeMemPtr.TEST.withAccess(elementRO),-2,false)).withAccess(arrayRO));
- inputs.add(TypeConAryB.make(new byte[]{1,2,3}));
+ inputs.add(TypeConAry.make(new byte[]{1,2,3}));
for( long value : new long[]{Long.MIN_VALUE,-129,-128,-1,0,1,127,128,255,256,Long.MAX_VALUE} )
inputs.add(TypeInteger.constant(value));
for( double value : new double[]{-0.0,0.0,1.0,16777217.0,Double.NaN,Double.NEGATIVE_INFINITY,Double.POSITIVE_INFINITY} )
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java b/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
index b6228666..eef05f93 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
@@ -110,6 +110,7 @@ public abstract class Eval2 {
// Class pointers and initializer self parameters share one object per run.
private static final HashMap<String,Object[]> CLASSES = new HashMap<>();
+ private static final IdentityHashMap<TypeStruct,Object[]> ARRAYS = new IdentityHashMap<>();
public static String eval( CodeGen code, long arg ) { return eval(code,arg,1000); }
public static String eval( CodeGen code, long arg, int timeout ) {
@@ -122,6 +123,7 @@ public abstract class Eval2 {
// selection. Objects loaded later are scheduled independently.
code.driver(CodeGen.Phase.LocalSched);
CLASSES.clear();
+ ARRAYS.clear();
// Timer for when we run too long. Ticks once per backedge or function call
int loopCnt = 0;
@@ -334,6 +336,8 @@ public abstract class Eval2 {
case RoundF32Node rnd -> (double)(float)d(rnd.in(1));
case ToIntegerNode cvt -> (long)d(cvt.in(1));
case ToFloatNode toflt-> (double)x(toflt.in(1));
+ case Intrinsic.F64BitsNode cast -> Double.doubleToRawLongBits(d(cast.in(1)));
+ case Intrinsic.F64FromBitsNode cast -> Double.longBitsToDouble(x(cast.in(1)));
case XorNode xor -> x(xor.in(1)) ^ x(xor.in(2));
default -> throw Utils.TODO();
};
@@ -361,9 +365,12 @@ public abstract class Eval2 {
if( tmp._obj.isAry() ) { // Constant array ptr
Type elem = tmp._obj.field("[]")._t;
if( elem instanceof TypeConAry con ) {
+ Object[] old=ARRAYS.get(tmp._obj);
+ if( old!=null ) yield old;
Object[] xs = new Object[con.len()];
for( int i=0; i<con.len(); i++ )
xs[i] = con.at8(i);
+ ARRAYS.put(tmp._obj,xs);
yield xs;
} else {
// Generic constant array, used as a default input to a
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/FloatNegationNativeTest.java b/chapter31/src/test/java/com/seaofnodes/simple/FloatNegationNativeTest.java
new file mode 100644
index 00000000..dbbe353a
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/FloatNegationNativeTest.java
@@ -0,0 +1,21 @@
+package com.seaofnodes.simple;
+
+import org.junit.Test;
+
+public class FloatNegationNativeTest extends TestC {
+ @Test public void negateRuntimeValues() throws Exception {
+ // Keep negation out of constant folding, including both signs of zero.
+ runSYS("""
+ val neg_noInline={f64 x -> -x;};
+ val main={ ->
+ if( neg_noInline(2.5)!=-2.5 || neg_noInline(-3.75)!=3.75 ) return 1;
+ if( 1.0/neg_noInline(0.0)!=-1e300*1e300 ) return 2;
+ if( 1.0/neg_noInline(-0.0)!=1e300*1e300 ) return 3;
+ if( neg_noInline(1e300*1e300)!=-1e300*1e300 ) return 4;
+ f64 nan=neg_noInline(1e300*1e300-1e300*1e300);
+ if( nan==nan ) return 5;
+ return 0;
+ };
+ ""","floatNegation","",-1);
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
index 66ced278..110a6a38 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
@@ -10,7 +10,7 @@ import static org.junit.Assert.*;
// These tests never open a window and do not need MiniFB installed.
public class GraphicsTest {
- private static String graphics, text, game, clock;
+ private static String graphics, text, game, clock, breakout;
@BeforeClass public static void compilePrograms() throws Exception {
var paths = new Ary<>(new String[]{TestC.RELEASE_SYS_DIR});
@@ -22,6 +22,8 @@ public class GraphicsTest {
"graphics_game",paths,TestC.CALL_CONVENTION,null,null,-1);
clock = TestC.compile(Files.readString(Path.of("docs/examples/Clock.smp")),
"graphics_clock",paths,TestC.CALL_CONVENTION,null,null,-1);
+ breakout = TestC.compile(Files.readString(Path.of("docs/examples/Breakout.smp")),
+ "graphics_breakout",paths,TestC.CALL_CONVENTION,null,null,-1);
}
private static String run(String exe, String backend, int exit) throws Exception {
@@ -101,6 +103,71 @@ public class GraphicsTest {
assertTrue(run(clock,"off",1).contains("disabled"));
}
+ @Test public void breakoutWithoutBackend() throws Exception {
+ assertTrue(run(breakout,"off",1).contains("disabled"));
+ }
+
+ @Test public void breakoutInputAndFrames() throws Exception {
+ Path source=Path.of("build/objs/breakout_input.c");
+ Path library=Path.of("build/objs/breakout_input"+(TestC.OS.startsWith("Windows") ? ".dll" : ".so"));
+ Files.writeString(source,"""
+ #include "simple_graphics.h"
+ #include <stdio.h>
+ #include <unistd.h>
+ static int frames, previous_ball, previous_paddle;
+ static int32_t open_window(const char *s,uint32_t w,uint32_t h) {
+ return w==1008 && h==760 ? 0 : -1;
+ }
+ static int32_t present(const uint32_t *p,uint32_t n) {
+ if(n!=1008*760) return -1;
+ int paddle=-1,ball=-1;
+ for(int x=24;x<984;x++) if(p[675*1008+x]==0x4ce0ef) { paddle=x; break; }
+ for(int y=560;y<674 && ball<0;y++)
+ for(int x=24;x<984;x++) if(p[y*1008+x]==0xeef7ff) { ball=y; break; }
+ int ok=paddle>=0 && ball>=0;
+ if(frames==0) ok=ok && paddle==448 && ball==658;
+ if(frames==1 || frames==6 || frames==9) ok=ok && ball<previous_ball;
+ if(frames==2 || frames==3) ok=ok && paddle>previous_paddle;
+ if(frames==4 || frames==5) ok=ok && paddle==previous_paddle && ball==previous_ball;
+ if(frames==7) ok=ok && paddle==584;
+ if(frames==8) ok=ok && paddle==448 && ball==658;
+ if(!ok) {
+ printf("bad frame %d: paddle %d (was %d), ball %d (was %d)\\n",
+ frames,paddle,previous_paddle,ball,previous_ball);
+ return -1;
+ }
+ previous_ball=ball; previous_paddle=paddle;
+ if(++frames==10) puts("breakout input smoke passed");
+ return 0;
+ }
+ static int32_t poll_events(int32_t n) { return 0; }
+ static int32_t mouse_x(void) { return frames>=7 ? 640 : 504; }
+ static int32_t mouse_y(void) { return 680; }
+ static int32_t key(int32_t k) {
+ return (k==' ' && (frames==1 || frames==9)) ||
+ (k==262 && (frames==2 || frames==3)) ||
+ (k=='P' && (frames==4 || frames==6)) ||
+ (k=='R' && (frames==8 || frames==9));
+ }
+ static int32_t wait_events(int64_t ms) { usleep(ms*1000); return 0; }
+ static void close_window(void) {}
+ static const struct simple_graphics_api api={SIMPLE_GRAPHICS_VERSION,
+ open_window,present,poll_events,mouse_x,mouse_y,poll_events,key,close_window,wait_events};
+ const struct simple_graphics_api *simple_minifb_api(void) { return &api; }
+ """);
+ TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
+ var pb=new ProcessBuilder(Path.of(breakout).toAbsolutePath().toString(),"smoke").redirectErrorStream(true);
+ pb.environment().put("SIMPLE_MINIFB",library.toAbsolutePath().toString());
+ pb.environment().put("SIMPLE_MINIAUDIO","off");
+ Process child=pb.start();
+ try {
+ assertTrue("Breakout timed out",child.waitFor(10,TimeUnit.SECONDS));
+ String output=new String(child.getInputStream().readAllBytes(),java.nio.charset.StandardCharsets.UTF_8);
+ assertEquals(output,0,child.exitValue());
+ assertEquals("breakout input smoke passed\n",output);
+ } finally { if(child.isAlive()) child.destroyForcibly(); }
+ }
+
@Test public void missingLibrary() throws Exception {
String missing = Path.of("build","no-such-minifb-backend").toAbsolutePath().toString();
String output = run(graphics,missing,1);
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/IntrinsicTest.java b/chapter31/src/test/java/com/seaofnodes/simple/IntrinsicTest.java
new file mode 100644
index 00000000..e3b30efb
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/IntrinsicTest.java
@@ -0,0 +1,188 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.Ary;
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class IntrinsicTest {
+ private static final String DECL="""
+ { f64 -> i64 } simple_f64_bits="C";
+ { i64 -> f64 } simple_f64_from_bits="C";
+ """;
+
+ @Test public void constantsAndRawNaNs() {
+ long[] patterns={0,Long.MIN_VALUE,1,0x0010000000000000L,0x3ff0000000000000L,
+ 0x7fefffffffffffffL,0x7ff0000000000000L,0xfff0000000000000L,
+ 0x7ff8000000000001L,0x7ff8000000000002L,0xfff800000000002aL,0x7ff0000000000001L};
+ for(long bits:patterns) {
+ String literal=bits==Long.MIN_VALUE ? "(-9223372036854775807-1)" : Long.toString(bits);
+ CodeGen code=new CodeGen(DECL+"return simple_f64_bits(simple_f64_from_bits("+literal+"));")
+ .driver(CodeGen.Phase.TypeCheck);
+ assertNull(code._stop.walk(n -> n instanceof CallNode ? n : null));
+ assertEquals(Long.toString(bits),Eval2.eval(code,0));
+ }
+ assertNotSame(TypeFloat.constant(Double.longBitsToDouble(patterns[8])),
+ TypeFloat.constant(Double.longBitsToDouble(patterns[9])));
+ }
+
+ @Test public void runtimeNodesAndMemory() {
+ CodeGen code=new CodeGen(DECL+"""
+ val bits=simple_f64_bits;
+ val a=new f64[1];
+ a[0]=simple_f64_from_bits(arg);
+ if( arg==0 ) a[0]=-0.0;
+ return bits(a[0]);
+ """).driver(CodeGen.Phase.TypeCheck);
+ assertNotNull(code._stop.walk(n -> n instanceof Intrinsic.BitCastNode ? n : null));
+ assertNull(code._stop.walk(n -> n instanceof CallNode ? n : null));
+ assertEquals(Long.toString(Long.MIN_VALUE),Eval2.eval(code,0));
+ assertEquals("9221120237041090602",Eval2.eval(code,0x7ff800000000002aL));
+ }
+
+ @Test public void ordinaryFunctionWithSameName() {
+ CodeGen code=new CodeGen("""
+ val simple_f64_bits={ f64 x -> 42; };
+ return simple_f64_bits(1.0);
+ """);
+ assertEquals("42",Eval2.eval(code,0));
+ }
+
+ @Test public void wrongSignature() {
+ try {
+ new CodeGen("{ i64 -> i64 } simple_f64_bits=\"C\"; return simple_f64_bits(arg);")
+ .driver(CodeGen.Phase.TypeCheck);
+ fail("The reserved C symbol has fixed semantics and a fixed signature");
+ } catch(RuntimeException e) {
+ assertTrue(e.getMessage(),e.getMessage().contains("Intrinsic 'simple_f64_bits' requires"));
+ }
+ }
+
+ @Test public void nativeRepresentations() throws Exception {
+ TestC.runSYS("""
+ val bits_noInline={ f64 x -> sys.math.f64Bits(x); };
+ val float_noInline={ i64 x -> sys.math.f64FromBits(x); };
+ val main={ ->
+ val patterns=new i64[~]{0,sys.integer.MIN_I64,1,0x0010000000000000,
+ 0x3ff0000000000000,0x7fefffffffffffff,0x7ff0000000000000,
+ 0x7ff8000000000001,0x7ff8000000000002,-2251799813685206,0x7ff0000000000001};
+ for( int i=0; i<patterns#; i++ )
+ if( bits_noInline(float_noInline(patterns[i]))!=patterns[i] ) return 1;
+ if( bits_noInline(-0.0)!=sys.integer.MIN_I64 ) return 2;
+ if( float_noInline(0x4008000000000000)!=3.0 ) return 3;
+ int numeric=3.75;
+ if( numeric!=3 ) return 4;
+ return 0;
+ };
+ ""","intrinsicNative","",-1);
+ }
+
+ @Test public void indirectCallsUseCFallback() throws Exception {
+ String source=DECL+"""
+ { f64 -> i64 } llround="C";
+ val apply_noInline={ { f64 -> i64 } f, f64 x -> f(x); };
+ val main={ ->
+ if( apply_noInline(simple_f64_bits,-0.0)!=(-9223372036854775807-1) ) return 1;
+ if( apply_noInline(llround,3.75)!=4 ) return 2;
+ if( apply_noInline(simple_f64_bits,1.0)!=0x3ff0000000000000 ) return 3;
+ if( apply_noInline(simple_f64_bits,simple_f64_from_bits(0x7ff800000000002a))!=0x7ff800000000002a ) return 4;
+ return 0;
+ };
+ """;
+ CodeGen code=new CodeGen(source).driver(CodeGen.Phase.TypeCheck);
+ assertNotNull("The indirect C call must survive",code._stop.walk(n ->
+ n instanceof CallNode c && c.external() && !c.tfp().isConstant() ? n : null));
+ TestC.runSYS(source,"intrinsicFallback","",-1);
+ }
+
+ @Test public void importedNodesAndNaNConstants() throws Exception {
+ Path dir=Files.createTempDirectory(Path.of("build/objs"),"intrinsic-import-");
+ String library=DECL+"""
+ val bits_noInline={ f64 x -> simple_f64_bits(x); };
+ val float_noInline={ i64 x -> simple_f64_from_bits(x); };
+ val nan=simple_f64_from_bits(0x7ff8000000000001);
+ val otherNaN=simple_f64_from_bits(0x7ff8000000000002);
+ """;
+ new CodeGen(null,dir.toString(),null,"Bits",library,126,true,TypeInteger.BOT)
+ .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false);
+ var paths=new Ary<>(new String[]{dir.toString()});
+ String[] clients={
+ "return Bits.bits_noInline(Bits.float_noInline(arg));",
+ "return Bits.bits_noInline(Bits.nan);",
+ "return Bits.bits_noInline(Bits.otherNaN);"
+ };
+ long[] expected={0x7ff800000000002aL,0x7ff8000000000001L,0x7ff8000000000002L};
+ for(int i=0;i<clients.length;i++) {
+ CodeGen client=new CodeGen(null,dir.toString(),paths,"Client",clients[i],126,true,TypeInteger.BOT);
+ assertEquals(Long.toString(expected[i]),Eval2.eval(client,expected[0]));
+ }
+ }
+
+ @Test public void allBackendsSelectRepresentationMoves() {
+ // The array store/load and branch keep both directions alive, rather
+ // than allowing the inverse-cast peephole to erase the whole test.
+ String source=DECL+"""
+ val a=new f64[1];
+ a[0]=simple_f64_from_bits(arg);
+ if( arg==0 ) a[0]=-0.0;
+ return simple_f64_bits(a[0]);
+ """;
+ for(String cpu:new String[]{"x86_64_v2","arm","riscv"}) {
+ CodeGen code=new CheckedCodeGen(source).driver(CodeGen.Phase.Encoding,cpu,"SystemV");
+ assertNotNull(code._stop.walk(n -> n instanceof MachConcreteNode m && m.op().equals("f64bits") ? n : null));
+ assertNotNull(code._stop.walk(n -> n instanceof MachConcreteNode m && m.op().equals("f64frombits") ? n : null));
+ }
+ }
+
+ @Test public void invalidArgumentIsNotInlinedAway() {
+ try {
+ new CodeGen(DECL+"return simple_f64_bits(1);").driver(CodeGen.Phase.TypeCheck);
+ fail("Intrinsic inlining must not hide the call's type error");
+ } catch(RuntimeException e) {
+ assertTrue(e.getMessage(),e.getMessage().contains("Argument #1 isa"));
+ }
+ }
+
+ @Test public void discardedValueKeepsArgumentEffects() throws Exception {
+ TestC.runSYS(DECL+"""
+ val next={ i64[] a -> a[0]++; return 1.0; };
+ val main={ ->
+ val a=new i64[1];
+ simple_f64_bits(next(a));
+ return a[0]!=1;
+ };
+ ""","intrinsicEffects","",-1);
+ }
+
+ @Test public void emulatedRepresentationMoves() throws Exception {
+ long[] patterns={0,Long.MIN_VALUE,1,0x3ff0000000000000L,0x7ff0000000000000L,
+ 0xfff0000000000000L,0x7ff800000000002aL,0x7ff0000000000001L};
+ for(boolean toBits:new boolean[]{true,false}) {
+ String source=toBits
+ ? "val cast={ f64 x -> { f64 -> i64 } simple_f64_bits=\"C\"; return simple_f64_bits(x); };"
+ : "val cast={ i64 x -> { i64 -> f64 } simple_f64_from_bits=\"C\"; return simple_f64_from_bits(x); };";
+ var arm=TestArm64.build("cast",source,0,-1,false);
+ var risc=TestRisc5.build(source,"cast",0,-1,false);
+ int armStart=arm._pc, riscStart=risc._pc;
+ for(long bits:patterns) {
+ arm._pc=armStart; risc._pc=riscStart;
+ if(toBits) {
+ arm.fregs[0]=Double.longBitsToDouble(bits);
+ risc.fregs[10]=Double.longBitsToDouble(bits);
+ } else {
+ arm.regs[0]=bits;
+ risc.regs[10]=bits;
+ }
+ assertEquals(0,arm.step(1000));
+ assertEquals(0,risc.step(1000));
+ assertEquals(bits,toBits ? arm.regs[0] : Double.doubleToRawLongBits(arm.fregs[0]));
+ assertEquals(bits,toBits ? risc.regs[10] : Double.doubleToRawLongBits(risc.fregs[10]));
+ }
+ }
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/TypeTest.java b/chapter31/src/test/java/com/seaofnodes/simple/TypeTest.java
index 16b75fdc..52e857e9 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/TypeTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/TypeTest.java
@@ -7,6 +7,26 @@ import static org.junit.Assert.assertSame;
public class TypeTest {
+ @Test public void testConstantArrayElements() {
+ TypeConAry range=TypeConAry.make(TypeInteger.U16,new long[]{5,6,7});
+ Assert.assertEquals("[5-7]",range.toString());
+ Assert.assertEquals("[5-7]",TypeConAry.make(TypeInteger.U8,new long[]{5,6,7}).toString());
+ Assert.assertEquals("[\"abc\"]",TypeConAry.make("abc").toString());
+ for( TypeInteger storage : new TypeInteger[]{TypeInteger.BOOL,TypeInteger.I8,TypeInteger.U8,
+ TypeInteger.I16,TypeInteger.U16,TypeInteger.I32,TypeInteger.U32,TypeInteger.BOT} ) {
+ TypeConAry empty=TypeConAry.make(storage,new long[0]);
+ assertSame(storage.dual(),empty.elem());
+ assertSame(storage,((TypeConAry)empty.dual()).elem());
+ for( long[] values : new long[][]{{0},{1},{0,1},{storage._min,storage._max}} ) {
+ TypeConAry array=TypeConAry.make(storage,values);
+ Assert.assertTrue(empty.isa(array));
+ assertSame(array,empty.meet(array));
+ assertSame(empty,array.join(empty));
+ check_symmetric(empty,array);
+ }
+ }
+ }
+
@Test public void testOpaqueExternalEscapes() {
TypeMem defaults = TypeMem.START.makeFrom(XInt.make(2),XInt.make(3));
TypeMem prior = TypeMem.START.makeFrom(XInt.make(5),XInt.make(7));
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java b/chapter31/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java
index b0f0f225..190cf17c 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java
@@ -3,6 +3,30 @@ import com.seaofnodes.simple.node.*;
import com.seaofnodes.simple.type.TypeInteger;
import static org.junit.Assert.*;
public class PrintRegTestSupport {
+ public static void checkDataAliases(java.nio.file.Path file, int size, String... names) {
+ ElfReader elf=ElfReader.load(file.toFile(),null);
+ assertNotNull(elf);
+ ElfReader.Section symbols=java.util.Arrays.stream(elf._sections)
+ .filter(s -> ".symtab".equals(s._name)).findFirst().orElseThrow();
+ ElfReader.Section strings=elf._sections[symbols._link];
+ var bytes=java.nio.ByteBuffer.wrap(elf._buf).order(java.nio.ByteOrder.LITTLE_ENDIAN);
+ var wanted=new java.util.HashSet<>(java.util.Arrays.asList(names));
+ Long address=null;
+ for( int i=0; i<symbols._size/symbols._esize; i++ ) {
+ int off=(int)symbols._offset+i*symbols._esize;
+ String name=strings.str(bytes.getInt(off));
+ if( !wanted.remove(name) ) continue;
+ assertTrue("Debug aliases precede global symbols",i<symbols._info);
+ assertEquals("Local object symbol",1,bytes.get(off+4)&255);
+ assertEquals(".rodata",elf._sections[bytes.getShort(off+6)&65535]._name);
+ assertEquals(size,bytes.getLong(off+16));
+ long value=bytes.getLong(off+8);
+ if( address!=null ) assertEquals("Aliases share storage",address.longValue(),value);
+ address=value;
+ }
+ assertTrue("Missing debug symbols: "+wanted,wanted.isEmpty());
+ }
+
public static void check() throws Exception {
var code = new CodeGen("return 0;").parse();
var alloc = new RegAlloc(code);