PPC/s390: [sim] Consistent support for C calls with up to 9 args

src/ppc/simulator-ppc.cc

 // Copyright 2014 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 <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #if V8_TARGET_ARCH_PPC
 
@@ skipping 1274 matching lines @@
 #else
   *x = static_cast<int32_t>(*pair);
   *y = static_cast<int32_t>(*pair >> 32);
 #endif
 }
 #endif
 
 // Calls into the V8 runtime.
 typedef intptr_t (*SimulatorRuntimeCall)(intptr_t arg0, intptr_t arg1,
                                          intptr_t arg2, intptr_t arg3,
-                                         intptr_t arg4, intptr_t arg5);
+                                         intptr_t arg4, intptr_t arg5,
+                                         intptr_t arg6, intptr_t arg7,
+                                         intptr_t arg8);
 typedef ObjectPair (*SimulatorRuntimePairCall)(intptr_t arg0, intptr_t arg1,
                                                intptr_t arg2, intptr_t arg3,
                                                intptr_t arg4, intptr_t arg5);
 typedef ObjectTriple (*SimulatorRuntimeTripleCall)(intptr_t arg0, intptr_t arg1,
                                                    intptr_t arg2, intptr_t arg3,
                                                    intptr_t arg4,
                                                    intptr_t arg5);
 
 // These prototypes handle the four types of FP calls.
 typedef int (*SimulatorRuntimeCompareCall)(double darg0, double darg1);
@@ skipping 16 matching lines @@
 void Simulator::SoftwareInterrupt(Instruction* instr) {
   int svc = instr->SvcValue();
   switch (svc) {
     case kCallRtRedirected: {
       // Check if stack is aligned. Error if not aligned is reported below to
       // include information on the function called.
       bool stack_aligned =
           (get_register(sp) & (::v8::internal::FLAG_sim_stack_alignment - 1)) ==
           0;
       Redirection* redirection = Redirection::FromSwiInstruction(instr);
-      const int kArgCount = 6;
+      const int kArgCount = 9;
+      const int kRegisterArgCount = 8;
       int arg0_regnum = 3;
       intptr_t result_buffer = 0;
       bool uses_result_buffer =
           redirection->type() == ExternalReference::BUILTIN_CALL_TRIPLE ||
           (redirection->type() == ExternalReference::BUILTIN_CALL_PAIR &&
            !ABI_RETURNS_OBJECT_PAIRS_IN_REGS);
       if (uses_result_buffer) {
         result_buffer = get_register(r3);
         arg0_regnum++;
       }
       intptr_t arg[kArgCount];
-      for (int i = 0; i < kArgCount; i++) {
+      // First eight arguments in registers r3-r10.
+      for (int i = 0; i < kRegisterArgCount; i++) {
         arg[i] = get_register(arg0_regnum + i);
       }
+      intptr_t* stack_pointer = reinterpret_cast<intptr_t*>(get_register(sp));
+      // Remaining argument on stack
+      arg[kRegisterArgCount] = stack_pointer[kStackFrameExtraParamSlot];
+      STATIC_ASSERT(kArgCount == kRegisterArgCount + 1);
+      STATIC_ASSERT(kMaxCParameters == 9);
       bool fp_call =
           (redirection->type() == ExternalReference::BUILTIN_FP_FP_CALL) ||
           (redirection->type() == ExternalReference::BUILTIN_COMPARE_CALL) ||
           (redirection->type() == ExternalReference::BUILTIN_FP_CALL) ||
           (redirection->type() == ExternalReference::BUILTIN_FP_INT_CALL);
       // This is dodgy but it works because the C entry stubs are never moved.
       // See comment in codegen-arm.cc and bug 1242173.
       intptr_t saved_lr = special_reg_lr_;
       intptr_t external =
           reinterpret_cast<intptr_t>(redirection->external_function());
@@ skipping 155 matching lines @@
         }
         target(arg[0], arg[1], Redirection::ReverseRedirection(arg[2]));
       } else {
         // builtin call.
         if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
           SimulatorRuntimeCall target =
               reinterpret_cast<SimulatorRuntimeCall>(external);
           PrintF(
               "Call to host function at %p,\n"
               "\t\t\t\targs %08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR
+              ", %08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR
               ", %08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR,
-              static_cast<void*>(FUNCTION_ADDR(target)), arg[0], arg[1],
-              arg[2], arg[3], arg[4], arg[5]);
+              static_cast<void*>(FUNCTION_ADDR(target)), arg[0], arg[1], arg[2],
+              arg[3], arg[4], arg[5], arg[6], arg[7], arg[8]);
           if (!stack_aligned) {
             PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
                    get_register(sp));
           }
           PrintF("\n");
         }
         CHECK(stack_aligned);
         if (redirection->type() == ExternalReference::BUILTIN_CALL_TRIPLE) {
           SimulatorRuntimeTripleCall target =
               reinterpret_cast<SimulatorRuntimeTripleCall>(external);
@@ skipping 26 matching lines @@
               set_register(r4, y);
             } else {
               memcpy(reinterpret_cast<void*>(result_buffer), &result,
                      sizeof(ObjectPair));
               set_register(r3, result_buffer);
             }
           } else {
             DCHECK(redirection->type() == ExternalReference::BUILTIN_CALL);
             SimulatorRuntimeCall target =
                 reinterpret_cast<SimulatorRuntimeCall>(external);
-            intptr_t result =
-                target(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
+            intptr_t result = target(arg[0], arg[1], arg[2], arg[3], arg[4],
+                                     arg[5], arg[6], arg[7], arg[8]);
             if (::v8::internal::FLAG_trace_sim) {
               PrintF("Returned %08" V8PRIxPTR "\n", result);
             }
             set_register(r3, result);
           }
         }
       }
       set_pc(saved_lr);
       break;
     }
@@ skipping 2837 matching lines @@
   }
   processor->prev_ = nullptr;
   processor->next_ = nullptr;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_PPC