summaryrefslogtreecommitdiff
path: root/chapter31/src/main/java/com/seaofnodes
diff options
context:
space:
mode:
Diffstat (limited to 'chapter31/src/main/java/com/seaofnodes')
-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