[NFC] Represent exactness and sharedness with one bit (#7500)

Since the Type representation only needs to include a bit for sharedness
for basic heap types and only needs to include a bit for exactness for
non-basic heap types, they can use the same bit. Using fewer bits in the
Type representation is beneficial because it reduces the minimum
alignment of HeapTypeInfos required to avoid trampling the reserved
bits.

Author: tlively

src/wasm-type.h

@@ -96,9 +96,10 @@ class HeapType {
   // should also be passed by value.
   uintptr_t id;
 
-  static constexpr int TypeBits = 3;
+  static constexpr int TypeBits = 2;
   static constexpr int UsedBits = TypeBits + 1;
   static constexpr int SharedMask = 1 << TypeBits;
+  friend class Type;
 
 public:
   // Bits 0-2 are used by the Type representation, so need to be left free.
@@ -290,6 +291,11 @@ class Type {
   static constexpr int NullMask = 1 << 1;
   static constexpr int ExactMask = 1 << 2;
 
+  // Only abstract heap types store sharedness as a bit in the representation
+  // and only non-abstract heap types can be exact, so exactness and sharedness
+  // can use the same bit.
+  static_assert(ExactMask == HeapType::SharedMask);
+
 public:
   enum BasicType : uint32_t {
     none = 0,
@@ -322,7 +328,8 @@ class Type {
   Type(HeapType heapType, Nullability nullable, Exactness exact = Inexact)
     : Type(heapType.getID() | (nullable == Nullable ? NullMask : 0) |
            (exact == Exact ? ExactMask : 0)) {
-    assert(!(heapType.getID() & (TupleMask | NullMask | ExactMask)));
+    assert(!(heapType.getID() &
+             (TupleMask | NullMask | (heapType.isBasic() ? 0 : ExactMask))));
     assert(!heapType.isBasic() || exact == Inexact);
   }
 
@@ -372,11 +379,18 @@ class Type {
   bool isRef() const { return !isBasic() && !(id & TupleMask); }
   bool isNullable() const { return isRef() && (id & NullMask); }
   bool isNonNullable() const { return isRef() && !(id & NullMask); }
-  bool isExact() const { return isRef() && (id & ExactMask); }
+  bool isExact() const {
+    return isRef() && !getHeapType().isBasic() && (id & ExactMask);
+  }
   bool isInexact() const { return isRef() && !(id & ExactMask); }
   HeapType getHeapType() const {
     assert(isRef());
-    return HeapType(id & ~(NullMask | ExactMask));
+    HeapType masked(id & ~NullMask);
+    // Avoid masking off the shared bit on basic heap types.
+    if (!masked.isBasic()) {
+      masked = HeapType(masked.id & ~ExactMask);
+    }
+    return masked;
   }
 
   bool isFunction() const { return isRef() && getHeapType().isFunction(); }

test/example/c-api-kitchen-sink.txt

@@ -20,17 +20,17 @@ BinaryenTypeAuto: -1
 BinaryenPackedTypeNotPacked: 0
 BinaryenPackedTypeInt8: 1
 BinaryenPackedTypeInt16: 2
-BinaryenHeapTypeExt: 16
-BinaryenHeapTypeFunc: 32
-BinaryenHeapTypeAny: 64
-BinaryenHeapTypeEq: 80
-BinaryenHeapTypeI31: 96
-BinaryenHeapTypeStruct: 112
-BinaryenHeapTypeArray: 128
-BinaryenHeapTypeString: 160
-BinaryenHeapTypeNone: 176
-BinaryenHeapTypeNoext: 192
-BinaryenHeapTypeNofunc: 208
+BinaryenHeapTypeExt: 8
+BinaryenHeapTypeFunc: 16
+BinaryenHeapTypeAny: 32
+BinaryenHeapTypeEq: 40
+BinaryenHeapTypeI31: 48
+BinaryenHeapTypeStruct: 56
+BinaryenHeapTypeArray: 64
+BinaryenHeapTypeString: 80
+BinaryenHeapTypeNone: 88
+BinaryenHeapTypeNoext: 96
+BinaryenHeapTypeNofunc: 104
 BinaryenFeatureMVP: 0
 BinaryenFeatureAtomics: 1
 BinaryenFeatureBulkMemory: 16