Type as int64

Author: Zoltan Herczeg

Diff for: include/wabt/type.h

@@ -34,7 +34,7 @@ using TypeVector = std::vector<Type>;
 class Type {
  public:
   // Matches binary format, do not change.
-  enum Enum : int32_t {
+  enum Enum : int64_t {
     I32 = -0x01,        // 0x7f
     I64 = -0x02,        // 0x7e
     F32 = -0x03,        // 0x7d
@@ -45,7 +45,7 @@ class Type {
     ExnRef = -0x17,     // 0x69
     FuncRef = -0x10,    // 0x70
     ExternRef = -0x11,  // 0x6f
-    Reference = -0x15,  // 0x6b
+    Reference = -0x15,  // 0x6b  : upper 32 bit contains an index
     Func = -0x20,       // 0x60
     Struct = -0x21,     // 0x5f
     Array = -0x22,      // 0x5e
@@ -59,28 +59,32 @@ class Type {
   };
 
   Type() = default;  // Provided so Type can be member of a union.
-  Type(int32_t code)
-      : enum_(static_cast<Enum>(code)), type_index_(kInvalidIndex) {}
-  Type(Enum e) : enum_(e), type_index_(kInvalidIndex) {}
-  Type(Enum e, Index type_index) : enum_(e), type_index_(type_index) {
-    assert(e == Enum::Reference);
+  Type(int32_t code) : enum_(code) {}
+  Type(Enum e) : enum_(static_cast<int64_t>(e)) {}
+  Type(Enum e, Index type_index) {
+    assert(Type(e).IsReferenceWithIndex());
+    enum_ = static_cast<uint32_t>(e) | (static_cast<int64_t>(type_index) << 32);
   }
-  constexpr operator Enum() const { return enum_; }
+  // Returns the full type, including any properties (e.g. index or nullable)
+  constexpr operator Enum() const { return static_cast<Enum>(enum_); }
+  // Returns the type only, excluding any properties (e.g. index or nullable).
+  constexpr Enum code() const { return static_cast<Enum>(static_cast<int32_t>(enum_)); }
 
   bool IsRef() const {
-    return enum_ == Type::ExternRef || enum_ == Type::FuncRef ||
-           enum_ == Type::Reference || enum_ == Type::ExnRef;
+    Enum type = code();
+    return type == Type::ExternRef || type == Type::FuncRef ||
+           type == Type::Reference || type == Type::ExnRef;
   }
 
-  bool IsReferenceWithIndex() const { return enum_ == Type::Reference; }
+  bool IsReferenceWithIndex() const { return code() == Type::Reference; }
 
   bool IsNullableRef() const {
     // Currently all reftypes are nullable
     return IsRef();
   }
 
   std::string GetName() const {
-    switch (enum_) {
+    switch (code()) {
       case Type::I32:       return "i32";
       case Type::I64:       return "i64";
       case Type::F32:       return "f32";
@@ -95,14 +99,14 @@ class Type {
       case Type::Any:       return "any";
       case Type::ExternRef: return "externref";
       case Type::Reference:
-        return StringPrintf("(ref %d)", type_index_);
+        return StringPrintf("(ref %d)", GetReferenceIndex());
       default:
-        return StringPrintf("<type_index[%d]>", enum_);
+        return StringPrintf("<type_index[%d]>", static_cast<int>(code()));
     }
   }
 
   const char* GetRefKindName() const {
-    switch (enum_) {
+    switch (code()) {
       case Type::FuncRef:   return "func";
       case Type::ExternRef: return "extern";
       case Type::ExnRef:    return "exn";
@@ -132,13 +136,13 @@ class Type {
   }
 
   Index GetReferenceIndex() const {
-    assert(enum_ == Enum::Reference);
-    return type_index_;
+    assert(IsReferenceWithIndex());
+    return static_cast<Index>(enum_ >> 32);
   }
 
   TypeVector GetInlineVector() const {
     assert(!IsIndex());
-    switch (enum_) {
+    switch (code()) {
       case Type::Void:
         return TypeVector();
 
@@ -159,8 +163,7 @@ class Type {
   }
 
  private:
-  Enum enum_;
-  Index type_index_;  // Only used for for Type::Reference
+  int64_t enum_;
 };
 
 }  // namespace wabt

Diff for: src/binary-reader.cc

@@ -365,7 +365,7 @@ Result BinaryReader::ReadS64Leb128(uint64_t* out_value, const char* desc) {
 Result BinaryReader::ReadType(Type* out_value, const char* desc) {
   uint32_t type = 0;
   CHECK_RESULT(ReadS32Leb128(&type, desc));
-  if (static_cast<Type::Enum>(type) == Type::Reference) {
+  if (type == static_cast<uint32_t>(Type::Reference)) {
     uint32_t heap_type = 0;
     CHECK_RESULT(ReadS32Leb128(&heap_type, desc));
     *out_value = Type(Type::Reference, heap_type);
@@ -555,7 +555,7 @@ Result BinaryReader::ReadField(TypeMut* out_value) {
 }
 
 bool BinaryReader::IsConcreteType(Type type) {
-  switch (type) {
+  switch (type.code()) {
     case Type::I32:
     case Type::I64:
     case Type::F32:

Diff for: src/c-writer.cc

@@ -2493,7 +2493,7 @@ void CWriter::WriteElemTableInit(bool active_initialization,
                                  const ElemSegment* src_segment,
                                  const Table* dst_table) {
   assert(dst_table->elem_type.IsRef() &&
-         dst_table->elem_type != Type::Reference);
+         dst_table->elem_type.code() != Type::Reference);
   assert(dst_table->elem_type == src_segment->elem_type);
 
   Write(GetReferenceTypeName(dst_table->elem_type), "_table_init(",

Diff for: src/interp/interp-util.cc

@@ -24,7 +24,7 @@ namespace wabt {
 namespace interp {
 
 std::string TypedValueToString(const TypedValue& tv) {
-  switch (tv.type) {
+  switch (tv.type.code()) {
     case Type::I32:
       return StringPrintf("i32:%u", tv.value.Get<s32>());
 

Diff for: src/type-checker.cc

@@ -33,7 +33,8 @@ std::string TypesToString(const TypeVector& types,
     Type ty = types[i];
     // NOTE: Reference (and GetName) is also used by (e.g.) objdump, which does
     // not apply validation. do this here so as to not break that.
-    if (ty == Type::Reference && ty.GetReferenceIndex() == kInvalidIndex) {
+    if (ty.code() == Type::Reference &&
+        ty.GetReferenceIndex() == kInvalidIndex) {
       result += "reference";
     } else {
       result += types[i].GetName();
@@ -233,11 +234,6 @@ Result TypeChecker::CheckType(Type actual, Type expected) {
     return Result::Ok;
   }
 
-  if (expected == Type::Reference && actual == Type::Reference) {
-    return expected.GetReferenceIndex() == actual.GetReferenceIndex()
-               ? Result::Ok
-               : Result::Error;
-  }
   if (actual != expected) {
     return Result::Error;
   }

Diff for: src/wast-parser.cc

@@ -324,7 +324,8 @@ void ResolveTypeName(
     Type& type,
     Index index,
     const std::unordered_map<uint32_t, std::string>& bindings) {
-  if (type != Type::Reference || type.GetReferenceIndex() != kInvalidIndex) {
+  if (type.code() != Type::Reference ||
+      type.GetReferenceIndex() != kInvalidIndex) {
     return;
   }