[wasm-gc][cleanup] Remove wasm signature from CallDescriptor

This field is no longer used, as the functionality it supported has been
subsumed by wasm-gc typed-based optimizations.

Bug: v8:7748
Change-Id: I970514bb29e5f91bb5610cafde60ec3dbcfb07aa
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3705376
Commit-Queue: Manos Koukoutos <manoskouk@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Reviewed-by: Maya Lekova <mslekova@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81244}

src/compiler/linkage.cc

@@ -538,9 +538,6 @@ CallDescriptor* Linkage::GetStubCallDescriptor(
       CallDescriptor::kCanUseRoots | flags,  // flags
       descriptor.DebugName(),                // debug name
       descriptor.GetStackArgumentOrder(),    // stack order
-#if V8_ENABLE_WEBASSEMBLY
-      nullptr,  // wasm function signature
-#endif
       allocatable_registers);
 }
 

src/compiler/linkage.h

@@ -265,9 +265,6 @@ class V8_EXPORT_PRIVATE CallDescriptor final
                  DoubleRegList callee_saved_fp_registers, Flags flags,
                  const char* debug_name = "",
                  StackArgumentOrder stack_order = StackArgumentOrder::kDefault,
-#if V8_ENABLE_WEBASSEMBLY
-                 const wasm::FunctionSig* wasm_sig = nullptr,
-#endif
                  const RegList allocatable_registers = {},
                  size_t return_slot_count = 0)
       : kind_(kind),
@@ -282,11 +279,7 @@ class V8_EXPORT_PRIVATE CallDescriptor final
         allocatable_registers_(allocatable_registers),
         flags_(flags),
         stack_order_(stack_order),
-#if V8_ENABLE_WEBASSEMBLY
-        wasm_sig_(wasm_sig),
-#endif
-        debug_name_(debug_name) {
-  }
+        debug_name_(debug_name) {}
 
   CallDescriptor(const CallDescriptor&) = delete;
   CallDescriptor& operator=(const CallDescriptor&) = delete;
@@ -309,9 +302,6 @@ class V8_EXPORT_PRIVATE CallDescriptor final
 
   // Returns {true} if this descriptor is a call to a Wasm C API function.
   bool IsWasmCapiFunction() const { return kind_ == kCallWasmCapiFunction; }
-
-  // Returns the wasm signature for this call based on the real parameter types.
-  const wasm::FunctionSig* wasm_sig() const { return wasm_sig_; }
 #endif  // V8_ENABLE_WEBASSEMBLY
 
   bool RequiresFrameAsIncoming() const {
@@ -478,9 +468,6 @@ class V8_EXPORT_PRIVATE CallDescriptor final
   const RegList allocatable_registers_;
   const Flags flags_;
   const StackArgumentOrder stack_order_;
-#if V8_ENABLE_WEBASSEMBLY
-  const wasm::FunctionSig* wasm_sig_;
-#endif
   const char* const debug_name_;
 
   mutable base::Optional<size_t> gp_param_count_;

src/compiler/wasm-compiler.cc

@@ -2748,16 +2748,15 @@ Node* WasmGraphBuilder::BuildImportCall(const wasm::FunctionSig* sig,
   }
 }
 
-Node* WasmGraphBuilder::CallDirect(uint32_t index, wasm::FunctionSig* real_sig,
-                                   base::Vector<Node*> args,
+Node* WasmGraphBuilder::CallDirect(uint32_t index, base::Vector<Node*> args,
                                    base::Vector<Node*> rets,
                                    wasm::WasmCodePosition position) {
   DCHECK_NULL(args[0]);
+  const wasm::FunctionSig* sig = env_->module->functions[index].sig;
 
   if (env_ && index < env_->module->num_imported_functions) {
     // Call to an imported function.
-    return BuildImportCall(real_sig, args, rets, position, index,
-                           kCallContinues);
+    return BuildImportCall(sig, args, rets, position, index, kCallContinues);
   }
 
   // A direct call to a wasm function defined in this module.
@@ -2765,15 +2764,14 @@ Node* WasmGraphBuilder::CallDirect(uint32_t index, wasm::FunctionSig* real_sig,
   Address code = static_cast<Address>(index);
   args[0] = mcgraph()->RelocatableIntPtrConstant(code, RelocInfo::WASM_CALL);
 
-  return BuildWasmCall(real_sig, args, rets, position, nullptr);
+  return BuildWasmCall(sig, args, rets, position, nullptr);
 }
 
 Node* WasmGraphBuilder::CallIndirect(uint32_t table_index, uint32_t sig_index,
-                                     wasm::FunctionSig* sig,
                                      base::Vector<Node*> args,
                                      base::Vector<Node*> rets,
                                      wasm::WasmCodePosition position) {
-  return BuildIndirectCall(table_index, sig_index, sig, args, rets, position,
+  return BuildIndirectCall(table_index, sig_index, args, rets, position,
                            kCallContinues);
 }
 
@@ -2826,10 +2824,12 @@ void WasmGraphBuilder::LoadIndirectFunctionTable(uint32_t table_index,
       wasm::ObjectAccess::ToTagged(WasmIndirectFunctionTable::kRefsOffset));
 }
 
-Node* WasmGraphBuilder::BuildIndirectCall(
-    uint32_t table_index, uint32_t sig_index, wasm::FunctionSig* real_sig,
-    base::Vector<Node*> args, base::Vector<Node*> rets,
-    wasm::WasmCodePosition position, IsReturnCall continuation) {
+Node* WasmGraphBuilder::BuildIndirectCall(uint32_t table_index,
+                                          uint32_t sig_index,
+                                          base::Vector<Node*> args,
+                                          base::Vector<Node*> rets,
+                                          wasm::WasmCodePosition position,
+                                          IsReturnCall continuation) {
   DCHECK_NOT_NULL(args[0]);
   DCHECK_NOT_NULL(env_);
 
@@ -2841,6 +2841,8 @@ Node* WasmGraphBuilder::BuildIndirectCall(
   LoadIndirectFunctionTable(table_index, &ift_size, &ift_sig_ids, &ift_targets,
                             &ift_instances);
 
+  const wasm::FunctionSig* sig = env_->module->signature(sig_index);
+
   Node* key = args[0];
 
   // Bounds check against the table size.
@@ -2885,9 +2887,9 @@ Node* WasmGraphBuilder::BuildIndirectCall(
 
   switch (continuation) {
     case kCallContinues:
-      return BuildWasmCall(real_sig, args, rets, position, target_instance);
+      return BuildWasmCall(sig, args, rets, position, target_instance);
     case kReturnCall:
-      return BuildWasmReturnCall(real_sig, args, position, target_instance);
+      return BuildWasmReturnCall(sig, args, position, target_instance);
   }
 }
 
@@ -2923,7 +2925,7 @@ Node* WasmGraphBuilder::BuildLoadCallTargetFromExportedFunctionData(
 }
 
 // TODO(9495): Support CAPI function refs.
-Node* WasmGraphBuilder::BuildCallRef(const wasm::FunctionSig* real_sig,
+Node* WasmGraphBuilder::BuildCallRef(const wasm::FunctionSig* sig,
                                      base::Vector<Node*> args,
                                      base::Vector<Node*> rets,
                                      CheckForNull null_check,
@@ -2970,8 +2972,8 @@ Node* WasmGraphBuilder::BuildCallRef(const wasm::FunctionSig* real_sig,
   args[0] = end_label.PhiAt(0);
 
   Node* call = continuation == kCallContinues
-                   ? BuildWasmCall(real_sig, args, rets, position, ref_node)
-                   : BuildWasmReturnCall(real_sig, args, position, ref_node);
+                   ? BuildWasmCall(sig, args, rets, position, ref_node)
+                   : BuildWasmReturnCall(sig, args, position, ref_node);
   return call;
 }
 
@@ -2998,32 +3000,31 @@ void WasmGraphBuilder::CompareToInternalFunctionAtIndex(Node* func_ref,
                 success_control, failure_control, hint);
 }
 
-Node* WasmGraphBuilder::CallRef(const wasm::FunctionSig* real_sig,
+Node* WasmGraphBuilder::CallRef(const wasm::FunctionSig* sig,
                                 base::Vector<Node*> args,
                                 base::Vector<Node*> rets,
                                 WasmGraphBuilder::CheckForNull null_check,
                                 wasm::WasmCodePosition position) {
-  return BuildCallRef(real_sig, args, rets, null_check,
-                      IsReturnCall::kCallContinues, position);
+  return BuildCallRef(sig, args, rets, null_check, IsReturnCall::kCallContinues,
+                      position);
 }
 
-Node* WasmGraphBuilder::ReturnCallRef(const wasm::FunctionSig* real_sig,
+Node* WasmGraphBuilder::ReturnCallRef(const wasm::FunctionSig* sig,
                                       base::Vector<Node*> args,
                                       WasmGraphBuilder::CheckForNull null_check,
                                       wasm::WasmCodePosition position) {
-  return BuildCallRef(real_sig, args, {}, null_check, IsReturnCall::kReturnCall,
+  return BuildCallRef(sig, args, {}, null_check, IsReturnCall::kReturnCall,
                       position);
 }
 
-Node* WasmGraphBuilder::ReturnCall(uint32_t index,
-                                   const wasm::FunctionSig* real_sig,
-                                   base::Vector<Node*> args,
+Node* WasmGraphBuilder::ReturnCall(uint32_t index, base::Vector<Node*> args,
                                    wasm::WasmCodePosition position) {
   DCHECK_NULL(args[0]);
+  const wasm::FunctionSig* sig = env_->module->functions[index].sig;
 
   if (env_ && index < env_->module->num_imported_functions) {
     // Return Call to an imported function.
-    return BuildImportCall(real_sig, args, {}, position, index, kReturnCall);
+    return BuildImportCall(sig, args, {}, position, index, kReturnCall);
   }
 
   // A direct tail call to a wasm function defined in this module.
@@ -3032,15 +3033,14 @@ Node* WasmGraphBuilder::ReturnCall(uint32_t index,
   Address code = static_cast<Address>(index);
   args[0] = mcgraph()->RelocatableIntPtrConstant(code, RelocInfo::WASM_CALL);
 
-  return BuildWasmReturnCall(real_sig, args, position, nullptr);
+  return BuildWasmReturnCall(sig, args, position, nullptr);
 }
 
 Node* WasmGraphBuilder::ReturnCallIndirect(uint32_t table_index,
                                            uint32_t sig_index,
-                                           wasm::FunctionSig* real_sig,
                                            base::Vector<Node*> args,
                                            wasm::WasmCodePosition position) {
-  return BuildIndirectCall(table_index, sig_index, real_sig, args, {}, position,
+  return BuildIndirectCall(table_index, sig_index, args, {}, position,
                            kReturnCall);
 }
 
@@ -8352,12 +8352,25 @@ class LinkageLocationAllocator {
   int slot_offset_;
 };
 
-LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
+const MachineSignature* FunctionSigToMachineSig(Zone* zone,
+                                                const wasm::FunctionSig* fsig) {
+  MachineSignature::Builder builder(zone, fsig->return_count(),
+                                    fsig->parameter_count());
+  for (wasm::ValueType ret : fsig->returns()) {
+    builder.AddReturn(ret.machine_type());
+  }
+  for (wasm::ValueType param : fsig->parameters()) {
+    builder.AddParam(param.machine_type());
+  }
+  return builder.Build();
+}
+
+LocationSignature* BuildLocations(Zone* zone, const MachineSignature* sig,
                                   bool extra_callable_param,
                                   int* parameter_slots, int* return_slots) {
   int extra_params = extra_callable_param ? 2 : 1;
-  LocationSignature::Builder locations(zone, fsig->return_count(),
-                                       fsig->parameter_count() + extra_params);
+  LocationSignature::Builder locations(zone, sig->return_count(),
+                                       sig->parameter_count() + extra_params);
 
   // Add register and/or stack parameter(s).
   LinkageLocationAllocator params(
@@ -8370,9 +8383,9 @@ LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
   // Parameters are separated into two groups (first all untagged, then all
   // tagged parameters). This allows for easy iteration of tagged parameters
   // during frame iteration.
-  const size_t parameter_count = fsig->parameter_count();
+  const size_t parameter_count = sig->parameter_count();
   for (size_t i = 0; i < parameter_count; i++) {
-    MachineRepresentation param = fsig->GetParam(i).machine_representation();
+    MachineRepresentation param = sig->GetParam(i).representation();
     // Skip tagged parameters (e.g. any-ref).
     if (IsAnyTagged(param)) continue;
     auto l = params.Next(param);
@@ -8383,7 +8396,7 @@ LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
   params.EndSlotArea();
 
   for (size_t i = 0; i < parameter_count; i++) {
-    MachineRepresentation param = fsig->GetParam(i).machine_representation();
+    MachineRepresentation param = sig->GetParam(i).representation();
     // Skip untagged parameters.
     if (!IsAnyTagged(param)) continue;
     auto l = params.Next(param);
@@ -8405,7 +8418,7 @@ LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
 
   const size_t return_count = locations.return_count_;
   for (size_t i = 0; i < return_count; i++) {
-    MachineRepresentation ret = fsig->GetReturn(i).machine_representation();
+    MachineRepresentation ret = sig->GetReturn(i).representation();
     locations.AddReturn(rets.Next(ret));
   }
 
@@ -8413,6 +8426,13 @@ LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
 
   return locations.Build();
 }
+
+LocationSignature* BuildLocations(Zone* zone, const wasm::FunctionSig* fsig,
+                                  bool extra_callable_param,
+                                  int* parameter_slots, int* return_slots) {
+  return BuildLocations(zone, FunctionSigToMachineSig(zone, fsig),
+                        extra_callable_param, parameter_slots, return_slots);
+}
 }  // namespace
 
 // General code uses the above configuration data.
@@ -8461,70 +8481,15 @@ CallDescriptor* GetWasmCallDescriptor(Zone* zone, const wasm::FunctionSig* fsig,
       flags,                              // flags
       "wasm-call",                        // debug name
       StackArgumentOrder::kDefault,       // order of the arguments in the stack
-      fsig,                               // signature
       RegList{},                          // allocatable registers
       return_slots);                      // return slot count
 }
 
 namespace {
-const wasm::FunctionSig* ReplaceTypeInSig(Zone* zone,
-                                          const wasm::FunctionSig* sig,
-                                          wasm::ValueType from,
-                                          wasm::ValueType to,
-                                          size_t num_replacements) {
-  size_t param_occurences =
-      std::count(sig->parameters().begin(), sig->parameters().end(), from);
-  size_t return_occurences =
-      std::count(sig->returns().begin(), sig->returns().end(), from);
-  if (param_occurences == 0 && return_occurences == 0) return sig;
-
-  wasm::FunctionSig::Builder builder(
-      zone, sig->return_count() + return_occurences * (num_replacements - 1),
-      sig->parameter_count() + param_occurences * (num_replacements - 1));
-
-  for (wasm::ValueType ret : sig->returns()) {
-    if (ret == from) {
-      for (size_t i = 0; i < num_replacements; i++) builder.AddReturn(to);
-    } else {
-      builder.AddReturn(ret);
-    }
-  }
-
-  for (wasm::ValueType param : sig->parameters()) {
-    if (param == from) {
-      for (size_t i = 0; i < num_replacements; i++) builder.AddParam(to);
-    } else {
-      builder.AddParam(param);
-    }
-  }
-
-  return builder.Build();
-}
 
 CallDescriptor* ReplaceTypeInCallDescriptorWith(
     Zone* zone, const CallDescriptor* call_descriptor, size_t num_replacements,
-    wasm::ValueType input_type, wasm::ValueType output_type) {
-  if (call_descriptor->wasm_sig() == nullptr) {
-    // This happens for builtins calls. They need no replacements anyway.
-#if DEBUG
-    for (size_t i = 0; i < call_descriptor->ParameterCount(); i++) {
-      DCHECK_NE(call_descriptor->GetParameterType(i),
-                input_type.machine_type());
-    }
-    for (size_t i = 0; i < call_descriptor->ReturnCount(); i++) {
-      DCHECK_NE(call_descriptor->GetReturnType(i), input_type.machine_type());
-    }
-#endif
-    return const_cast<CallDescriptor*>(call_descriptor);
-  }
-  const wasm::FunctionSig* sig =
-      ReplaceTypeInSig(zone, call_descriptor->wasm_sig(), input_type,
-                       output_type, num_replacements);
-  // If {ReplaceTypeInSig} took the early fast path, there's nothing to do.
-  if (sig == call_descriptor->wasm_sig()) {
-    return const_cast<CallDescriptor*>(call_descriptor);
-  }
-
+    MachineType from, MachineType to) {
   // The last parameter may be the special callable parameter. In that case we
   // have to preserve it as the last parameter, i.e. we allocate it in the new
   // location signature again in the same register.
@@ -8533,10 +8498,49 @@ CallDescriptor* ReplaceTypeInCallDescriptorWith(
        LinkageLocation::ForRegister(kJSFunctionRegister.code(),
                                     MachineType::TaggedPointer()));
 
+  size_t return_count = call_descriptor->ReturnCount();
+  // To recover the function parameter count, disregard the instance parameter,
+  // and the extra callable parameter if present.
+  size_t parameter_count =
+      call_descriptor->ParameterCount() - (extra_callable_param ? 2 : 1);
+
+  std::vector<MachineType> reps;
+
+  bool changed = false;
+  for (int i = 0; i < static_cast<int>(call_descriptor->ReturnCount()); i++) {
+    MachineType initial_type = call_descriptor->GetReturnType(i);
+    if (initial_type == from) {
+      for (size_t j = 0; j < num_replacements; j++) reps.push_back(to);
+      return_count += num_replacements - 1;
+      changed = true;
+    } else {
+      reps.push_back(initial_type);
+    }
+  }
+
+  // Disregard the instance (first) parameter, and the extra callable (last)
+  // parameter if present.
+  for (int i = 1; i < static_cast<int>(call_descriptor->ParameterCount()) -
+                          (extra_callable_param ? 1 : 0);
+       i++) {
+    MachineType initial_type = call_descriptor->GetParameterType(i);
+    if (initial_type == from) {
+      for (size_t j = 0; j < num_replacements; j++) reps.push_back(to);
+      parameter_count += num_replacements - 1;
+      changed = true;
+    } else {
+      reps.push_back(initial_type);
+    }
+  }
+
+  if (!changed) return const_cast<CallDescriptor*>(call_descriptor);
+
+  MachineSignature sig(return_count, parameter_count, reps.data());
+
   int parameter_slots;
   int return_slots;
   LocationSignature* location_sig = BuildLocations(
-      zone, sig, extra_callable_param, &parameter_slots, &return_slots);
+      zone, &sig, extra_callable_param, &parameter_slots, &return_slots);
 
   return zone->New<CallDescriptor>(               // --
       call_descriptor->kind(),                    // kind
@@ -8550,20 +8554,11 @@ CallDescriptor* ReplaceTypeInCallDescriptorWith(
       call_descriptor->flags(),                   // flags
       call_descriptor->debug_name(),              // debug name
       call_descriptor->GetStackArgumentOrder(),   // stack order
-      sig,                                        // signature
       call_descriptor->AllocatableRegisters(),    // allocatable registers
       return_slots);                              // return slot count
 }
 }  // namespace
 
-// static
-const wasm::FunctionSig* WasmGraphBuilder::Int64LoweredSig(
-    Zone* zone, const wasm::FunctionSig* sig) {
-  return (kSystemPointerSize == 4)
-             ? ReplaceTypeInSig(zone, sig, wasm::kWasmI64, wasm::kWasmI32, 2)
-             : sig;
-}
-
 void WasmGraphBuilder::StoreCallCount(Node* call, int count) {
   mcgraph()->StoreCallCount(call->id(), count);
 }
@@ -8574,8 +8569,8 @@ void WasmGraphBuilder::ReserveCallCounts(size_t num_call_instructions) {
 
 CallDescriptor* GetI32WasmCallDescriptor(
     Zone* zone, const CallDescriptor* call_descriptor) {
-  return ReplaceTypeInCallDescriptorWith(zone, call_descriptor, 2,
-                                         wasm::kWasmI64, wasm::kWasmI32);
+  return ReplaceTypeInCallDescriptorWith(
+      zone, call_descriptor, 2, MachineType::Int64(), MachineType::Int32());
 }
 
 AssemblerOptions WasmAssemblerOptions() {

src/compiler/wasm-compiler.h

@@ -343,25 +343,22 @@ class WasmGraphBuilder {
   // In all six call-related public functions, we pass a signature based on the
   // real arguments for this call. This signature gets stored in the Call node
   // and will later help us generate better code if this call gets inlined.
-  Node* CallDirect(uint32_t index, wasm::FunctionSig* real_sig,
-                   base::Vector<Node*> args, base::Vector<Node*> rets,
-                   wasm::WasmCodePosition position);
+  Node* CallDirect(uint32_t index, base::Vector<Node*> args,
+                   base::Vector<Node*> rets, wasm::WasmCodePosition position);
   Node* CallIndirect(uint32_t table_index, uint32_t sig_index,
-                     wasm::FunctionSig* real_sig, base::Vector<Node*> args,
-                     base::Vector<Node*> rets, wasm::WasmCodePosition position);
-  Node* CallRef(const wasm::FunctionSig* real_sig, base::Vector<Node*> args,
+                     base::Vector<Node*> args, base::Vector<Node*> rets,
+                     wasm::WasmCodePosition position);
+  Node* CallRef(const wasm::FunctionSig* sig, base::Vector<Node*> args,
                 base::Vector<Node*> rets, CheckForNull null_check,
                 wasm::WasmCodePosition position);
 
-  Node* ReturnCall(uint32_t index, const wasm::FunctionSig* real_sig,
-                   base::Vector<Node*> args, wasm::WasmCodePosition position);
+  Node* ReturnCall(uint32_t index, base::Vector<Node*> args,
+                   wasm::WasmCodePosition position);
   Node* ReturnCallIndirect(uint32_t table_index, uint32_t sig_index,
-                           wasm::FunctionSig* real_sig,
                            base::Vector<Node*> args,
                            wasm::WasmCodePosition position);
-  Node* ReturnCallRef(const wasm::FunctionSig* real_sig,
-                      base::Vector<Node*> args, CheckForNull null_check,
-                      wasm::WasmCodePosition position);
+  Node* ReturnCallRef(const wasm::FunctionSig* sig, base::Vector<Node*> args,
+                      CheckForNull null_check, wasm::WasmCodePosition position);
 
   void CompareToInternalFunctionAtIndex(Node* func_ref, uint32_t function_index,
                                         Node** success_control,
@@ -589,9 +586,6 @@ class WasmGraphBuilder {
 
   void RemoveBytecodePositionDecorator();
 
-  static const wasm::FunctionSig* Int64LoweredSig(Zone* zone,
-                                                  const wasm::FunctionSig* sig);
-
   void StoreCallCount(Node* call, int count);
   void ReserveCallCounts(size_t num_call_instructions);
 
@@ -647,8 +641,7 @@ class WasmGraphBuilder {
                                  Node** ift_sig_ids, Node** ift_targets,
                                  Node** ift_instances);
   Node* BuildIndirectCall(uint32_t table_index, uint32_t sig_index,
-                          wasm::FunctionSig* real_sig, base::Vector<Node*> args,
-                          base::Vector<Node*> rets,
+                          base::Vector<Node*> args, base::Vector<Node*> rets,
                           wasm::WasmCodePosition position,
                           IsReturnCall continuation);
   Node* BuildWasmCall(const wasm::FunctionSig* sig, base::Vector<Node*> args,
@@ -666,9 +659,9 @@ class WasmGraphBuilder {
                         base::Vector<Node*> rets,
                         wasm::WasmCodePosition position, Node* func_index,
                         IsReturnCall continuation);
-  Node* BuildCallRef(const wasm::FunctionSig* real_sig,
-                     base::Vector<Node*> args, base::Vector<Node*> rets,
-                     CheckForNull null_check, IsReturnCall continuation,
+  Node* BuildCallRef(const wasm::FunctionSig* sig, base::Vector<Node*> args,
+                     base::Vector<Node*> rets, CheckForNull null_check,
+                     IsReturnCall continuation,
                      wasm::WasmCodePosition position);
 
   Node* BuildF32CopySign(Node* left, Node* right);

src/wasm/graph-builder-interface.cc

@@ -1903,18 +1903,6 @@ class WasmGraphBuildingInterface {
               const Value args[], Value returns[]) {
     size_t param_count = sig->parameter_count();
     size_t return_count = sig->return_count();
-
-    // Construct a function signature based on the real function parameters.
-    FunctionSig::Builder real_sig_builder(builder_->graph_zone(), return_count,
-                                          param_count);
-    for (size_t i = 0; i < param_count; i++) {
-      real_sig_builder.AddParam(args[i].type);
-    }
-    for (size_t i = 0; i < return_count; i++) {
-      real_sig_builder.AddReturn(sig->GetReturn(i));
-    }
-    FunctionSig* real_sig = real_sig_builder.Build();
-
     NodeVector arg_nodes(param_count + 1);
     base::SmallVector<TFNode*, 1> return_nodes(return_count);
     arg_nodes[0] = (call_info.call_mode() == CallInfo::kCallDirect)
@@ -1929,12 +1917,12 @@ class WasmGraphBuildingInterface {
         CheckForException(
             decoder, builder_->CallIndirect(
                          call_info.table_index(), call_info.sig_index(),
-                         real_sig, base::VectorOf(arg_nodes),
+                         base::VectorOf(arg_nodes),
                          base::VectorOf(return_nodes), decoder->position()));
         break;
       case CallInfo::kCallDirect: {
         TFNode* call = builder_->CallDirect(
-            call_info.callee_index(), real_sig, base::VectorOf(arg_nodes),
+            call_info.callee_index(), base::VectorOf(arg_nodes),
             base::VectorOf(return_nodes), decoder->position());
         builder_->StoreCallCount(call, call_info.call_count());
         CheckForException(decoder, call);
@@ -1943,7 +1931,7 @@ class WasmGraphBuildingInterface {
       case CallInfo::kCallRef:
         CheckForException(
             decoder,
-            builder_->CallRef(real_sig, base::VectorOf(arg_nodes),
+            builder_->CallRef(sig, base::VectorOf(arg_nodes),
                               base::VectorOf(return_nodes),
                               call_info.null_check(), decoder->position()));
         break;
@@ -1962,17 +1950,6 @@ class WasmGraphBuildingInterface {
                     const FunctionSig* sig, const Value args[]) {
     size_t arg_count = sig->parameter_count();
 
-    // Construct a function signature based on the real function parameters.
-    FunctionSig::Builder real_sig_builder(builder_->graph_zone(),
-                                          sig->return_count(), arg_count);
-    for (size_t i = 0; i < arg_count; i++) {
-      real_sig_builder.AddParam(args[i].type);
-    }
-    for (size_t i = 0; i < sig->return_count(); i++) {
-      real_sig_builder.AddReturn(sig->GetReturn(i));
-    }
-    FunctionSig* real_sig = real_sig_builder.Build();
-
     ValueVector arg_values(arg_count + 1);
     if (call_info.call_mode() == CallInfo::kCallDirect) {
       arg_values[0].node = nullptr;
@@ -1996,18 +1973,18 @@ class WasmGraphBuildingInterface {
     switch (call_info.call_mode()) {
       case CallInfo::kCallIndirect:
         builder_->ReturnCallIndirect(
-            call_info.table_index(), call_info.sig_index(), real_sig,
+            call_info.table_index(), call_info.sig_index(),
             base::VectorOf(arg_nodes), decoder->position());
         break;
       case CallInfo::kCallDirect: {
-        TFNode* call = builder_->ReturnCall(call_info.callee_index(), real_sig,
+        TFNode* call = builder_->ReturnCall(call_info.callee_index(),
                                             base::VectorOf(arg_nodes),
                                             decoder->position());
         builder_->StoreCallCount(call, call_info.call_count());
         break;
       }
       case CallInfo::kCallRef:
-        builder_->ReturnCallRef(real_sig, base::VectorOf(arg_nodes),
+        builder_->ReturnCallRef(sig, base::VectorOf(arg_nodes),
                                 call_info.null_check(), decoder->position());
         break;
     }

test/unittests/compiler/linkage-tail-call-unittest.cc

@@ -42,15 +42,12 @@ class LinkageTailCall : public TestWithZone {
         LinkageLocation::ForAnyRegister(MachineType::Pointer()),
         locations,  // location_sig
         stack_arguments,
-        Operator::kNoProperties,   // properties
-        kNoCalleeSaved,            // callee-saved
-        kNoCalleeSavedFp,          // callee-saved fp
-        CallDescriptor::kNoFlags,  // flags,
-        "", StackArgumentOrder::kDefault,
-#if V8_ENABLE_WEBASSEMBLY
-        nullptr,  // wasm function sig
-#endif
-        RegList{},  // allocatable_registers
+        Operator::kNoProperties,           // properties
+        kNoCalleeSaved,                    // callee-saved
+        kNoCalleeSavedFp,                  // callee-saved fp
+        CallDescriptor::kNoFlags,          // flags,
+        "", StackArgumentOrder::kDefault,  // --
+        RegList{},                         // allocatable_registers
         stack_returns);
   }