[csa] Typify [Tail]CallRuntime and [Tail]CallStub.

This CL also introduces TailCallRuntime() with explicit arity
parameter.

Bug: v8:6949
Change-Id: I20266a0d3779e0336d5e9f83d3919ffc91fe0f47
Reviewed-on: https://chromium-review.googlesource.com/1097081
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53679}

src/builtins/builtins-wasm-gen.cc

@@ -15,7 +15,7 @@ typedef compiler::Node Node;
 TF_BUILTIN(WasmStackGuard, CodeStubAssembler) {
   TNode<Object> instance = UncheckedCast<Object>(
       LoadFromParentFrame(WasmCompiledFrameConstants::kWasmInstanceOffset));
-  TNode<Object> centry = UncheckedCast<Object>(Load(
+  TNode<Code> centry = UncheckedCast<Code>(Load(
       MachineType::AnyTagged(), instance,
       IntPtrConstant(WasmInstanceObject::kCEntryStubOffset - kHeapObjectTag)));
   TailCallRuntimeWithCEntry(Runtime::kWasmStackGuard, centry,
@@ -26,7 +26,7 @@ TF_BUILTIN(WasmStackGuard, CodeStubAssembler) {
   TF_BUILTIN(ThrowWasm##name, CodeStubAssembler) {                             \
     TNode<Object> instance = UncheckedCast<Object>(                            \
         LoadFromParentFrame(WasmCompiledFrameConstants::kWasmInstanceOffset)); \
-    TNode<Object> centry = UncheckedCast<Object>(                              \
+    TNode<Code> centry = UncheckedCast<Code>(                                  \
         Load(MachineType::AnyTagged(), instance,                               \
              IntPtrConstant(WasmInstanceObject::kCEntryStubOffset -            \
                             kHeapObjectTag)));                                 \

src/code-stub-assembler.h

@@ -2158,9 +2158,8 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
   TNode<Object> GetProperty(SloppyTNode<Context> context,
                             SloppyTNode<Object> receiver,
                             SloppyTNode<Object> name) {
-    return UncheckedCast<Object>(
-        CallStub(Builtins::CallableFor(isolate(), Builtins::kGetProperty),
-                 context, receiver, name));
+    return CallStub(Builtins::CallableFor(isolate(), Builtins::kGetProperty),
+                    context, receiver, name);
   }
 
   Node* GetMethod(Node* context, Node* object, Handle<Name> name,
@@ -2171,17 +2170,16 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
                             TArgs... args) {
     DCHECK_IMPLIES(Builtins::KindOf(id) == Builtins::TFJ,
                    !Builtins::IsLazy(id));
-    return UncheckedCast<Object>(
-        CallStub(Builtins::CallableFor(isolate(), id), context, args...));
+    return CallStub<Object>(Builtins::CallableFor(isolate(), id), context,
+                            args...);
   }
 
   template <class... TArgs>
-  TNode<Object> TailCallBuiltin(Builtins::Name id, SloppyTNode<Object> context,
+  void TailCallBuiltin(Builtins::Name id, SloppyTNode<Object> context,
                        TArgs... args) {
     DCHECK_IMPLIES(Builtins::KindOf(id) == Builtins::TFJ,
                    !Builtins::IsLazy(id));
-    return UncheckedCast<Object>(
-        TailCallStub(Builtins::CallableFor(isolate(), id), context, args...));
+    return TailCallStub(Builtins::CallableFor(isolate(), id), context, args...);
   }
 
   void LoadPropertyFromFastObject(Node* object, Node* map,

src/compiler/code-assembler.cc

@@ -24,19 +24,22 @@
 #include "src/utils.h"
 #include "src/zone/zone.h"
 
-#define REPEAT_1_TO_2(V, T) V(T) V(T, T)
-#define REPEAT_1_TO_3(V, T) REPEAT_1_TO_2(V, T) V(T, T, T)
-#define REPEAT_1_TO_4(V, T) REPEAT_1_TO_3(V, T) V(T, T, T, T)
-#define REPEAT_1_TO_5(V, T) REPEAT_1_TO_4(V, T) V(T, T, T, T, T)
-#define REPEAT_1_TO_6(V, T) REPEAT_1_TO_5(V, T) V(T, T, T, T, T, T)
-#define REPEAT_1_TO_7(V, T) REPEAT_1_TO_6(V, T) V(T, T, T, T, T, T, T)
-#define REPEAT_1_TO_8(V, T) REPEAT_1_TO_7(V, T) V(T, T, T, T, T, T, T, T)
-#define REPEAT_1_TO_9(V, T) REPEAT_1_TO_8(V, T) V(T, T, T, T, T, T, T, T, T)
-#define REPEAT_1_TO_10(V, T) REPEAT_1_TO_9(V, T) V(T, T, T, T, T, T, T, T, T, T)
-#define REPEAT_1_TO_11(V, T) \
-  REPEAT_1_TO_10(V, T) V(T, T, T, T, T, T, T, T, T, T, T)
-#define REPEAT_1_TO_12(V, T) \
-  REPEAT_1_TO_11(V, T) V(T, T, T, T, T, T, T, T, T, T, T, T)
+#define REPEAT_0_TO_1(V, T0, T) V(T0) V(T0, T)
+#define REPEAT_0_TO_2(V, T0, T) REPEAT_0_TO_1(V, T0, T) V(T0, T, T)
+#define REPEAT_0_TO_3(V, T0, T) REPEAT_0_TO_2(V, T0, T) V(T0, T, T, T)
+#define REPEAT_0_TO_4(V, T0, T) REPEAT_0_TO_3(V, T0, T) V(T0, T, T, T, T)
+#define REPEAT_0_TO_5(V, T0, T) REPEAT_0_TO_4(V, T0, T) V(T0, T, T, T, T, T)
+#define REPEAT_0_TO_6(V, T0, T) REPEAT_0_TO_5(V, T0, T) V(T0, T, T, T, T, T, T)
+#define REPEAT_0_TO_7(V, T0, T) \
+  REPEAT_0_TO_6(V, T0, T) V(T0, T, T, T, T, T, T, T)
+#define REPEAT_0_TO_8(V, T0, T) \
+  REPEAT_0_TO_7(V, T0, T) V(T0, T, T, T, T, T, T, T, T)
+#define REPEAT_0_TO_9(V, T0, T) \
+  REPEAT_0_TO_8(V, T0, T) V(T0, T, T, T, T, T, T, T, T, T)
+#define REPEAT_0_TO_10(V, T0, T) \
+  REPEAT_0_TO_9(V, T0, T) V(T0, T, T, T, T, T, T, T, T, T, T)
+#define REPEAT_0_TO_11(V, T0, T) \
+  REPEAT_0_TO_10(V, T0, T) V(T0, T, T, T, T, T, T, T, T, T, T, T)
 
 namespace v8 {
 namespace internal {
@@ -1051,7 +1054,7 @@ void CodeAssembler::GotoIfException(Node* node, Label* if_exception,
 
 template <class... TArgs>
 TNode<Object> CodeAssembler::CallRuntimeImpl(Runtime::FunctionId function,
-                                             SloppyTNode<Object> context,
+                                             TNode<Object> context,
                                              TArgs... args) {
   int argc = static_cast<int>(sizeof...(args));
   auto call_descriptor = Linkage::GetRuntimeCallDescriptor(
@@ -1064,7 +1067,8 @@ TNode<Object> CodeAssembler::CallRuntimeImpl(Runtime::FunctionId function,
   Node* ref = ExternalConstant(ExternalReference::Create(function));
   Node* arity = Int32Constant(argc);
 
-  Node* nodes[] = {centry, args..., ref, arity, context};
+  Node* nodes[] = {centry, implicit_cast<TNode<Object>>(args)..., ref, arity,
+                   context};
 
   CallPrologue();
   Node* return_value =
@@ -1077,29 +1081,32 @@ TNode<Object> CodeAssembler::CallRuntimeImpl(Runtime::FunctionId function,
 #define INSTANTIATE(...)                                                   \
   template V8_EXPORT_PRIVATE TNode<Object> CodeAssembler::CallRuntimeImpl( \
       Runtime::FunctionId, __VA_ARGS__);
-REPEAT_1_TO_7(INSTANTIATE, SloppyTNode<Object>)
+REPEAT_0_TO_6(INSTANTIATE, TNode<Object>, SloppyTNode<Object>)
 #undef INSTANTIATE
 
 template <class... TArgs>
-TNode<Object> CodeAssembler::TailCallRuntimeImpl(Runtime::FunctionId function,
-                                                 SloppyTNode<Object> context,
-                                                 TArgs... args) {
+void CodeAssembler::TailCallRuntimeImpl(Runtime::FunctionId function,
+                                        TNode<Int32T> arity,
+                                        TNode<Object> context, TArgs... args) {
   int result_size = Runtime::FunctionForId(function)->result_size;
-  TNode<Object> centry =
+  TNode<Code> centry =
       HeapConstant(CodeFactory::RuntimeCEntry(isolate(), result_size));
-  return TailCallRuntimeWithCEntryImpl(function, centry, context, args...);
+  return TailCallRuntimeWithCEntryImpl(function, arity, centry, context,
+                                       implicit_cast<TNode<Object>>(args)...);
 }
 
 // Instantiate TailCallRuntime() for argument counts used by CSA-generated code
 #define INSTANTIATE(...)                                              \
-  template V8_EXPORT_PRIVATE TNode<Object> CodeAssembler::TailCallRuntimeImpl( \
-      Runtime::FunctionId, __VA_ARGS__);
-REPEAT_1_TO_7(INSTANTIATE, SloppyTNode<Object>)
+  template V8_EXPORT_PRIVATE void CodeAssembler::TailCallRuntimeImpl( \
+      Runtime::FunctionId, TNode<Int32T>, __VA_ARGS__);
+REPEAT_0_TO_6(INSTANTIATE, TNode<Object>, SloppyTNode<Object>)
 #undef INSTANTIATE
 
 template <class... TArgs>
-TNode<Object> CodeAssembler::TailCallRuntimeWithCEntryImpl(
-    Runtime::FunctionId function, TNode<Object> centry, TNode<Object> context,
+void CodeAssembler::TailCallRuntimeWithCEntryImpl(Runtime::FunctionId function,
+                                                  TNode<Int32T> arity,
+                                                  TNode<Code> centry,
+                                                  TNode<Object> context,
                                                   TArgs... args) {
   int argc = static_cast<int>(sizeof...(args));
   auto call_descriptor = Linkage::GetRuntimeCallDescriptor(
@@ -1107,27 +1114,25 @@ TNode<Object> CodeAssembler::TailCallRuntimeWithCEntryImpl(
       CallDescriptor::kNoFlags);
 
   Node* ref = ExternalConstant(ExternalReference::Create(function));
-  Node* arity = Int32Constant(argc);
 
   Node* nodes[] = {centry, args..., ref, arity, context};
 
-  return UncheckedCast<Object>(
-      raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes));
+  raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes);
 }
 
-// Instantiate TailCallRuntimeWithCEntry() for argument counts used by
+// Instantiate TailCallRuntimeWithCEntryImpl() for argument counts used by
 // CSA-generated code.
 #define INSTANTIATE(...)                            \
-  template V8_EXPORT_PRIVATE TNode<Object>          \
+  template V8_EXPORT_PRIVATE void                   \
       CodeAssembler::TailCallRuntimeWithCEntryImpl( \
-          Runtime::FunctionId, TNode<Object>, __VA_ARGS__);
-REPEAT_1_TO_7(INSTANTIATE, TNode<Object>)
+          Runtime::FunctionId, TNode<Int32T>, TNode<Code>, __VA_ARGS__);
+REPEAT_0_TO_6(INSTANTIATE, TNode<Object>, SloppyTNode<Object>)
 #undef INSTANTIATE
 
 template <class... TArgs>
 Node* CodeAssembler::CallStubR(const CallInterfaceDescriptor& descriptor,
-                               size_t result_size, Node* target, Node* context,
-                               TArgs... args) {
+                               size_t result_size, SloppyTNode<Code> target,
+                               SloppyTNode<Object> context, TArgs... args) {
   Node* nodes[] = {target, args..., context};
   int input_count = arraysize(nodes);
   if (context == nullptr) --input_count;
@@ -1138,8 +1143,9 @@ Node* CodeAssembler::CallStubR(const CallInterfaceDescriptor& descriptor,
 // Instantiate CallStubR() for argument counts used by CSA-generated code.
 #define INSTANTIATE(...)                                                    \
   template V8_EXPORT_PRIVATE Node* CodeAssembler::CallStubR(                \
-      const CallInterfaceDescriptor& descriptor, size_t, Node*, __VA_ARGS__);
-REPEAT_1_TO_11(INSTANTIATE, Node*)
+      const CallInterfaceDescriptor& descriptor, size_t, SloppyTNode<Code>, \
+      __VA_ARGS__);
+REPEAT_0_TO_10(INSTANTIATE, SloppyTNode<Object>, Node*)
 #undef INSTANTIATE
 
 Node* CodeAssembler::CallStubN(const CallInterfaceDescriptor& descriptor,
@@ -1167,8 +1173,8 @@ Node* CodeAssembler::CallStubN(const CallInterfaceDescriptor& descriptor,
 }
 
 template <class... TArgs>
-Node* CodeAssembler::TailCallStubImpl(const CallInterfaceDescriptor& descriptor,
-                                      Node* target, Node* context,
+void CodeAssembler::TailCallStubImpl(const CallInterfaceDescriptor& descriptor,
+                                     TNode<Code> target, TNode<Object> context,
                                      TArgs... args) {
   DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
   size_t result_size = 1;
@@ -1179,14 +1185,14 @@ Node* CodeAssembler::TailCallStubImpl(const CallInterfaceDescriptor& descriptor,
 
   Node* nodes[] = {target, args..., context};
   CHECK_EQ(descriptor.GetParameterCount() + 2, arraysize(nodes));
-  return raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes);
+  raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes);
 }
 
 // Instantiate TailCallStub() for argument counts used by CSA-generated code
 #define INSTANTIATE(...)                                           \
-  template V8_EXPORT_PRIVATE Node* CodeAssembler::TailCallStubImpl( \
-      const CallInterfaceDescriptor& descriptor, Node*, __VA_ARGS__);
-REPEAT_1_TO_12(INSTANTIATE, Node*)
+  template V8_EXPORT_PRIVATE void CodeAssembler::TailCallStubImpl( \
+      const CallInterfaceDescriptor& descriptor, TNode<Code>, __VA_ARGS__);
+REPEAT_0_TO_11(INSTANTIATE, TNode<Object>, Node*)
 #undef INSTANTIATE
 
 template <class... TArgs>
@@ -1213,7 +1219,7 @@ Node* CodeAssembler::TailCallStubThenBytecodeDispatch(
   template V8_EXPORT_PRIVATE Node*                 \
   CodeAssembler::TailCallStubThenBytecodeDispatch( \
       const CallInterfaceDescriptor&, Node*, Node*, Node*, __VA_ARGS__);
-REPEAT_1_TO_7(INSTANTIATE, Node*)
+REPEAT_0_TO_6(INSTANTIATE, Node*, Node*)
 #undef INSTANTIATE
 
 template <class... TArgs>
@@ -1707,14 +1713,14 @@ Smi* CheckObjectType(Object* value, Smi* type, String* location) {
 }  // namespace internal
 }  // namespace v8
 
-#undef REPEAT_1_TO_2
-#undef REPEAT_1_TO_3
-#undef REPEAT_1_TO_4
-#undef REPEAT_1_TO_5
-#undef REPEAT_1_TO_6
-#undef REPEAT_1_TO_7
-#undef REPEAT_1_TO_8
-#undef REPEAT_1_TO_9
-#undef REPEAT_1_TO_10
-#undef REPEAT_1_TO_11
-#undef REPEAT_1_TO_12
+#undef REPEAT_0_TO_1
+#undef REPEAT_0_TO_2
+#undef REPEAT_0_TO_3
+#undef REPEAT_0_TO_4
+#undef REPEAT_0_TO_5
+#undef REPEAT_0_TO_6
+#undef REPEAT_0_TO_7
+#undef REPEAT_0_TO_8
+#undef REPEAT_0_TO_9
+#undef REPEAT_0_TO_10
+#undef REPEAT_0_TO_11

src/compiler/code-assembler.h

@@ -975,9 +975,6 @@ class V8_EXPORT_PRIVATE CodeAssembler {
 
   // Calls
   template <class... TArgs>
-  TNode<Object> CallRuntimeImpl(Runtime::FunctionId function,
-                                SloppyTNode<Object> context, TArgs... args);
-  template <class... TArgs>
   TNode<Object> CallRuntime(Runtime::FunctionId function,
                             SloppyTNode<Object> context, TArgs... args) {
     return CallRuntimeImpl(function, context,
@@ -985,70 +982,75 @@ class V8_EXPORT_PRIVATE CodeAssembler {
   }
 
   template <class... TArgs>
-  TNode<Object> TailCallRuntimeImpl(Runtime::FunctionId function,
-                                    SloppyTNode<Object> context, TArgs... args);
-  template <class... TArgs>
-  TNode<Object> TailCallRuntime(Runtime::FunctionId function,
+  void TailCallRuntime(Runtime::FunctionId function,
                        SloppyTNode<Object> context, TArgs... args) {
-    return TailCallRuntimeImpl(function, context,
+    int argc = static_cast<int>(sizeof...(args));
+    TNode<Int32T> arity = Int32Constant(argc);
+    return TailCallRuntimeImpl(function, arity, context,
                                implicit_cast<SloppyTNode<Object>>(args)...);
   }
 
   template <class... TArgs>
-  TNode<Object> TailCallRuntimeWithCEntryImpl(Runtime::FunctionId function,
-                                              TNode<Object> centry,
-                                              TNode<Object> context,
-                                              TArgs... args);
+  void TailCallRuntime(Runtime::FunctionId function, TNode<Int32T> arity,
+                       SloppyTNode<Object> context, TArgs... args) {
+    return TailCallRuntimeImpl(function, arity, context,
+                               implicit_cast<SloppyTNode<Object>>(args)...);
+  }
+
   template <class... TArgs>
-  TNode<Object> TailCallRuntimeWithCEntry(Runtime::FunctionId function,
-                                          TNode<Object> centry,
-                                          TNode<Object> context,
+  void TailCallRuntimeWithCEntry(Runtime::FunctionId function,
+                                 TNode<Code> centry, TNode<Object> context,
                                  TArgs... args) {
-    return TailCallRuntimeWithCEntryImpl(function, centry, context,
-                                         implicit_cast<TNode<Object>>(args)...);
+    int argc = static_cast<int>(sizeof...(args));
+    TNode<Int32T> arity = Int32Constant(argc);
+    return TailCallRuntimeWithCEntryImpl(
+        function, arity, centry, context,
+        implicit_cast<SloppyTNode<Object>>(args)...);
   }
 
   //
   // If context passed to CallStub is nullptr, it won't be passed to the stub.
   //
 
-  template <class... TArgs>
-  Node* CallStub(Callable const& callable, Node* context, TArgs... args) {
-    Node* target = HeapConstant(callable.code());
-    return CallStub(callable.descriptor(), target, context,
+  template <class T = Object, class... TArgs>
+  TNode<T> CallStub(Callable const& callable, SloppyTNode<Object> context,
+                    TArgs... args) {
+    TNode<Code> target = HeapConstant(callable.code());
+    return CallStub<T>(callable.descriptor(), target, context,
                        implicit_cast<Node*>(args)...);
   }
 
-  template <class... TArgs>
-  Node* CallStub(const CallInterfaceDescriptor& descriptor, Node* target,
-                 Node* context, TArgs... args) {
-    return CallStubR(descriptor, 1, target, context,
-                     implicit_cast<Node*>(args)...);
+  template <class T = Object, class... TArgs>
+  TNode<T> CallStub(const CallInterfaceDescriptor& descriptor,
+                    SloppyTNode<Code> target, SloppyTNode<Object> context,
+                    TArgs... args) {
+    return UncheckedCast<T>(CallStubR(descriptor, 1, target, context,
+                                      implicit_cast<Node*>(args)...));
   }
 
   template <class... TArgs>
   Node* CallStubR(const CallInterfaceDescriptor& descriptor, size_t result_size,
-                  Node* target, Node* context, TArgs... args);
+                  SloppyTNode<Code> target, SloppyTNode<Object> context,
+                  TArgs... args);
 
   Node* CallStubN(const CallInterfaceDescriptor& descriptor, size_t result_size,
                   int input_count, Node* const* inputs,
                   bool pass_context = true);
 
   template <class... TArgs>
-  Node* TailCallStub(Callable const& callable, Node* context, TArgs... args) {
-    Node* target = HeapConstant(callable.code());
+  void TailCallStub(Callable const& callable, SloppyTNode<Object> context,
+                    TArgs... args) {
+    TNode<Code> target = HeapConstant(callable.code());
     return TailCallStub(callable.descriptor(), target, context, args...);
   }
 
   template <class... TArgs>
-  Node* TailCallStub(const CallInterfaceDescriptor& descriptor, Node* target,
-                     Node* context, TArgs... args) {
+  void TailCallStub(const CallInterfaceDescriptor& descriptor,
+                    SloppyTNode<Code> target, SloppyTNode<Object> context,
+                    TArgs... args) {
     return TailCallStubImpl(descriptor, target, context,
                             implicit_cast<Node*>(args)...);
   }
-  template <class... TArgs>
-  Node* TailCallStubImpl(const CallInterfaceDescriptor& descriptor,
-                         Node* target, Node* context, TArgs... args);
 
   template <class... TArgs>
   Node* TailCallBytecodeDispatch(const CallInterfaceDescriptor& descriptor,
@@ -1179,6 +1181,23 @@ class V8_EXPORT_PRIVATE CodeAssembler {
   PoisoningMitigationLevel poisoning_level() const;
 
  private:
+  template <class... TArgs>
+  TNode<Object> CallRuntimeImpl(Runtime::FunctionId function,
+                                TNode<Object> context, TArgs... args);
+
+  template <class... TArgs>
+  void TailCallRuntimeImpl(Runtime::FunctionId function, TNode<Int32T> arity,
+                           TNode<Object> context, TArgs... args);
+
+  template <class... TArgs>
+  void TailCallRuntimeWithCEntryImpl(Runtime::FunctionId function,
+                                     TNode<Int32T> arity, TNode<Code> centry,
+                                     TNode<Object> context, TArgs... args);
+
+  template <class... TArgs>
+  void TailCallStubImpl(const CallInterfaceDescriptor& descriptor,
+                        TNode<Code> target, TNode<Object> context,
+                        TArgs... args);
   // These two don't have definitions and are here only for catching use cases
   // where the cast is not necessary.
   TNode<Int32T> Signed(TNode<Int32T> x);

src/ic/accessor-assembler.cc

@@ -886,8 +886,8 @@ void AccessorAssembler::HandleStoreICHandlerCase(
     BIND(&call_handler);
     {
       StoreWithVectorDescriptor descriptor(isolate());
-      TailCallStub(descriptor, strong_handler, p->context, p->receiver, p->name,
-                   p->value, p->slot, p->vector);
+      TailCallStub(descriptor, CAST(strong_handler), CAST(p->context),
+                   p->receiver, p->name, p->value, p->slot, p->vector);
     }
   }
 
@@ -3077,8 +3077,8 @@ void AccessorAssembler::StoreInArrayLiteralIC(const StoreICParameters* p) {
       Label if_transitioning_element_store(this);
       GotoIfNot(IsCode(handler), &if_transitioning_element_store);
       StoreWithVectorDescriptor descriptor(isolate());
-      TailCallStub(descriptor, handler, p->context, p->receiver, p->name,
-                   p->value, p->slot, p->vector);
+      TailCallStub(descriptor, CAST(handler), CAST(p->context), p->receiver,
+                   p->name, p->value, p->slot, p->vector);
 
       BIND(&if_transitioning_element_store);
       {