Type picks up a log_size for doing struct layouts

6 files changed, 62 insertions, 59 deletions

diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/Type.java b/chapter15/src/main/java/com/seaofnodes/simple/type/Type.java
index cb816848..983fcf98 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/Type.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/Type.java
@@ -179,6 +179,14 @@ public class Type {
     public Type glb() { return _type==TCTRL ? XCONTROL : BOTTOM; }
 
     // ----------------------------------------------------------
+
+    // Size in bits to hold an instance of this type.
+    // Sizes are expected to be between 1 and 64 bits.
+    // Size 0 means this either takes no space (such as a known-zero field)
+    // or isn't a scalar to be stored in memory.
+    public int log_size() { throw Utils.TODO(); }
+
+    // ----------------------------------------------------------
     // Useful in the debugger, which calls toString everywhere.
     // This is a more verbose dev-friendly print.
     @Override
diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeArray.java b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeArray.java
index 32d9259c..8bfbff30 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeArray.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeArray.java
@@ -6,65 +6,32 @@ import java.util.ArrayList;
 /**
  * Represents an array type
  */
-public class TypeArray extends Type {
+public class TypeArray extends TypeStruct {
 
     // An Array has a type and a size; the size is any integer type.
     // The type can be any scalar type, so not e.g. TypeMem.
-    public final Type _type;
-    public final TypeInteger _len;
 
-    private TypeArray(Type type, TypeInteger len) {
-        super(Type.TARRAY);
-        _type = type;
-        _len = len;
+    private TypeArray(TypeInteger len, int lenAlias, Type body, int bodyAlias) {
+        super(TARRAY, "array", new Field[]{Field.make("#",lenAlias,len), Field.make("[]",bodyAlias,body)});
     }
 
     // All fields directly listed
-    public static TypeArray make(Type type, TypeInteger len) { return new TypeArray(type,len).intern(); }
-
-    public static final TypeArray BOT = make(Type.BOTTOM,TypeInteger.BOT);
-    public static final TypeArray FLTS = make(TypeFloat.BOT,TypeInteger.U32);
-
-    public static void gather(ArrayList<Type> ts) { ts.add(BOT); ts.add(FLTS); }
-
-    @Override
-    Type xmeet(Type t) {
-        TypeArray that = (TypeArray) t;
-        Type type = _type.meet(that._type);
-        TypeInteger len = (TypeInteger)_len.meet(that._len);
-        return make(type,len);
-    }
-
-    @Override
-    public TypeArray dual() {
-        return make(_type.dual(),_len.dual());
-    }
-
-    // Keeps the same array, but lower-bounds the type not length
-    @Override
-    public TypeArray glb() {
-        return make(_type.glb(),_len);
-    }
-
-    @Override
-    boolean eq(Type t) {
-        TypeArray ts = (TypeArray)t; // Invariant
-        return _type==ts._type && _len==ts._len;
-    }
-
-    @Override
-    int hash() {
-        return Utils.fold(Utils.rot(_type.hashCode(),17) ^ _len.hashCode());
-    }
-
-    @Override
-    public StringBuilder print(StringBuilder sb) {
-        _type.print(sb).append("[");
-        _len .print(sb).append("]");
-        return sb;
-    }
-
-    @Override public String str() {
-        return _type.str() + "[" + _len.str() + "]";
-    }
+    public static TypeArray make(TypeInteger len, int lenAlias, Type body, int bodyAlias) { return new TypeArray(len,lenAlias,body,bodyAlias).intern(); }
+    public static TypeArray make(int lenAlias, Type body, int bodyAlias) { return make(TypeInteger.BOT,lenAlias,body,bodyAlias); }
+
+    //public static final TypeArray BOT = make(Type.BOTTOM,TypeInteger.BOT);
+    //public static final TypeArray FLTS = make(TypeFloat.BOT,TypeInteger.U32);
+    //
+    //public static void gather(ArrayList<Type> ts) { ts.add(BOT); ts.add(FLTS); }
+
+    //@Override
+    //public StringBuilder print(StringBuilder sb) {
+    //    _type.print(sb).append("[");
+    //    _len .print(sb).append("]");
+    //    return sb;
+    //}
+    //
+    //@Override public String str() {
+    //    return _type.str() + "[" + _len.str() + "]";
+    //}
 }
diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeFloat.java b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
index 975c1a9e..dc36c082 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
@@ -70,6 +70,11 @@ public class TypeFloat extends Type {
     @Override public boolean isHighOrConst() { return _sz<=0; }
     @Override public boolean isConstant()    { return _sz==0; }
 
+    @Override public int log_size() {
+        int sz = _sz==0 ? (isF32() ? 32 : 64) : Math.abs(_sz);
+        return _sz==32 ? 2 : 3;
+    }
+
     public double value() { return _con; }
 
     @Override
@@ -111,4 +116,5 @@ public class TypeFloat extends Type {
         TypeFloat i = (TypeFloat)t; // Contract
         return _con==i._con && _sz==i._sz;
     }
+
 }
diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeInteger.java b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
index aca3e06b..fca3362e 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
@@ -1,5 +1,6 @@
 package com.seaofnodes.simple.type;
 
+import com.seaofnodes.simple.Utils;
 import java.util.ArrayList;
 
 /**
@@ -75,6 +76,14 @@ public class TypeInteger extends Type {
     @Override public boolean isHighOrConst() { return _min >= _max; }
     @Override public boolean isConstant   () { return _min == _max; }
 
+    @Override public int log_size() {
+        if( this==I8  || this==U8 || this==BOOL ) return 0; // 1<<0 == 1 bytes
+        if( this==I16 || this==U16              ) return 1; // 1<<1 == 2 bytes
+        if( this==I32 || this==U32              ) return 2; // 1<<2 == 4 bytes
+        if( this==BOT                           ) return 3; // 1<<3 == 8 bytes
+        throw Utils.TODO();
+    }
+
     public long value() { assert isConstant(); return _min; }
 
     // AND-mask of forced zeros.  e.g. unsigned types will return their mask;
diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
index 06fe2963..7743c80d 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
@@ -6,8 +6,8 @@ import java.util.ArrayList;
  * Represents a Pointer to memory.
  *
  * Null is generic pointer to non-existent memory.
- * *void is a non-Null pointer to all possible structs.
- * Pointers can be to specific struct types, or a union with Null.
+ * *void is a non-Null pointer to all possible refs, both structs and arrays.
+ * Pointers can be to specific struct and array types, or a union with Null.
  * The distinguished *$BOT ptr represents union of *void and Null.
  * The distinguished *$TOP ptr represents the dual of *$BOT.
  */
@@ -33,12 +33,16 @@ public class TypeMemPtr extends Type {
     }
     public static TypeMemPtr make(TypeStruct obj, boolean nil) { return new TypeMemPtr(obj, nil).intern(); }
     public static TypeMemPtr make(TypeStruct obj) { return make(obj, false); }
-    public TypeMemPtr make_from(TypeStruct obj) { return make(obj, _nil); }
+    public TypeMemPtr makeFrom(TypeStruct obj) { return make(obj, _nil); }
 
+    // An abstract pointer, pointing to either a Struct or an Array.
+    // Can also be null or not.
     public static TypeMemPtr BOT = make(TypeStruct.BOT,true);
     public static TypeMemPtr TOP = BOT.dual();
+    // An abstract null (can be Struct or Array) or not-null C void*
     public static TypeMemPtr NULLPTR = make(TypeStruct.TOP,true);
     public static TypeMemPtr VOIDPTR = NULLPTR.dual(); // A bottom mix of not-null ptrs, like C's void* but not null
+
     public static TypeMemPtr TEST= make(TypeStruct.TEST,false);
     public static void gather(ArrayList<Type> ts) { ts.add(NULLPTR); ts.add(BOT); ts.add(TEST); }
 
@@ -52,11 +56,13 @@ public class TypeMemPtr extends Type {
     public TypeMemPtr dual() { return TypeMemPtr.make(_obj.dual(), !_nil); }
 
     @Override
-    public Type glb() { return make(_obj.glb(),true); }
+    public TypeMemPtr glb() { return make(_obj.glb(),true); }
     @Override public TypeMemPtr makeInit() { return NULLPTR; }
 
     @Override public boolean isHigh() { return this==TOP; }
 
+    @Override public int log_size() { return 2; } // (1<<2)==4-byte pointers
+
     @Override
     int hash() { return _obj.hashCode() ^ (_nil ? 1024 : 0); }
 
diff --git a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeTuple.java b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeTuple.java
index 783f3f60..59ddf34b 100644
--- a/chapter15/src/main/java/com/seaofnodes/simple/type/TypeTuple.java
+++ b/chapter15/src/main/java/com/seaofnodes/simple/type/TypeTuple.java
@@ -46,7 +46,14 @@ public class TypeTuple extends Type {
         return sb;
     }
 
-    @Override public String str() { return print(new StringBuilder()).toString(); }
+    @Override public String str() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[  ");
+        for( Type t : _types )
+            sb.append(t.str()).append(", ");
+        sb.setLength(sb.length()-2);
+        return sb.append("]").toString();
+    }
 
     /**
      * Display Type name in a format that's good for IR printer