[wasm] Small refactoring for module types

Changes:
- Introduce {TypeDefinition} for wasm modules.
- Introduce an enum {TypeDefinition::Kind} to represent the three
  different definition types.
- Collapse the {types}, {type_kinds} and {supertypes} vectors into a
  single vector of {TypeDefinition}s.
- Use {TypeDefinition} in WasmModuleBuilder.
- Drive-by: Remove {kNullIndex} in WasmModuleBuilder.
- Drive-by: Tidy-up wasm-module.h.

Change-Id: I97c2c268bcad745176243c693cf169bfa5714f94
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3416233Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Manos Koukoutos <manoskouk@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78813}

src/wasm/module-decoder.cc

@@ -666,16 +666,16 @@ class ModuleDecoderImpl : public Decoder {
         errorf("type %d: cyclic inheritance", i);
         continue;
       }
-      switch (module_->type_kinds[i]) {
-        case kWasmStructTypeCode:
+      switch (module_->types[i].kind) {
+        case TypeDefinition::kStruct:
           if (!module->has_struct(explicit_super)) break;
           if (!StructIsSubtypeOf(i, explicit_super, module, module)) break;
           continue;
-        case kWasmArrayTypeCode:
+        case TypeDefinition::kArray:
           if (!module->has_array(explicit_super)) break;
           if (!ArrayIsSubtypeOf(i, explicit_super, module, module)) break;
           continue;
-        case kWasmFunctionTypeCode:
+        case TypeDefinition::kFunction:
           if (!module->has_signature(explicit_super)) break;
           if (!FunctionIsSubtypeOf(i, explicit_super, module, module)) break;
           continue;

src/wasm/module-instantiate.cc

@@ -230,14 +230,14 @@ void CreateMapForType(Isolate* isolate, const WasmModule* module,
     rtt_parent = handle(Map::cast(maps->get(supertype)), isolate);
   }
   Handle<Map> map;
-  switch (module->type_kinds[type_index]) {
-    case kWasmStructTypeCode:
+  switch (module->types[type_index].kind) {
+    case TypeDefinition::kStruct:
       map = CreateStructMap(isolate, module, type_index, rtt_parent, instance);
       break;
-    case kWasmArrayTypeCode:
+    case TypeDefinition::kArray:
       map = CreateArrayMap(isolate, module, type_index, rtt_parent, instance);
       break;
-    case kWasmFunctionTypeCode:
+    case TypeDefinition::kFunction:
       // TODO(7748): Create funcref RTTs lazily?
       // TODO(7748): Canonicalize function maps (cross-module)?
       map = CreateFuncRefMap(isolate, module, rtt_parent, instance);
@@ -711,8 +711,8 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
   //--------------------------------------------------------------------------
   if (enabled_.has_gc()) {
     Handle<FixedArray> maps = isolate_->factory()->NewFixedArray(
-        static_cast<int>(module_->type_kinds.size()));
-    for (uint32_t index = 0; index < module_->type_kinds.size(); index++) {
+        static_cast<int>(module_->types.size()));
+    for (uint32_t index = 0; index < module_->types.size(); index++) {
       CreateMapForType(isolate_, module_, index, instance, maps);
     }
     instance->set_managed_object_maps(*maps);

src/wasm/wasm-module-builder.cc

@@ -58,7 +58,7 @@ void WasmFunctionBuilder::EmitI32V(int32_t val) { body_.write_i32v(val); }
 
 void WasmFunctionBuilder::EmitU32V(uint32_t val) { body_.write_u32v(val); }
 
-void WasmFunctionBuilder::SetSignature(FunctionSig* sig) {
+void WasmFunctionBuilder::SetSignature(const FunctionSig* sig) {
   DCHECK(!locals_.has_sig());
   locals_.set_sig(sig);
   signature_index_ = builder_->AddSignature(sig);
@@ -274,7 +274,7 @@ WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
       has_max_memory_size_(false),
       has_shared_memory_(false) {}
 
-WasmFunctionBuilder* WasmModuleBuilder::AddFunction(FunctionSig* sig) {
+WasmFunctionBuilder* WasmModuleBuilder::AddFunction(const FunctionSig* sig) {
   functions_.push_back(zone_->New<WasmFunctionBuilder>(this));
   // Add the signature if one was provided here.
   if (sig) functions_.back()->SetSignature(sig);
@@ -290,21 +290,22 @@ void WasmModuleBuilder::AddDataSegment(const byte* data, uint32_t size,
   }
 }
 
-uint32_t WasmModuleBuilder::ForceAddSignature(FunctionSig* sig,
+uint32_t WasmModuleBuilder::ForceAddSignature(const FunctionSig* sig,
                                               uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
   signature_map_.emplace(*sig, index);
-  types_.push_back(Type(sig, supertype));
+  types_.emplace_back(sig, supertype);
   return index;
 }
 
-uint32_t WasmModuleBuilder::AddSignature(FunctionSig* sig, uint32_t supertype) {
+uint32_t WasmModuleBuilder::AddSignature(const FunctionSig* sig,
+                                         uint32_t supertype) {
   auto sig_entry = signature_map_.find(*sig);
   if (sig_entry != signature_map_.end()) return sig_entry->second;
   return ForceAddSignature(sig, supertype);
 }
 
-uint32_t WasmModuleBuilder::AddException(FunctionSig* type) {
+uint32_t WasmModuleBuilder::AddException(const FunctionSig* type) {
   DCHECK_EQ(0, type->return_count());
   int type_index = AddSignature(type);
   uint32_t except_index = static_cast<uint32_t>(exceptions_.size());
@@ -315,20 +316,16 @@ uint32_t WasmModuleBuilder::AddException(FunctionSig* type) {
 uint32_t WasmModuleBuilder::AddStructType(StructType* type,
                                           uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
-  types_.push_back(Type(type, supertype));
+  types_.emplace_back(type, supertype);
   return index;
 }
 
 uint32_t WasmModuleBuilder::AddArrayType(ArrayType* type, uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
-  types_.push_back(Type(type, supertype));
+  types_.emplace_back(type, supertype);
   return index;
 }
 
-// static
-const uint32_t WasmModuleBuilder::kNullIndex =
-    std::numeric_limits<uint32_t>::max();
-
 uint32_t WasmModuleBuilder::IncreaseTableMinSize(uint32_t table_index,
                                                  uint32_t count) {
   DCHECK_LT(table_index, tables_.size());
@@ -600,11 +597,11 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
     size_t start = EmitSection(kTypeSectionCode, buffer);
     buffer->write_size(types_.size());
 
-    for (const Type& type : types_) {
+    for (const TypeDefinition& type : types_) {
       bool has_super = type.supertype != kNoSuperType;
       switch (type.kind) {
-        case Type::kFunctionSig: {
-          FunctionSig* sig = type.sig;
+        case TypeDefinition::kFunction: {
+          const FunctionSig* sig = type.function_sig;
           buffer->write_u8(has_super ? kWasmFunctionSubtypeCode
                                      : kWasmFunctionTypeCode);
           buffer->write_size(sig->parameter_count());
@@ -622,8 +619,8 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
           }
           break;
         }
-        case Type::kStructType: {
-          StructType* struct_type = type.struct_type;
+        case TypeDefinition::kStruct: {
+          const StructType* struct_type = type.struct_type;
           buffer->write_u8(has_super ? kWasmStructSubtypeCode
                                      : kWasmStructTypeCode);
           buffer->write_size(struct_type->field_count());
@@ -638,8 +635,8 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
           }
           break;
         }
-        case Type::kArrayType: {
-          ArrayType* array_type = type.array_type;
+        case TypeDefinition::kArray: {
+          const ArrayType* array_type = type.array_type;
           buffer->write_u8(has_super ? kWasmArraySubtypeCode
                                      : kWasmArrayTypeCode);
           WriteValueType(buffer, array_type->element_type());

src/wasm/wasm-module-builder.h

@@ -166,7 +166,7 @@ class WasmModuleBuilder;
 class V8_EXPORT_PRIVATE WasmFunctionBuilder : public ZoneObject {
  public:
   // Building methods.
-  void SetSignature(FunctionSig* sig);
+  void SetSignature(const FunctionSig* sig);
   uint32_t AddLocal(ValueType type);
   void EmitByte(byte b);
   void EmitI32V(int32_t val);
@@ -208,7 +208,7 @@ class V8_EXPORT_PRIVATE WasmFunctionBuilder : public ZoneObject {
   WasmModuleBuilder* builder() const { return builder_; }
   uint32_t func_index() { return func_index_; }
   uint32_t sig_index() { return signature_index_; }
-  inline FunctionSig* signature();
+  inline const FunctionSig* signature();
 
  private:
   explicit WasmFunctionBuilder(WasmModuleBuilder* builder);
@@ -311,7 +311,7 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
   // Building methods.
   uint32_t AddImport(base::Vector<const char> name, FunctionSig* sig,
                      base::Vector<const char> module = {});
-  WasmFunctionBuilder* AddFunction(FunctionSig* sig = nullptr);
+  WasmFunctionBuilder* AddFunction(const FunctionSig* sig = nullptr);
   uint32_t AddGlobal(ValueType type, bool mutability = true,
                      WasmInitExpr init = WasmInitExpr());
   uint32_t AddGlobalImport(base::Vector<const char> name, ValueType type,
@@ -332,11 +332,12 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
   // exceeded.
   uint32_t IncreaseTableMinSize(uint32_t table_index, uint32_t count);
   // Adds the signature to the module if it does not already exist.
-  uint32_t AddSignature(FunctionSig* sig, uint32_t supertype = kNoSuperType);
+  uint32_t AddSignature(const FunctionSig* sig,
+                        uint32_t supertype = kNoSuperType);
   // Does not deduplicate function signatures.
-  uint32_t ForceAddSignature(FunctionSig* sig,
+  uint32_t ForceAddSignature(const FunctionSig* sig,
                              uint32_t supertype = kNoSuperType);
-  uint32_t AddException(FunctionSig* type);
+  uint32_t AddException(const FunctionSig* type);
   uint32_t AddStructType(StructType* type, uint32_t supertype = kNoSuperType);
   uint32_t AddArrayType(ArrayType* type, uint32_t supertype = kNoSuperType);
   uint32_t AddTable(ValueType type, uint32_t min_size);
@@ -365,25 +366,27 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
   ValueType GetTableType(uint32_t index) { return tables_[index].type; }
 
   bool IsSignature(uint32_t index) {
-    return types_[index].kind == Type::kFunctionSig;
+    return types_[index].kind == TypeDefinition::kFunction;
   }
 
-  FunctionSig* GetSignature(uint32_t index) {
-    DCHECK(types_[index].kind == Type::kFunctionSig);
-    return types_[index].sig;
+  const FunctionSig* GetSignature(uint32_t index) {
+    DCHECK(types_[index].kind == TypeDefinition::kFunction);
+    return types_[index].function_sig;
   }
 
   bool IsStructType(uint32_t index) {
-    return types_[index].kind == Type::kStructType;
+    return types_[index].kind == TypeDefinition::kStruct;
   }
-  StructType* GetStructType(uint32_t index) {
+  const StructType* GetStructType(uint32_t index) {
     return types_[index].struct_type;
   }
 
   bool IsArrayType(uint32_t index) {
-    return types_[index].kind == Type::kArrayType;
+    return types_[index].kind == TypeDefinition::kArray;
+  }
+  const ArrayType* GetArrayType(uint32_t index) {
+    return types_[index].array_type;
   }
-  ArrayType* GetArrayType(uint32_t index) { return types_[index].array_type; }
 
   WasmFunctionBuilder* GetFunction(uint32_t index) { return functions_[index]; }
   int NumExceptions() { return static_cast<int>(exceptions_.size()); }
@@ -394,30 +397,11 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
 
   int NumFunctions() { return static_cast<int>(functions_.size()); }
 
-  FunctionSig* GetExceptionType(int index) {
-    return types_[exceptions_[index]].sig;
+  const FunctionSig* GetExceptionType(int index) {
+    return types_[exceptions_[index]].function_sig;
   }
 
-  static const uint32_t kNullIndex;
-
  private:
-  struct Type {
-    enum Kind { kFunctionSig, kStructType, kArrayType };
-    explicit Type(FunctionSig* signature, uint32_t supertype)
-        : kind(kFunctionSig), supertype(supertype), sig(signature) {}
-    explicit Type(StructType* struct_type, uint32_t supertype)
-        : kind(kStructType), supertype(supertype), struct_type(struct_type) {}
-    explicit Type(ArrayType* array_type, uint32_t supertype)
-        : kind(kArrayType), supertype(supertype), array_type(array_type) {}
-    Kind kind;
-    uint32_t supertype;
-    union {
-      FunctionSig* sig;
-      StructType* struct_type;
-      ArrayType* array_type;
-    };
-  };
-
   struct WasmFunctionImport {
     base::Vector<const char> module;
     base::Vector<const char> name;
@@ -460,7 +444,7 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
 
   friend class WasmFunctionBuilder;
   Zone* zone_;
-  ZoneVector<Type> types_;
+  ZoneVector<TypeDefinition> types_;
   ZoneVector<WasmFunctionImport> function_imports_;
   ZoneVector<WasmGlobalImport> global_imports_;
   ZoneVector<WasmExport> exports_;
@@ -482,8 +466,8 @@ class V8_EXPORT_PRIVATE WasmModuleBuilder : public ZoneObject {
 #endif
 };
 
-FunctionSig* WasmFunctionBuilder::signature() {
-  return builder_->types_[signature_index_].sig;
+const FunctionSig* WasmFunctionBuilder::signature() {
+  return builder_->types_[signature_index_].function_sig;
 }
 
 }  // namespace wasm

src/wasm/wasm-module.cc

@@ -629,7 +629,7 @@ size_t EstimateStoredSize(const WasmModule* module) {
   return sizeof(WasmModule) + VectorSize(module->globals) +
          (module->signature_zone ? module->signature_zone->allocation_size()
                                  : 0) +
-         VectorSize(module->types) + VectorSize(module->type_kinds) +
+         VectorSize(module->types) +
          VectorSize(module->canonicalized_type_ids) +
          VectorSize(module->functions) + VectorSize(module->data_segments) +
          VectorSize(module->tables) + VectorSize(module->import_table) +

src/wasm/wasm-module.h

@@ -345,14 +345,22 @@ class V8_EXPORT_PRIVATE AsmJsOffsetInformation {
 };
 
 struct TypeDefinition {
-  explicit TypeDefinition(const FunctionSig* sig) : function_sig(sig) {}
-  explicit TypeDefinition(const StructType* type) : struct_type(type) {}
-  explicit TypeDefinition(const ArrayType* type) : array_type(type) {}
+  enum Kind { kFunction, kStruct, kArray };
+
+  TypeDefinition(const FunctionSig* sig, uint32_t supertype)
+      : function_sig(sig), supertype(supertype), kind(kFunction) {}
+  TypeDefinition(const StructType* type, uint32_t supertype)
+      : struct_type(type), supertype(supertype), kind(kStruct) {}
+  TypeDefinition(const ArrayType* type, uint32_t supertype)
+      : array_type(type), supertype(supertype), kind(kArray) {}
+
   union {
     const FunctionSig* function_sig;
     const StructType* struct_type;
     const ArrayType* array_type;
   };
+  uint32_t supertype;
+  Kind kind;
 };
 
 struct V8_EXPORT_PRIVATE WasmDebugSymbols {
@@ -379,9 +387,9 @@ struct TypeFeedbackStorage {
 struct WasmTable;
 
 // End of a chain of explicit supertypes.
-constexpr uint32_t kGenericSuperType = 0xFFFFFFFE;
+constexpr uint32_t kGenericSuperType = std::numeric_limits<uint32_t>::max() - 1;
 // Used for types that have no explicit supertype.
-constexpr uint32_t kNoSuperType = 0xFFFFFFFF;
+constexpr uint32_t kNoSuperType = std::numeric_limits<uint32_t>::max();
 
 // Static representation of a module.
 struct V8_EXPORT_PRIVATE WasmModule {
@@ -395,7 +403,6 @@ struct V8_EXPORT_PRIVATE WasmModule {
   bool mem_export = false;         // true if the memory is exported
   int start_function_index = -1;   // start function, >= 0 if any
 
-  std::vector<WasmGlobal> globals;
   // Size of the buffer required for all globals that are not imported and
   // mutable.
   uint32_t untagged_globals_buffer_size = 0;
@@ -410,26 +417,17 @@ struct V8_EXPORT_PRIVATE WasmModule {
   // ID and length).
   WireBytesRef code = {0, 0};
   WireBytesRef name = {0, 0};
-  std::vector<TypeDefinition> types;  // by type index
-  std::vector<uint8_t> type_kinds;    // by type index
-  std::vector<uint32_t> supertypes;   // by type index
-  // Map from each type index to the index of its corresponding canonical index.
-  // Canonical indices do not correspond to types.
-  // Note: right now, only functions are canonicalized, and arrays and structs
-  // map to 0.
-  std::vector<uint32_t> canonicalized_type_ids;
 
   bool has_type(uint32_t index) const { return index < types.size(); }
 
   void add_signature(const FunctionSig* sig, uint32_t supertype) {
-    types.push_back(TypeDefinition(sig));
-    type_kinds.push_back(kWasmFunctionTypeCode);
-    supertypes.push_back(supertype);
+    types.push_back(TypeDefinition(sig, supertype));
     uint32_t canonical_id = sig ? signature_map.FindOrInsert(*sig) : 0;
     canonicalized_type_ids.push_back(canonical_id);
   }
   bool has_signature(uint32_t index) const {
-    return index < types.size() && type_kinds[index] == kWasmFunctionTypeCode;
+    return index < types.size() &&
+           types[index].kind == TypeDefinition::kFunction;
   }
   const FunctionSig* signature(uint32_t index) const {
     DCHECK(has_signature(index));
@@ -437,14 +435,12 @@ struct V8_EXPORT_PRIVATE WasmModule {
   }
 
   void add_struct_type(const StructType* type, uint32_t supertype) {
-    types.push_back(TypeDefinition(type));
-    type_kinds.push_back(kWasmStructTypeCode);
-    supertypes.push_back(supertype);
+    types.push_back(TypeDefinition(type, supertype));
     // No canonicalization for structs.
     canonicalized_type_ids.push_back(0);
   }
   bool has_struct(uint32_t index) const {
-    return index < types.size() && type_kinds[index] == kWasmStructTypeCode;
+    return index < types.size() && types[index].kind == TypeDefinition::kStruct;
   }
   const StructType* struct_type(uint32_t index) const {
     DCHECK(has_struct(index));
@@ -452,14 +448,12 @@ struct V8_EXPORT_PRIVATE WasmModule {
   }
 
   void add_array_type(const ArrayType* type, uint32_t supertype) {
-    types.push_back(TypeDefinition(type));
-    type_kinds.push_back(kWasmArrayTypeCode);
-    supertypes.push_back(supertype);
+    types.push_back(TypeDefinition(type, supertype));
     // No canonicalization for arrays.
     canonicalized_type_ids.push_back(0);
   }
   bool has_array(uint32_t index) const {
-    return index < types.size() && type_kinds[index] == kWasmArrayTypeCode;
+    return index < types.size() && types[index].kind == TypeDefinition::kArray;
   }
   const ArrayType* array_type(uint32_t index) const {
     DCHECK(has_array(index));
@@ -467,14 +461,23 @@ struct V8_EXPORT_PRIVATE WasmModule {
   }
 
   uint32_t supertype(uint32_t index) const {
-    DCHECK(index < supertypes.size());
-    return supertypes[index];
+    DCHECK(index < types.size());
+    return types[index].supertype;
   }
   bool has_supertype(uint32_t index) const {
     return supertype(index) != kNoSuperType;
   }
 
+  std::vector<TypeDefinition> types;  // by type index
+  // Map from each type index to the index of its corresponding canonical index.
+  // Canonical indices do not correspond to types.
+  // Note: right now, only functions are canonicalized, and arrays and structs
+  // map to 0.
+  std::vector<uint32_t> canonicalized_type_ids;
+  // Canonicalizing map for signature indexes.
+  SignatureMap signature_map;
   std::vector<WasmFunction> functions;
+  std::vector<WasmGlobal> globals;
   std::vector<WasmDataSegment> data_segments;
   std::vector<WasmTable> tables;
   std::vector<WasmImport> import_table;
@@ -483,9 +486,6 @@ struct V8_EXPORT_PRIVATE WasmModule {
   std::vector<WasmElemSegment> elem_segments;
   std::vector<WasmCompilationHint> compilation_hints;
   BranchHintInfo branch_hints;
-  SignatureMap signature_map;  // canonicalizing map for signature indexes.
-  // Entries in this storage are short-lived: when tier-up of a function is
-  // scheduled, an entry is placed; the Turbofan graph builder consumes it.
   mutable TypeFeedbackStorage type_feedback;
 
   ModuleOrigin origin = kWasmOrigin;  // origin of the module

src/wasm/wasm-subtyping.cc

@@ -202,9 +202,9 @@ V8_INLINE bool EquivalentIndices(uint32_t index1, uint32_t index2,
                                  const WasmModule* module1,
                                  const WasmModule* module2) {
   DCHECK(index1 != index2 || module1 != module2);
-  uint8_t kind1 = module1->type_kinds[index1];
+  TypeDefinition::Kind kind1 = module1->types[index1].kind;
 
-  if (kind1 != module2->type_kinds[index2]) return false;
+  if (kind1 != module2->types[index2].kind) return false;
 
   base::RecursiveMutexGuard type_cache_access(
       TypeJudgementCache::instance()->type_cache_mutex());
@@ -213,12 +213,12 @@ V8_INLINE bool EquivalentIndices(uint32_t index1, uint32_t index2,
     return true;
   }
 
-  if (kind1 == kWasmStructTypeCode) {
+  if (kind1 == TypeDefinition::kStruct) {
     return StructEquivalentIndices(index1, index2, module1, module2);
-  } else if (kind1 == kWasmArrayTypeCode) {
+  } else if (kind1 == TypeDefinition::kArray) {
     return ArrayEquivalentIndices(index1, index2, module1, module2);
   } else {
-    DCHECK_EQ(kind1, kWasmFunctionTypeCode);
+    DCHECK_EQ(kind1, TypeDefinition::kFunction);
     return FunctionEquivalentIndices(index1, index2, module1, module2);
   }
 }
@@ -426,9 +426,9 @@ V8_NOINLINE V8_EXPORT_PRIVATE bool IsSubtypeOfImpl(
   // equality; here we catch (ref $x) being a subtype of (ref null $x).
   if (sub_module == super_module && sub_index == super_index) return true;
 
-  uint8_t sub_kind = sub_module->type_kinds[sub_index];
+  TypeDefinition::Kind sub_kind = sub_module->types[sub_index].kind;
 
-  if (sub_kind != super_module->type_kinds[super_index]) return false;
+  if (sub_kind != super_module->types[super_index].kind) return false;
 
   // Types with explicit supertypes just check those.
   if (sub_module->has_supertype(sub_index)) {
@@ -460,12 +460,13 @@ V8_NOINLINE V8_EXPORT_PRIVATE bool IsSubtypeOfImpl(
     return true;
   }
 
-  if (sub_kind == kWasmStructTypeCode) {
-    return StructIsSubtypeOf(sub_index, super_index, sub_module, super_module);
-  } else if (sub_kind == kWasmArrayTypeCode) {
+  switch (sub_kind) {
+    case TypeDefinition::kStruct:
+      return StructIsSubtypeOf(sub_index, super_index, sub_module,
+                               super_module);
+    case TypeDefinition::kArray:
       return ArrayIsSubtypeOf(sub_index, super_index, sub_module, super_module);
-  } else {
-    DCHECK_EQ(sub_kind, kWasmFunctionTypeCode);
+    case TypeDefinition::kFunction:
       return FunctionIsSubtypeOf(sub_index, super_index, sub_module,
                                  super_module);
   }

test/cctest/wasm/test-run-wasm-bulk-memory.cc

@@ -410,13 +410,11 @@ void TestTableInitElems(TestExecutionTier execution_tier, int table_index) {
     function_indexes.push_back(fn.function_index());
   }
 
-  // Passive element segment has [f0, f1, f2, f3, f4, null].
-  function_indexes.push_back(WasmModuleBuilder::kNullIndex);
-
   // Add 10 function tables, even though we only test one table.
   for (int i = 0; i < 10; ++i) {
     r.builder().AddIndirectFunctionTable(nullptr, kTableSize);
   }
+  // Passive element segment has [f0, f1, f2, f3, f4].
   r.builder().AddPassiveElementSegment(function_indexes);
 
   WasmFunctionCompiler& call = r.NewFunction(sigs.i_i(), "call");

test/fuzzer/wasm-compile.cc

@@ -622,7 +622,7 @@ class WasmGenerator {
     uint8_t random_byte = data->get<uint8_t>();
     int func_index = random_byte % functions_.size();
     uint32_t sig_index = functions_[func_index];
-    FunctionSig* sig = builder_->builder()->GetSignature(sig_index);
+    const FunctionSig* sig = builder_->builder()->GetSignature(sig_index);
     // Generate arguments.
     for (size_t i = 0; i < sig->parameter_count(); ++i) {
       Generate(sig->GetParam(i), data);
@@ -808,7 +808,8 @@ class WasmGenerator {
                              control_depth - catch_blocks_[catch_index]);
     } else {
       int tag = data->get<uint8_t>() % builder_->builder()->NumExceptions();
-      FunctionSig* exception_sig = builder_->builder()->GetExceptionType(tag);
+      const FunctionSig* exception_sig =
+          builder_->builder()->GetExceptionType(tag);
       base::Vector<const ValueType> exception_types(
           exception_sig->parameters().begin(),
           exception_sig->parameter_count());
@@ -853,7 +854,7 @@ class WasmGenerator {
     bool new_default = data->get<bool>();
 
     if (builder_->builder()->IsStructType(index)) {
-      StructType* struct_gen = builder_->builder()->GetStructType(index);
+      const StructType* struct_gen = builder_->builder()->GetStructType(index);
       int field_count = struct_gen->field_count();
       bool can_be_defaultable = false;
 
@@ -1143,7 +1144,7 @@ class WasmGenerator {
     if (num_structs_ > 0) {
       int struct_index = data->get<uint8_t>() % num_structs_;
       DCHECK(builder->IsStructType(struct_index));
-      StructType* struct_type = builder->GetStructType(struct_index);
+      const StructType* struct_type = builder->GetStructType(struct_index);
       ZoneVector<uint32_t> field_indices(builder->zone());
       for (uint32_t i = 0; i < struct_type->field_count(); i++) {
         if (struct_type->mutability(i)) {
@@ -1253,7 +1254,7 @@ class WasmGenerator {
         num_structs_(num_structs),
         num_arrays_(num_arrays),
         liftoff_as_reference_(liftoff_as_reference) {
-    FunctionSig* sig = fn->signature();
+    const FunctionSig* sig = fn->signature();
     blocks_.emplace_back();
     for (size_t i = 0; i < sig->return_count(); ++i) {
       blocks_.back().push_back(sig->GetReturn(i));
@@ -2508,7 +2509,7 @@ class WasmCompileFuzzer : public WasmExecutionFuzzer {
     // have typed-function tables.
     std::vector<WasmFunctionBuilder*> functions;
     for (int i = 0; i < num_functions; ++i) {
-      FunctionSig* sig = builder.GetSignature(function_signatures[i]);
+      const FunctionSig* sig = builder.GetSignature(function_signatures[i]);
       functions.push_back(builder.AddFunction(sig));
     }
 
@@ -2576,7 +2577,7 @@ class WasmCompileFuzzer : public WasmExecutionFuzzer {
       WasmGenerator gen(f, function_signatures, globals, mutable_globals,
                         num_structs, num_arrays, &function_range,
                         liftoff_as_reference);
-      FunctionSig* sig = f->signature();
+      const FunctionSig* sig = f->signature();
       base::Vector<const ValueType> return_types(sig->returns().begin(),
                                                  sig->return_count());
       gen.Generate(return_types, &function_range);

test/fuzzer/wasm-fuzzer-common.cc

@@ -623,13 +623,6 @@ void GenerateTestCase(Isolate* isolate, ModuleWireBytes wire_bytes,
     os << ");\n";
   }
 
-#if DEBUG
-  for (uint8_t kind : module->type_kinds) {
-    DCHECK(kWasmArrayTypeCode == kind || kWasmStructTypeCode == kind ||
-           kWasmFunctionTypeCode == kind);
-  }
-#endif
-
   for (int i = 0; i < static_cast<int>(module->types.size()); i++) {
     if (module->has_struct(i)) {
       const StructType* struct_type = module->types[i].struct_type;

test/unittests/wasm/function-body-decoder-unittest.cc

@@ -136,13 +136,13 @@ class TestModuleBuilder {
       type_builder.AddField(field.first, field.second);
     }
     mod.add_struct_type(type_builder.Build(), supertype);
-    return static_cast<byte>(mod.type_kinds.size() - 1);
+    return static_cast<byte>(mod.types.size() - 1);
   }
 
   byte AddArray(ValueType type, bool mutability) {
     ArrayType* array = mod.signature_zone->New<ArrayType>(type, mutability);
     mod.add_array_type(array, kNoSuperType);
-    return static_cast<byte>(mod.type_kinds.size() - 1);
+    return static_cast<byte>(mod.types.size() - 1);
   }
 
   void InitializeMemory(MemoryType mem_type = kMemory32) {

test/unittests/wasm/module-decoder-unittest.cc

@@ -1634,7 +1634,6 @@ TEST_F(WasmModuleVerifyTest, CanonicalTypeIds) {
   const WasmModule* module = result.value().get();
 
   EXPECT_EQ(5u, module->types.size());
-  EXPECT_EQ(5u, module->type_kinds.size());
   EXPECT_EQ(5u, module->canonicalized_type_ids.size());
   EXPECT_EQ(2u, module->signature_map.size());