[NFC] Encode reference types with bit packing (#7142)

Value types were previously represented internally as either enum values
for "basic," i.e. non-reference, non-tuple types or pointers to
`TypeInfo` structs encoding either references or tuples. Update the
representation of reference types to use one bit to encode nullability
and the rest of the bits to encode the referenced heap type. This allows
canonical reference types to be created with a single logical or rather
than by taking a lock on a global type store and doing a hash map lookup
to canonicalize.

This change is a massive performance improvement and dramatically
improves how performance scales with threads because the removed lock
was highly contended. Even with a single core, the performance of an O3
optimization pipeline on a WasmGC module improves by 6%. With 8 cores,
the improvement increases to 29% and with all 128 threads on my machine,
the improvement reaches 46%.

The full new encoding of types is as follows:

 - If the type ID is within the range of the basic types, the type is
   the corresponding basic type.

 - Otherwise, if bit 0 is set, the type is a tuple and the rest of the
   bits are a canonical pointer to the tuple.

 - Otherwise, the type is a reference type. Bit 1 determines the
   nullability and the rest of the bits encode the heap type.

Also update the encodings of basic heap types so they no longer use the
low two bits to avoid conflicts with the use of those bits in the
encoding of types.

1 files changed, 0 insertions, 8 deletions

diff --git a/test/gtest/type-builder.cpp b/test/gtest/type-builder.cpp
index 97943551f..514df0c59 100644
--- a/test/gtest/type-builder.cpp
+++ b/test/gtest/type-builder.cpp
@@ -164,7 +164,6 @@ TEST_F(TypeTest, Basics) {
   TypeBuilder builder(3);
   ASSERT_EQ(builder.size(), size_t{3});
 
-  Type refSig = builder.getTempRefType(builder[0], NonNullable);
   Type refStruct = builder.getTempRefType(builder[1], NonNullable);
   Type refArray = builder.getTempRefType(builder[2], NonNullable);
   Type refNullArray = builder.getTempRefType(builder[2], Nullable);
@@ -191,7 +190,6 @@ TEST_F(TypeTest, Basics) {
   ASSERT_TRUE(built[2].isArray());
 
   // The built types should have the correct structure.
-  Type newRefSig = Type(built[0], NonNullable);
   Type newRefStruct = Type(built[1], NonNullable);
   Type newRefArray = Type(built[2], NonNullable);
   Type newRefNullArray = Type(built[2], Nullable);
@@ -200,12 +198,6 @@ TEST_F(TypeTest, Basics) {
             Signature(newRefStruct, {newRefArray, Type::i32}));
   EXPECT_EQ(built[1].getStruct(), Struct({Field(newRefNullArray, Immutable)}));
   EXPECT_EQ(built[2].getArray(), Array(Field(refNullAny, Mutable)));
-
-  // The built types should be different from the temporary types.
-  EXPECT_NE(newRefSig, refSig);
-  EXPECT_NE(newRefStruct, refStruct);
-  EXPECT_NE(newRefArray, refArray);
-  EXPECT_NE(newRefNullArray, refNullArray);
 }
 
 TEST_F(TypeTest, DirectSelfSupertype) {