MIPS: Make all registers addressable in Operands.

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.
 
 #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"
@@ skipping 671 matching lines @@
 }
 
 
 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[] = {0};
+    int rarray[] = {
+        RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
     CallDescriptor* desc = config.Create(&zone, &sig);
     CopyTwentyInt32(desc);
   }
 }
 
 
@@ skipping 31 matching lines @@
 
 
 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[] = {0};
+      int rarray[] = {
+          RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
       Allocator params(parray, 1, nullptr, 0);
       Allocator rets(rarray, 1, nullptr, 0);
       RegisterConfig config(params, rets);
       CallDescriptor* desc = config.Create(&zone, &sig);
       Run_Computation<int32_t>(desc, Build_Int32_WeightedSum,
                                Compute_Int32_WeightedSum, 257 + count);
     }
   }
 }
 
@@ skipping 34 matching lines @@
   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[] = {0};
-  int rarray[] = {0};
+  int parray[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
   Allocator params(parray, 1, nullptr, 0);
   Allocator rets(rarray, 1, nullptr, 0);
   RegisterConfig config(params, rets);
 
   Zone zone;
 
   for (int i = which + 1; i <= 64; i++) {
     Int32Signature sig(i);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<int32_t, which>(desc);
@@ skipping 20 matching lines @@
 TEST_INT32_SELECT(62)
 TEST_INT32_SELECT(63)
 
 
 TEST(Int64Select_registers) {
   if (RegisterConfiguration::ArchDefault()
           ->num_allocatable_general_registers() < 2)
     return;
   if (kPointerSize < 8) return;  // TODO(titzer): int64 on 32-bit platforms
 
-  int rarray[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
   ArgsBuffer<int64_t>::Sig sig(2);
 
   RegisterPairs pairs;
   Zone zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<int64_t, 0>(desc);
     RunSelect<int64_t, 1>(desc);
   }
 }
 
 
 TEST(Float32Select_registers) {
   if (RegisterConfiguration::ArchDefault()->num_allocatable_double_registers() <
       2) {
     return;
   }
 
-  int rarray[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableDoubleCode(0)};
   ArgsBuffer<float32>::Sig sig(2);
 
   Float32RegisterPairs pairs;
   Zone zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(nullptr, 0, parray, 2);
     Allocator rets(nullptr, 0, rarray, 1);
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float32, 0>(desc);
     RunSelect<float32, 1>(desc);
   }
 }
 
 
 TEST(Float64Select_registers) {
   if (RegisterConfiguration::ArchDefault()->num_allocatable_double_registers() <
       2)
     return;
   if (RegisterConfiguration::ArchDefault()
           ->num_allocatable_general_registers() < 2)
     return;
-  int rarray[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableDoubleCode(0)};
   ArgsBuffer<float64>::Sig sig(2);
 
   Float64RegisterPairs pairs;
   Zone zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(nullptr, 0, parray, 2);
     Allocator rets(nullptr, 0, rarray, 1);
     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[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->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[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->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);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float64, 0>(desc);
     RunSelect<float64, 1>(desc);
@@ skipping 33 matching lines @@
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
   }
 }
 
 
 TEST(Float64StackParamsToStackParams) {
   if (DISABLE_NATIVE_STACK_PARAMS) return;
 
-  int rarray[] = {0};
+  int rarray[] = {
+      RegisterConfiguration::ArchDefault()->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);
@@ skipping 22 matching lines @@
       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);
 
   // Build call descriptor
-  int parray[] = {0, 1};
-  int rarray[] = {0};
-  Allocator palloc(parray, 2, parray, 2);
-  Allocator ralloc(rarray, 1, rarray, 1);
+  int parray_gp[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0),
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(1)};
+  int rarray_gp[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableGeneralCode(0)};
+  int parray_fp[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableDoubleCode(0),
+      RegisterConfiguration::ArchDefault()->GetAllocatableDoubleCode(1)};
+  int rarray_fp[] = {
+      RegisterConfiguration::ArchDefault()->GetAllocatableDoubleCode(0)};
+  Allocator palloc(parray_gp, 2, parray_fp, 2);
+  Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
   RegisterConfig config(palloc, ralloc);
 
   for (int which = 0; which < num_params; which++) {
     Zone zone;
     HandleScope scope(isolate);
     MachineSignature::Builder builder(&zone, 1, num_params);
     builder.AddReturn(params[which]);
     for (int j = 0; j < num_params; j++) builder.AddParam(params[j]);
     MachineSignature* sig = builder.Build();
     CallDescriptor* desc = config.Create(&zone, sig);
@@ skipping 70 matching lines @@
       }
     }
   }
 }
 
 
 TEST(MixedParams_0) { MixedParamTest(0); }
 TEST(MixedParams_1) { MixedParamTest(1); }
 TEST(MixedParams_2) { MixedParamTest(2); }
 TEST(MixedParams_3) { MixedParamTest(3); }