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

src/s390/simulator-s390.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_S390
 
@@ skipping 1916 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 = 5;
       int arg0_regnum = 2;
       intptr_t result_buffer = 0;
       bool uses_result_buffer =
           redirection->type() == ExternalReference::BUILTIN_CALL_TRIPLE ||
           (redirection->type() == ExternalReference::BUILTIN_CALL_PAIR &&
            !ABI_RETURNS_OBJECTPAIR_IN_REGS);
       if (uses_result_buffer) {
         result_buffer = get_register(r2);
         arg0_regnum++;
       }
       intptr_t arg[kArgCount];
-      for (int i = 0; i < kArgCount - 1; i++) {
+      // First 5 arguments in registers r2-r6.
+      for (int i = 0; i < kRegisterArgCount; i++) {
         arg[i] = get_register(arg0_regnum + i);
       }
+      // Remaining arguments on stack
       intptr_t* stack_pointer = reinterpret_cast<intptr_t*>(get_register(sp));
-      arg[5] = stack_pointer[kCalleeRegisterSaveAreaSize / kPointerSize];
+      for (int i = kRegisterArgCount; i < kArgCount; i++) {
+        arg[i] = stack_pointer[(kCalleeRegisterSaveAreaSize / kPointerSize) +
+                               (i - kRegisterArgCount)];
+      }
+      STATIC_ASSERT(kArgCount == kRegisterArgCount + 4);
+      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);
 
       // Place the return address on the stack, making the call GC safe.
       *reinterpret_cast<intptr_t*>(get_register(sp) +
                                    kStackFrameRASlot * kPointerSize) =
           get_register(r14);
@@ skipping 157 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]);
+              arg[3], arg[4], arg[5], arg[6], arg[7], arg[8]);
           if (!stack_aligned) {
             PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
                    static_cast<intptr_t>(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(r3, y);
             } else {
               memcpy(reinterpret_cast<void*>(result_buffer), &result,
                      sizeof(ObjectPair));
               set_register(r2, 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(r2, result);
           }
         }
         // #if !V8_TARGET_ARCH_S390X
         //         DCHECK(redirection->type() ==
         //         ExternalReference::BUILTIN_CALL);
         //         SimulatorRuntimeCall target =
@@ skipping 7616 matching lines @@
   return 0;
 }
 
 #undef EVALUATE
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_S390