From ce8b6e6a13fc6a60640b3fe84fdf20d8aa94cc3e Mon Sep 17 00:00:00 2001 From: Cliff Click Date: Mon, 23 Sep 2024 14:34:57 -0700 Subject: Type picks up a log_size for doing struct layouts --- .../main/java/com/seaofnodes/simple/type/Type.java | 8 +++ .../java/com/seaofnodes/simple/type/TypeArray.java | 75 ++++++---------------- .../java/com/seaofnodes/simple/type/TypeFloat.java | 6 ++ .../com/seaofnodes/simple/type/TypeInteger.java | 9 +++ .../com/seaofnodes/simple/type/TypeMemPtr.java | 14 ++-- .../java/com/seaofnodes/simple/type/TypeTuple.java | 9 ++- 6 files changed, 62 insertions(+), 59 deletions(-) (limited to 'chapter15/src/main') 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 @@ -178,6 +178,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. 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 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 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 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 -- cgit v1.2.3