[turbofan, arm64] Fix native stack parameters on arm64.

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

 // Copyright 2015 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.
 
 // TODO(jochen): Remove this after the setting is turned on globally.
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include "src/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-type.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/register-configuration.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-#if V8_TARGET_ARCH_ARM64
-// TODO(titzer): fix native stack parameters on arm64
-#define DISABLE_NATIVE_STACK_PARAMS true
-#else
-#define DISABLE_NATIVE_STACK_PARAMS false
-#endif
-
 namespace {
 typedef float float32;
 typedef double float64;
 
 // Picks a representative pair of integers from the given range.
 // If there are less than {max_pairs} possible pairs, do them all, otherwise try
 // to select a representative set.
 class Pairs {
  public:
   Pairs(int max_pairs, int range, const int* codes)
@@ skipping 173 matching lines @@
     return new (zone) CallDescriptor(       // --
         CallDescriptor::kCallCodeObject,    // kind
         target_type,                        // target MachineType
         target_loc,                         // target location
         msig,                               // machine_sig
         locations.Build(),                  // location_sig
         stack_param_count,                  // stack_parameter_count
         compiler::Operator::kNoProperties,  // properties
         kCalleeSaveRegisters,               // callee-saved registers
         kCalleeSaveFPRegisters,             // callee-saved fp regs
-        CallDescriptor::kNoFlags,           // flags
+        CallDescriptor::kUseNativeStack,    // flags
         "c-call");
   }
 
  private:
   Allocator& params;
   Allocator& rets;
 };
 
 const int kMaxParamCount = 64;
 
@@ skipping 317 matching lines @@
       int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) -
                                               static_cast<uint32_t>(*j));
       int32_t result = runnable.Call(*i, *j);
       CHECK_EQ(expected, result);
     }
   }
 }
 
 
 static void CopyTwentyInt32(CallDescriptor* desc) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
-
   const int kNumParams = 20;
   int32_t input[kNumParams];
   int32_t output[kNumParams];
   Isolate* isolate = CcTest::InitIsolateOnce();
   HandleScope scope(isolate);
   Handle<Code> inner = Handle<Code>::null();
   {
     // Writes all parameters into the output buffer.
     Zone zone;
     Graph graph(&zone);
@@ skipping 91 matching lines @@
 TEST_INT32_SUB_WITH_RET(13)
 TEST_INT32_SUB_WITH_RET(14)
 TEST_INT32_SUB_WITH_RET(15)
 TEST_INT32_SUB_WITH_RET(16)
 TEST_INT32_SUB_WITH_RET(17)
 TEST_INT32_SUB_WITH_RET(18)
 TEST_INT32_SUB_WITH_RET(19)
 
 
 TEST(Run_Int32Sub_all_allocatable_single) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   Int32Signature sig(2);
   RegisterPairs pairs;
   while (pairs.More()) {
     Zone zone;
     int parray[1];
     int rarray[1];
     pairs.Next(&rarray[0], &parray[0], true);
     Allocator params(parray, 1, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
     CallDescriptor* desc = config.Create(&zone, &sig);
     TestInt32Sub(desc);
   }
 }
 
 
 TEST(Run_CopyTwentyInt32_all_allocatable_pairs) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   Int32Signature sig(20);
   RegisterPairs pairs;
   while (pairs.More()) {
     Zone zone;
     int parray[2];
     int rarray[] = {
         RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
             ->GetAllocatableGeneralCode(0)};
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
@@ skipping 32 matching lines @@
 static int32_t Compute_Int32_WeightedSum(CallDescriptor* desc, int32_t* input) {
   uint32_t result = 0;
   for (int i = 0; i < ParamCount(desc); i++) {
     result += static_cast<uint32_t>(input[i]) * coeff[i];
   }
   return static_cast<int32_t>(result);
 }
 
 
 static void Test_Int32_WeightedSum_of_size(int count) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   Int32Signature sig(count);
   for (int p0 = 0; p0 < Register::kNumRegisters; p0++) {
     if (Register::from_code(p0).IsAllocatable()) {
       Zone zone;
 
       int parray[] = {p0};
       int rarray[] = {
           RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
               ->GetAllocatableGeneralCode(0)};
       Allocator params(parray, 1, nullptr, 0);
@@ skipping 41 matching lines @@
   int count = ParamCount(desc);
   if (count <= which) return;
   Run_Computation<CType>(desc, Build_Select<which>,
                          Compute_Select<CType, which>,
                          1044 + which + 3 * sizeof(CType));
 }
 
 
 template <int which>
 void Test_Int32_Select() {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
-
   int parray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableGeneralCode(0)};
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableGeneralCode(0)};
   Allocator params(parray, 1, nullptr, 0);
   Allocator rets(rarray, 1, nullptr, 0);
   RegisterConfig config(params, rets);
 
@@ skipping 103 matching lines @@
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float64, 0>(desc);
     RunSelect<float64, 1>(desc);
   }
 }
 
 
 TEST(Float32Select_stack_params_return_reg) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
   RegisterConfig config(params, rets);
 
   Zone zone;
   for (int count = 1; count < 6; count++) {
     ArgsBuffer<float32>::Sig sig(count);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float32, 0>(desc);
     RunSelect<float32, 1>(desc);
     RunSelect<float32, 2>(desc);
     RunSelect<float32, 3>(desc);
     RunSelect<float32, 4>(desc);
     RunSelect<float32, 5>(desc);
   }
 }
 
 
 TEST(Float64Select_stack_params_return_reg) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
   RegisterConfig config(params, rets);
 
   Zone zone;
   for (int count = 1; count < 6; count++) {
     ArgsBuffer<float64>::Sig sig(count);
@@ skipping 34 matching lines @@
       args[i] = raw.Parameter(i);
     }
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
   }
 }
 
 
 TEST(Float64StackParamsToStackParams) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
-
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
 
   Zone zone;
   ArgsBuffer<float64>::Sig sig(2);
   RegisterConfig config(params, rets);
   CallDescriptor* desc = config.Create(&zone, &sig);
 
   Run_Computation<float64>(desc, Build_Select_With_Call<float64, 0>,
                            Compute_Select<float64, 0>, 1098);
 
   Run_Computation<float64>(desc, Build_Select_With_Call<float64, 1>,
                            Compute_Select<float64, 1>, 1099);
 }
 
 
 void MixedParamTest(int start) {
-  if (DISABLE_NATIVE_STACK_PARAMS) return;
   if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->num_double_registers() < 2)
     return;
 
 // TODO(titzer): mix in 64-bit types on all platforms when supported.
 #if V8_TARGET_ARCH_32_BIT
   static MachineType types[] = {
       kMachInt32,   kMachFloat32, kMachFloat64, kMachInt32,   kMachFloat64,
       kMachFloat32, kMachFloat32, kMachFloat64, kMachInt32,   kMachFloat32,
       kMachInt32,   kMachFloat64, kMachFloat64, kMachFloat32, kMachInt32,
       kMachFloat64, kMachInt32,   kMachFloat32};
 #else
   static MachineType types[] = {
       kMachInt32,   kMachInt64,   kMachFloat32, kMachFloat64, kMachInt32,
-      kMachFloat64, kMachFloat32, kMachInt64,   kMachFloat64, kMachInt32,
+      kMachFloat64, kMachFloat32, kMachInt64,   kMachInt64,   kMachFloat32,
       kMachFloat32, kMachInt32,   kMachFloat64, kMachFloat64, kMachInt64,
       kMachInt32,   kMachFloat64, kMachInt32,   kMachFloat32};
 #endif
 
   Isolate* isolate = CcTest::InitIsolateOnce();
 
   // Build machine signature
   MachineType* params = &types[start];
   const int num_params = static_cast<int>(arraysize(types) - start);
 
@@ skipping 103 matching lines @@
 
 
 TEST(MixedParams_0) { MixedParamTest(0); }
 TEST(MixedParams_1) { MixedParamTest(1); }
 TEST(MixedParams_2) { MixedParamTest(2); }
 TEST(MixedParams_3) { MixedParamTest(3); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8