[arm64] Preparation for padding of arguments

As part of JSSP removal, we need to align the arguments passed to functions
on the stack, by adding a padding slot when the total number of arguments
is odd.

This patch introduces the kPadArguments flag (which is currently set to
false for all architectures), which will control padding of arguments in
architecture-independent parts of the code (deoptimizer, instruction
selector).

It also adds some executable tests for tail calls with various stack
parameter counts on the caller and callee sides.

This will be turned on for arm64 together with arm64-specific changes to
the code generator, the MacroAsembler and the builtins, in a later patch.

Bug: v8:6644
Change-Id: I79a5c149123fe8130cedd1ccffec3d9b50361e08
Reviewed-on: https://chromium-review.googlesource.com/806554
Commit-Queue: Georgia Kouveli <georgia.kouveli@arm.com>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#50134}

src/arm/assembler-arm.h

@@ -173,6 +173,7 @@ GENERAL_REGISTERS(DECLARE_REGISTER)
 #undef DECLARE_REGISTER
 constexpr Register no_reg = Register::no_reg();
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = false;
 constexpr bool kSimdMaskRegisters = false;
 

src/arm64/assembler-arm64.h

@@ -295,6 +295,9 @@ class Register : public CPURegister {
 static_assert(IS_TRIVIALLY_COPYABLE(Register),
               "Register can efficiently be passed by value");
 
+// TODO(arm64): Switch this on when the rest of the argument padding changes
+//              are done.
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/compiler/linkage.cc

@@ -101,7 +101,24 @@ int CallDescriptor::GetStackParameterDelta(
       }
     }
   }
-  return callee_slots_above_sp - tail_caller_slots_above_sp;
+
+  int stack_param_delta = callee_slots_above_sp - tail_caller_slots_above_sp;
+  if (kPadArguments) {
+    // Adjust stack delta when it is odd.
+    if (stack_param_delta % 2 != 0) {
+      if (callee_slots_above_sp % 2 != 0) {
+        // The delta is odd due to the callee - we will need to add one slot
+        // of padding.
+        ++stack_param_delta;
+      } else {
+        // The delta is odd because of the caller. We already have one slot of
+        // padding that we can reuse for arguments, so we will need one fewer
+        // slot.
+        --stack_param_delta;
+      }
+    }
+  }
+  return stack_param_delta;
 }
 
 bool CallDescriptor::CanTailCall(const Node* node) const {

src/compiler/linkage.h

@@ -298,7 +298,7 @@ class V8_EXPORT_PRIVATE CallDescriptor final
 
   bool HasSameReturnLocationsAs(const CallDescriptor* other) const;
 
-  int GetStackParameterDelta(const CallDescriptor* tail_caller = nullptr) const;
+  int GetStackParameterDelta(const CallDescriptor* tail_caller) const;
 
   bool CanTailCall(const Node* call) const;
 

src/deoptimizer.cc

@@ -556,6 +556,10 @@ int LookupCatchHandler(TranslatedFrame* translated_frame, int* data_out) {
   return -1;
 }
 
+bool ShouldPadArguments(int arg_count) {
+  return kPadArguments && (arg_count % 2 != 0);
+}
+
 }  // namespace
 
 // We rely on this function not causing a GC.  It is called from generated code
@@ -728,7 +732,8 @@ void Deoptimizer::DoComputeInterpretedFrame(TranslatedFrame* translated_frame,
   }
 
   // The 'fixed' part of the frame consists of the incoming parameters and
-  // the part described by InterpreterFrameConstants.
+  // the part described by InterpreterFrameConstants. This will include
+  // argument padding, when needed.
   unsigned fixed_frame_size = ComputeInterpretedFixedSize(shared);
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
@@ -753,12 +758,20 @@ void Deoptimizer::DoComputeInterpretedFrame(TranslatedFrame* translated_frame,
 
   // Compute the incoming parameter translation.
   unsigned output_offset = output_frame_size;
+
+  if (ShouldPadArguments(parameter_count)) {
+    output_offset -= kPointerSize;
+    WriteValueToOutput(isolate()->heap()->the_hole_value(), 0, frame_index,
+                       output_offset, "padding ");
+  }
+
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     WriteTranslatedValueToOutput(&value_iterator, &input_index, frame_index,
                                  output_offset);
   }
 
+  DCHECK_EQ(output_offset, output_frame->GetLastArgumentSlotOffset());
   if (trace_scope_ != nullptr) {
     PrintF(trace_scope_->file(), "    -------------------------\n");
   }
@@ -978,6 +991,9 @@ void Deoptimizer::DoComputeArgumentsAdaptorFrame(
 
   unsigned height = translated_frame->height();
   unsigned height_in_bytes = height * kPointerSize;
+  int parameter_count = height;
+  if (ShouldPadArguments(parameter_count)) height_in_bytes += kPointerSize;
+
   TranslatedFrame::iterator function_iterator = value_iterator;
   Object* function = value_iterator->GetRawValue();
   value_iterator++;
@@ -991,7 +1007,6 @@ void Deoptimizer::DoComputeArgumentsAdaptorFrame(
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
   // Allocate and store the output frame description.
-  int parameter_count = height;
   FrameDescription* output_frame = new (output_frame_size)
       FrameDescription(output_frame_size, parameter_count);
 
@@ -1010,14 +1025,21 @@ void Deoptimizer::DoComputeArgumentsAdaptorFrame(
   }
   output_frame->SetTop(top_address);
 
-  // Compute the incoming parameter translation.
   unsigned output_offset = output_frame_size;
+  if (ShouldPadArguments(parameter_count)) {
+    output_offset -= kPointerSize;
+    WriteValueToOutput(isolate()->heap()->the_hole_value(), 0, frame_index,
+                       output_offset, "padding ");
+  }
+
+  // Compute the incoming parameter translation.
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     WriteTranslatedValueToOutput(&value_iterator, &input_index, frame_index,
                                  output_offset);
   }
 
+  DCHECK_EQ(output_offset, output_frame->GetLastArgumentSlotOffset());
   // Read caller's PC from the previous frame.
   output_offset -= kPCOnStackSize;
   intptr_t value;
@@ -1130,6 +1152,9 @@ void Deoptimizer::DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
     if (PadTopOfStackRegister()) height_in_bytes += kPointerSize;
   }
 
+  int parameter_count = height;
+  if (ShouldPadArguments(parameter_count)) height_in_bytes += kPointerSize;
+
   JSFunction* function = JSFunction::cast(value_iterator->GetRawValue());
   value_iterator++;
   input_index++;
@@ -1145,8 +1170,8 @@ void Deoptimizer::DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
   // Allocate and store the output frame description.
-  FrameDescription* output_frame =
-      new (output_frame_size) FrameDescription(output_frame_size);
+  FrameDescription* output_frame = new (output_frame_size)
+      FrameDescription(output_frame_size, parameter_count);
 
   // Construct stub can not be topmost.
   DCHECK(frame_index > 0 && frame_index < output_count_);
@@ -1159,9 +1184,15 @@ void Deoptimizer::DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
   top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   output_frame->SetTop(top_address);
 
-  // Compute the incoming parameter translation.
-  int parameter_count = height;
   unsigned output_offset = output_frame_size;
+
+  if (ShouldPadArguments(parameter_count)) {
+    output_offset -= kPointerSize;
+    WriteValueToOutput(isolate()->heap()->the_hole_value(), 0, frame_index,
+                       output_offset, "padding ");
+  }
+
+  // Compute the incoming parameter translation.
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     // The allocated receiver of a construct stub frame is passed as the
@@ -1172,6 +1203,7 @@ void Deoptimizer::DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
         (i == 0) ? reinterpret_cast<Address>(top_address) : nullptr);
   }
 
+  DCHECK_EQ(output_offset, output_frame->GetLastArgumentSlotOffset());
   // Read caller's PC from the previous frame.
   output_offset -= kPCOnStackSize;
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
@@ -1236,7 +1268,12 @@ void Deoptimizer::DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
                      output_offset, "padding");
 
   output_offset -= kPointerSize;
+
+  if (ShouldPadArguments(parameter_count)) {
+    value = output_frame->GetFrameSlot(output_frame_size - 2 * kPointerSize);
+  } else {
     value = output_frame->GetFrameSlot(output_frame_size - kPointerSize);
+  }
   output_frame->SetFrameSlot(output_offset, value);
 
   if (bailout_id == BailoutId::ConstructStubCreate()) {
@@ -1382,7 +1419,7 @@ void Deoptimizer::DoComputeBuiltinContinuation(
   // parameter count.
   int stack_param_count = height_in_words - register_parameter_count - 1;
   if (must_handle_result) stack_param_count++;
-  int output_frame_size =
+  unsigned output_frame_size =
       kPointerSize * (stack_param_count + allocatable_register_count +
                       padding_slot_count) +
       BuiltinContinuationFrameConstants::kFixedFrameSize;
@@ -1424,9 +1461,12 @@ void Deoptimizer::DoComputeBuiltinContinuation(
            stack_param_count);
   }
 
-  unsigned output_frame_offset = output_frame_size;
-  FrameDescription* output_frame =
-      new (output_frame_size) FrameDescription(output_frame_size);
+  int translated_stack_parameters =
+      must_handle_result ? stack_param_count - 1 : stack_param_count;
+
+  if (ShouldPadArguments(stack_param_count)) output_frame_size += kPointerSize;
+  FrameDescription* output_frame = new (output_frame_size)
+      FrameDescription(output_frame_size, stack_param_count);
   output_[frame_index] = output_frame;
 
   // The top address of the frame is computed from the previous frame's top and
@@ -1457,8 +1497,12 @@ void Deoptimizer::DoComputeBuiltinContinuation(
 
   intptr_t value;
 
-  int translated_stack_parameters =
-      must_handle_result ? stack_param_count - 1 : stack_param_count;
+  unsigned output_frame_offset = output_frame_size;
+  if (ShouldPadArguments(stack_param_count)) {
+    output_frame_offset -= kPointerSize;
+    WriteValueToOutput(isolate()->heap()->the_hole_value(), 0, frame_index,
+                       output_frame_offset, "padding ");
+  }
 
   for (int i = 0; i < translated_stack_parameters; ++i) {
     output_frame_offset -= kPointerSize;
@@ -1473,6 +1517,8 @@ void Deoptimizer::DoComputeBuiltinContinuation(
                        "placeholder for return result on lazy deopt ");
   }
 
+  DCHECK_EQ(output_frame_offset, output_frame->GetLastArgumentSlotOffset());
+
   for (int i = 0; i < register_parameter_count; ++i) {
     Object* object = value_iterator->GetRawValue();
     int code = continuation_descriptor.GetRegisterParameter(i).code();
@@ -1754,14 +1800,6 @@ unsigned Deoptimizer::ComputeInputFrameSize() const {
   return result;
 }
 
-// static
-unsigned Deoptimizer::ComputeJavascriptFixedSize(SharedFunctionInfo* shared) {
-  // The fixed part of the frame consists of the return address, frame
-  // pointer, function, context, and all the incoming arguments.
-  return ComputeIncomingArgumentSize(shared) +
-         StandardFrameConstants::kFixedFrameSize;
-}
-
 // static
 unsigned Deoptimizer::ComputeInterpretedFixedSize(SharedFunctionInfo* shared) {
   // The fixed part of the frame consists of the return address, frame
@@ -1772,7 +1810,9 @@ unsigned Deoptimizer::ComputeInterpretedFixedSize(SharedFunctionInfo* shared) {
 
 // static
 unsigned Deoptimizer::ComputeIncomingArgumentSize(SharedFunctionInfo* shared) {
-  return (shared->internal_formal_parameter_count() + 1) * kPointerSize;
+  int parameter_slots = shared->internal_formal_parameter_count() + 1;
+  if (kPadArguments) parameter_slots = RoundUp(parameter_slots, 2);
+  return parameter_slots * kPointerSize;
 }
 
 void Deoptimizer::EnsureCodeForDeoptimizationEntry(Isolate* isolate,

src/deoptimizer.h

@@ -547,7 +547,6 @@ class Deoptimizer : public Malloced {
 
   unsigned ComputeInputFrameAboveFpFixedSize() const;
   unsigned ComputeInputFrameSize() const;
-  static unsigned ComputeJavascriptFixedSize(SharedFunctionInfo* shared);
   static unsigned ComputeInterpretedFixedSize(SharedFunctionInfo* shared);
 
   static unsigned ComputeIncomingArgumentSize(SharedFunctionInfo* shared);
@@ -700,9 +699,15 @@ class FrameDescription {
     return *GetFrameSlotPointer(offset);
   }
 
+  unsigned GetLastArgumentSlotOffset() {
+    int parameter_slots = parameter_count();
+    if (kPadArguments) parameter_slots = RoundUp(parameter_slots, 2);
+    return GetFrameSize() - parameter_slots * kPointerSize;
+  }
+
   Address GetFramePointerAddress() {
-    int fp_offset = GetFrameSize() - parameter_count() * kPointerSize -
-                    StandardFrameConstants::kCallerSPOffset;
+    int fp_offset =
+        GetLastArgumentSlotOffset() - StandardFrameConstants::kCallerSPOffset;
     return reinterpret_cast<Address>(GetFrameSlotPointer(fp_offset));
   }
 

src/ia32/assembler-ia32.h

@@ -113,6 +113,7 @@ GENERAL_REGISTERS(DEFINE_REGISTER)
 #undef DEFINE_REGISTER
 constexpr Register no_reg = Register::no_reg();
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/mips/assembler-mips.h

@@ -238,6 +238,7 @@ int ToNumber(Register reg);
 
 Register ToRegister(int num);
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/mips64/assembler-mips64.h

@@ -238,6 +238,7 @@ int ToNumber(Register reg);
 
 Register ToRegister(int num);
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/ppc/assembler-ppc.h

@@ -303,6 +303,7 @@ constexpr Register kConstantPoolRegister = r28;  // Constant pool.
 constexpr Register kRootRegister = r29;          // Roots array pointer.
 constexpr Register cp = r30;                     // JavaScript context pointer.
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/s390/assembler-s390.h

@@ -276,6 +276,7 @@ constexpr Register kLithiumScratch = r1;  // lithium scratch.
 constexpr Register kRootRegister = r10;   // Roots array pointer.
 constexpr Register cp = r13;              // JavaScript context pointer.
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

src/x64/assembler-x64.h

@@ -182,6 +182,7 @@ constexpr Register arg_reg_4 = rcx;
   V(xmm13)                              \
   V(xmm14)
 
+constexpr bool kPadArguments = false;
 constexpr bool kSimpleFPAliasing = true;
 constexpr bool kSimdMaskRegisters = false;
 

test/cctest/BUILD.gn

@@ -84,6 +84,7 @@ v8_source_set("cctest_sources") {
     "compiler/test-run-native-calls.cc",
     "compiler/test-run-stackcheck.cc",
     "compiler/test-run-stubs.cc",
+    "compiler/test-run-tail-calls.cc",
     "compiler/test-run-unwinding-info.cc",
     "compiler/test-run-variables.cc",
     "compiler/test-run-wasm-machops.cc",

test/cctest/cctest.gyp

@@ -73,6 +73,7 @@
       'compiler/test-run-native-calls.cc',
       'compiler/test-run-stackcheck.cc',
       'compiler/test-run-stubs.cc',
+      'compiler/test-run-tail-calls.cc',
       'compiler/test-run-variables.cc',
       'compiler/test-run-wasm-machops.cc',
       'compiler/value-helper.cc',

test/cctest/compiler/code-assembler-tester.h

@@ -36,10 +36,11 @@ class CodeAssemblerTester {
         scope_(isolate),
         state_(isolate, &zone_, 0, kind, "test") {}
 
-  CodeAssemblerTester(Isolate* isolate, CallDescriptor* call_descriptor)
+  CodeAssemblerTester(Isolate* isolate, CallDescriptor* call_descriptor,
+                      const char* name = "test")
       : zone_(isolate->allocator(), ZONE_NAME),
         scope_(isolate),
-        state_(isolate, &zone_, call_descriptor, Code::STUB, "test", 0, -1) {}
+        state_(isolate, &zone_, call_descriptor, Code::STUB, name, 0, -1) {}
 
   CodeAssemblerState* state() { return &state_; }
 

test/cctest/compiler/test-run-tail-calls.cc

+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/assembler-inl.h"
+#include "src/base/utils/random-number-generator.h"
+#include "src/code-stub-assembler.h"
+
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/code-assembler-tester.h"
+#include "test/cctest/compiler/function-tester.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+#define __ assembler.
+
+namespace {
+
+// Function that takes a number of pointer-sized integer arguments, calculates a
+// weighted sum of them and returns it.
+Handle<Code> BuildCallee(Isolate* isolate, CallDescriptor* descriptor) {
+  CodeAssemblerTester tester(isolate, descriptor, "callee");
+  CodeStubAssembler assembler(tester.state());
+  int param_count = static_cast<int>(descriptor->StackParameterCount());
+  Node* sum = __ IntPtrConstant(0);
+  for (int i = 0; i < param_count; ++i) {
+    Node* product = __ IntPtrMul(__ Parameter(i), __ IntPtrConstant(i + 1));
+    sum = __ IntPtrAdd(sum, product);
+  }
+  __ Return(sum);
+  return tester.GenerateCodeCloseAndEscape();
+}
+
+// Function that tail-calls another function with a number of pointer-sized
+// integer arguments.
+Handle<Code> BuildCaller(Isolate* isolate, CallDescriptor* descriptor,
+                         CallDescriptor* callee_descriptor) {
+  CodeAssemblerTester tester(isolate, descriptor, "caller");
+  CodeStubAssembler assembler(tester.state());
+  std::vector<Node*> params;
+  // The first parameter is always the callee.
+  params.push_back(__ HeapConstant(BuildCallee(isolate, callee_descriptor)));
+  int param_count = static_cast<int>(callee_descriptor->StackParameterCount());
+  for (int i = 0; i < param_count; ++i) {
+    params.push_back(__ IntPtrConstant(i));
+  }
+  DCHECK_EQ(param_count + 1, params.size());
+  tester.raw_assembler_for_testing()->TailCallN(callee_descriptor,
+                                                param_count + 1, params.data());
+  return tester.GenerateCodeCloseAndEscape();
+}
+
+// Setup function, which calls "caller".
+Handle<Code> BuildSetupFunction(Isolate* isolate,
+                                CallDescriptor* caller_descriptor,
+                                CallDescriptor* callee_descriptor) {
+  CodeAssemblerTester tester(isolate, 0);
+  CodeStubAssembler assembler(tester.state());
+  std::vector<Node*> params;
+  // The first parameter is always the callee.
+  params.push_back(__ HeapConstant(
+      BuildCaller(isolate, caller_descriptor, callee_descriptor)));
+  // Set up arguments for "Caller".
+  int param_count = static_cast<int>(caller_descriptor->StackParameterCount());
+  for (int i = 0; i < param_count; ++i) {
+    // Use values that are different from the ones we will pass to this
+    // function's callee later.
+    params.push_back(__ IntPtrConstant(i + 42));
+  }
+  DCHECK_EQ(param_count + 1, params.size());
+  Node* raw_result = tester.raw_assembler_for_testing()->CallN(
+      caller_descriptor, param_count + 1, params.data());
+  __ Return(__ SmiTag(raw_result));
+  return tester.GenerateCodeCloseAndEscape();
+}
+
+CallDescriptor* CreateDescriptorForStackArguments(Zone* zone,
+                                                  int stack_param_count) {
+  LocationSignature::Builder locations(zone, 1,
+                                       static_cast<size_t>(stack_param_count));
+
+  locations.AddReturn(LinkageLocation::ForRegister(kReturnRegister0.code(),
+                                                   MachineType::IntPtr()));
+
+  for (int i = 0; i < stack_param_count; ++i) {
+    locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+        i - stack_param_count, MachineType::IntPtr()));
+  }
+
+  return new (zone)
+      CallDescriptor(CallDescriptor::kCallCodeObject,  // kind
+                     MachineType::AnyTagged(),         // target MachineType
+                     LinkageLocation::ForAnyRegister(
+                         MachineType::AnyTagged()),  // target location
+                     locations.Build(),              // location_sig
+                     stack_param_count,              // stack_parameter_count
+                     Operator::kNoProperties,        // properties
+                     kNoCalleeSaved,                 // callee-saved registers
+                     kNoCalleeSaved,                 // callee-saved fp
+                     CallDescriptor::kNoFlags);      // flags
+}
+
+// Test a tail call from a caller with n parameters to a callee with m
+// parameters. All parameters are pointer-sized.
+void TestHelper(int n, int m) {
+  HandleAndZoneScope scope;
+  Isolate* isolate = scope.main_isolate();
+  Zone* zone = scope.main_zone();
+  CallDescriptor* caller_descriptor =
+      CreateDescriptorForStackArguments(zone, n);
+  CallDescriptor* callee_descriptor =
+      CreateDescriptorForStackArguments(zone, m);
+  Handle<Code> setup =
+      BuildSetupFunction(isolate, caller_descriptor, callee_descriptor);
+  FunctionTester ft(setup, 0);
+  Handle<Object> result = ft.Call().ToHandleChecked();
+  int expected = 0;
+  for (int i = 0; i < m; ++i) expected += (i + 1) * i;
+  CHECK_EQ(expected, Handle<Smi>::cast(result)->value());
+}
+
+}  // namespace
+
+#undef __
+
+TEST(CallerOddCalleeEven) {
+  TestHelper(1, 0);
+  TestHelper(1, 2);
+  TestHelper(3, 2);
+  TestHelper(3, 4);
+}
+
+TEST(CallerOddCalleeOdd) {
+  TestHelper(1, 1);
+  TestHelper(1, 3);
+  TestHelper(3, 1);
+  TestHelper(3, 3);
+}
+
+TEST(CallerEvenCalleeEven) {
+  TestHelper(0, 0);
+  TestHelper(0, 2);
+  TestHelper(2, 0);
+  TestHelper(2, 2);
+}
+
+TEST(CallerEvenCalleeOdd) {
+  TestHelper(0, 1);
+  TestHelper(0, 3);
+  TestHelper(2, 1);
+  TestHelper(2, 3);
+}
+
+TEST(FuzzStackParamCount) {
+  const int kNumTests = 1000;
+  const int kMaxSlots = 30;
+  base::RandomNumberGenerator* const rng = CcTest::random_number_generator();
+  for (int i = 0; i < kNumTests; ++i) {
+    int n = rng->NextInt(kMaxSlots);
+    int m = rng->NextInt(kMaxSlots);
+    TestHelper(n, m);
+  }
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

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

@@ -157,7 +157,9 @@ TEST_F(LinkageTailCall, MoreRegisterAndStackParametersCallee) {
   Node* const node = Node::New(zone(), 1, op, 0, nullptr, false);
   EXPECT_TRUE(desc1->CanTailCall(node));
   int stack_param_delta = desc2->GetStackParameterDelta(desc1);
-  EXPECT_EQ(1, stack_param_delta);
+  // We might need to add one slot of padding to the callee arguments.
+  int expected = kPadArguments ? 2 : 1;
+  EXPECT_EQ(expected, stack_param_delta);
 }
 
 
@@ -178,7 +180,9 @@ TEST_F(LinkageTailCall, MoreRegisterAndStackParametersCaller) {
   Node* const node = Node::New(zone(), 1, op, 0, nullptr, false);
   EXPECT_TRUE(desc1->CanTailCall(node));
   int stack_param_delta = desc2->GetStackParameterDelta(desc1);
-  EXPECT_EQ(-1, stack_param_delta);
+  // We might need to drop one slot of padding from the caller's arguments.
+  int expected = kPadArguments ? -2 : -1;
+  EXPECT_EQ(expected, stack_param_delta);
 }
 
 
@@ -313,7 +317,9 @@ TEST_F(LinkageTailCall, MatchingStackParametersExtraCallerRegistersAndStack) {
       Node::New(zone(), 1, op, arraysize(parameters), parameters, false);
   EXPECT_TRUE(desc1->CanTailCall(node));
   int stack_param_delta = desc2->GetStackParameterDelta(desc1);
-  EXPECT_EQ(-1, stack_param_delta);
+  // We might need to add one slot of padding to the callee arguments.
+  int expected = kPadArguments ? 0 : -1;
+  EXPECT_EQ(expected, stack_param_delta);
 }
 
 
@@ -341,7 +347,9 @@ TEST_F(LinkageTailCall, MatchingStackParametersExtraCalleeRegistersAndStack) {
       Node::New(zone(), 1, op, arraysize(parameters), parameters, false);
   EXPECT_TRUE(desc1->CanTailCall(node));
   int stack_param_delta = desc2->GetStackParameterDelta(desc1);
-  EXPECT_EQ(1, stack_param_delta);
+  // We might need to drop one slot of padding from the caller's arguments.
+  int expected = kPadArguments ? 0 : 1;
+  EXPECT_EQ(expected, stack_param_delta);
 }
 
 }  // namespace compiler