1 files changed, 60 insertions, 12 deletions

diff --git a/deps/v8/src/wasm/wasm-module-builder.cc b/deps/v8/src/wasm/wasm-module-builder.cc
index 0e485bd09b..ec838f4b12 100644
--- a/deps/v8/src/wasm/wasm-module-builder.cc
+++ b/deps/v8/src/wasm/wasm-module-builder.cc
@@ -57,7 +57,7 @@ void WasmFunctionBuilder::EmitU32V(uint32_t val) { body_.write_u32v(val); }
 void WasmFunctionBuilder::SetSignature(const FunctionSig* sig) {
   DCHECK(!locals_.has_sig());
   locals_.set_sig(sig);
-  signature_index_ = builder_->AddSignature(sig);
+  signature_index_ = builder_->AddSignature(sig, true);
 }
 
 void WasmFunctionBuilder::SetSignature(uint32_t sig_index) {
@@ -305,38 +305,40 @@ void WasmModuleBuilder::AddDataSegment(const byte* data, uint32_t size,
 }
 
 uint32_t WasmModuleBuilder::ForceAddSignature(const FunctionSig* sig,
+                                              bool is_final,
                                               uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
   signature_map_.emplace(*sig, index);
-  types_.emplace_back(sig, supertype);
+  types_.emplace_back(sig, supertype, is_final);
   return index;
 }
 
-uint32_t WasmModuleBuilder::AddSignature(const FunctionSig* sig,
+uint32_t WasmModuleBuilder::AddSignature(const FunctionSig* sig, bool is_final,
                                          uint32_t supertype) {
   auto sig_entry = signature_map_.find(*sig);
   if (sig_entry != signature_map_.end()) return sig_entry->second;
-  return ForceAddSignature(sig, supertype);
+  return ForceAddSignature(sig, is_final, supertype);
 }
 
 uint32_t WasmModuleBuilder::AddException(const FunctionSig* type) {
   DCHECK_EQ(0, type->return_count());
-  int type_index = AddSignature(type);
+  int type_index = AddSignature(type, true);
   uint32_t except_index = static_cast<uint32_t>(exceptions_.size());
   exceptions_.push_back(type_index);
   return except_index;
 }
 
-uint32_t WasmModuleBuilder::AddStructType(StructType* type,
+uint32_t WasmModuleBuilder::AddStructType(StructType* type, bool is_final,
                                           uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
-  types_.emplace_back(type, supertype);
+  types_.emplace_back(type, supertype, is_final);
   return index;
 }
 
-uint32_t WasmModuleBuilder::AddArrayType(ArrayType* type, uint32_t supertype) {
+uint32_t WasmModuleBuilder::AddArrayType(ArrayType* type, bool is_final,
+                                         uint32_t supertype) {
   uint32_t index = static_cast<uint32_t>(types_.size());
-  types_.emplace_back(type, supertype);
+  types_.emplace_back(type, supertype, is_final);
   return index;
 }
 
@@ -390,7 +392,7 @@ uint32_t WasmModuleBuilder::AddImport(base::Vector<const char> name,
                                       FunctionSig* sig,
                                       base::Vector<const char> module) {
   DCHECK(adding_imports_allowed_);
-  function_imports_.push_back({module, name, AddSignature(sig)});
+  function_imports_.push_back({module, name, AddSignature(sig, true)});
   return static_cast<uint32_t>(function_imports_.size() - 1);
 }
 
@@ -473,6 +475,48 @@ void WriteInitializerExpressionWithEnd(ZoneBuffer* buffer,
       buffer->write_u8(kExprS128Const & 0xFF);
       buffer->write(init.immediate().s128_const.data(), kSimd128Size);
       break;
+    case WasmInitExpr::kI32Add:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI32);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI32);
+      buffer->write_u8(kExprI32Add);
+      break;
+    case WasmInitExpr::kI32Sub:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI32);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI32);
+      buffer->write_u8(kExprI32Sub);
+      break;
+    case WasmInitExpr::kI32Mul:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI32);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI32);
+      buffer->write_u8(kExprI32Mul);
+      break;
+    case WasmInitExpr::kI64Add:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI64);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI64);
+      buffer->write_u8(kExprI64Add);
+      break;
+    case WasmInitExpr::kI64Sub:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI64);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI64);
+      buffer->write_u8(kExprI64Sub);
+      break;
+    case WasmInitExpr::kI64Mul:
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[0],
+                                        kWasmI64);
+      WriteInitializerExpressionWithEnd(buffer, (*init.operands())[1],
+                                        kWasmI64);
+      buffer->write_u8(kExprI64Mul);
+      break;
     case WasmInitExpr::kGlobalGet:
       buffer->write_u8(kExprGlobalGet);
       buffer->write_u32v(init.immediate().index);
@@ -613,9 +657,13 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
       const TypeDefinition& type = types_[i];
 
       if (type.supertype != kNoSuperType) {
-        buffer->write_u8(kWasmSubtypeCode);
-        buffer->write_u8(1);  // The supertype count is always 1.
+        buffer->write_u8(type.is_final ? kWasmSubtypeFinalCode
+                                       : kWasmSubtypeCode);
+        buffer->write_u8(1);
         buffer->write_u32v(type.supertype);
+      } else if (!type.is_final) {
+        buffer->write_u8(kWasmSubtypeCode);
+        buffer->write_u8(0);
       }
       switch (type.kind) {
         case TypeDefinition::kFunction: {