summaryrefslogtreecommitdiff
path: root/chapter31/src/main/java
diff options
context:
space:
mode:
authorCliff Click <cliffc@acm.org>2026-11-14 12:41:16 -0800
committerCliff Click <cliffc@acm.org>2026-11-14 12:41:16 -0800
commit3d0f3f38d9d8345b6508b3289dc94b0500c53d9e (patch)
tree1b769cdc4e415fad5c1b18afa23ffc6fe56db18a /chapter31/src/main/java
parentafcf96444366fb4b7c83f938763013cbc360aade (diff)
downloadSimple-3d0f3f38d9d8345b6508b3289dc94b0500c53d9e.tar.gz
Simple-3d0f3f38d9d8345b6508b3289dc94b0500c53d9e.zip
Breakout, Clock demos
Math lib with simple constants raw bit converters TypeConAry unified Big Formatting change Debug symbols for constant data IterPeeps was endlessly running asserts with much inlining RegAlloc rounds raised
Diffstat (limited to 'chapter31/src/main/java')
-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
32 files changed, 456 insertions, 111 deletions
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