[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.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);
   }