[sim] Consistent support for C calls with up to 9 args

src/arm64/simulator-arm64.cc

 // Copyright 2013 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 <stdlib.h>
 #include <cmath>
 #include <cstdarg>
 
 #if V8_TARGET_ARCH_ARM64
 
@@ skipping 520 matching lines @@
                          Redirection* first) {
   Redirection::DeleteChain(first);
 }
 
 
 // Calls into the V8 runtime are based on this very simple interface.
 // Note: To be able to return two values from some calls the code in runtime.cc
 // uses the ObjectPair structure.
 // The simulator assumes all runtime calls return two 64-bits values. If they
 // don't, register x1 is clobbered. This is fine because x1 is caller-saved.
-typedef ObjectPair (*SimulatorRuntimeCall)(int64_t arg0,
-                                           int64_t arg1,
-                                           int64_t arg2,
-                                           int64_t arg3,
-                                           int64_t arg4,
-                                           int64_t arg5,
-                                           int64_t arg6,
-                                           int64_t arg7);
+typedef ObjectPair (*SimulatorRuntimeCall)(int64_t arg0, int64_t arg1,
+                                           int64_t arg2, int64_t arg3,
+                                           int64_t arg4, int64_t arg5,
+                                           int64_t arg6, int64_t arg7,
+                                           int64_t arg8);
 
 typedef ObjectTriple (*SimulatorRuntimeTripleCall)(int64_t arg0, int64_t arg1,
                                                    int64_t arg2, int64_t arg3,
                                                    int64_t arg4, int64_t arg5,
                                                    int64_t arg6, int64_t arg7);
 
 typedef int64_t (*SimulatorRuntimeCompareCall)(double arg1, double arg2);
 typedef double (*SimulatorRuntimeFPFPCall)(double arg1, double arg2);
 typedef double (*SimulatorRuntimeFPCall)(double arg1);
 typedef double (*SimulatorRuntimeFPIntCall)(double arg1, int32_t arg2);
@@ skipping 21 matching lines @@
   TraceSim("Call to host function at %p\n",
            redirection->external_function<void*>());
 
   // SP must be 16-byte-aligned at the call interface.
   bool stack_alignment_exception = ((sp() & 0xf) != 0);
   if (stack_alignment_exception) {
     TraceSim("  with unaligned stack 0x%016" PRIx64 ".\n", sp());
     FATAL("ALIGNMENT EXCEPTION");
   }
 
+  int64_t* stack_pointer = reinterpret_cast<int64_t*>(sp());
+
+  const int64_t arg0 = xreg(0);
+  const int64_t arg1 = xreg(1);
+  const int64_t arg2 = xreg(2);
+  const int64_t arg3 = xreg(3);
+  const int64_t arg4 = xreg(4);
+  const int64_t arg5 = xreg(5);
+  const int64_t arg6 = xreg(6);
+  const int64_t arg7 = xreg(7);
+  const int64_t arg8 = stack_pointer[0];
+  STATIC_ASSERT(kMaxCParameters == 9);
+
   switch (redirection->type()) {
     default:
       TraceSim("Type: Unknown.\n");
       UNREACHABLE();
       break;
 
     case ExternalReference::BUILTIN_CALL:
     case ExternalReference::BUILTIN_CALL_PAIR: {
       // Object* f(v8::internal::Arguments) or
       // ObjectPair f(v8::internal::Arguments).
       TraceSim("Type: BUILTIN_CALL\n");
       SimulatorRuntimeCall target =
         reinterpret_cast<SimulatorRuntimeCall>(external);
 
       // We don't know how many arguments are being passed, but we can
       // pass 8 without touching the stack. They will be ignored by the
       // host function if they aren't used.
-      TraceSim("Arguments: "
-               "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
-               "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
-               "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
-               "0x%016" PRIx64 ", 0x%016" PRIx64,
-               xreg(0), xreg(1), xreg(2), xreg(3),
-               xreg(4), xreg(5), xreg(6), xreg(7));
-      ObjectPair result = target(xreg(0), xreg(1), xreg(2), xreg(3),
-                                 xreg(4), xreg(5), xreg(6), xreg(7));
+      TraceSim(
+          "Arguments: "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64,
+          arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+      ObjectPair result =
+          target(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
       TraceSim("Returned: {%p, %p}\n", static_cast<void*>(result.x),
                static_cast<void*>(result.y));
 #ifdef DEBUG
       CorruptAllCallerSavedCPURegisters();
 #endif
       set_xreg(0, reinterpret_cast<int64_t>(result.x));
       set_xreg(1, reinterpret_cast<int64_t>(result.y));
       break;
     }
 
     case ExternalReference::BUILTIN_CALL_TRIPLE: {
       // ObjectTriple f(v8::internal::Arguments).
       TraceSim("Type: BUILTIN_CALL TRIPLE\n");
       SimulatorRuntimeTripleCall target =
           reinterpret_cast<SimulatorRuntimeTripleCall>(external);
 
       // We don't know how many arguments are being passed, but we can
       // pass 8 without touching the stack. They will be ignored by the
       // host function if they aren't used.
       TraceSim(
           "Arguments: "
-          "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
-          "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
-          "0x%016" PRIx64 ", 0x%016" PRIx64 ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
+          "0x%016" PRIx64 ", 0x%016" PRIx64
+          ", "
           "0x%016" PRIx64 ", 0x%016" PRIx64,
-          xreg(0), xreg(1), xreg(2), xreg(3), xreg(4), xreg(5), xreg(6),
-          xreg(7));
+          arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
       // Return location passed in x8.
       ObjectTriple* sim_result = reinterpret_cast<ObjectTriple*>(xreg(8));
-      ObjectTriple result = target(xreg(0), xreg(1), xreg(2), xreg(3), xreg(4),
-                                   xreg(5), xreg(6), xreg(7));
+      ObjectTriple result =
+          target(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
       TraceSim("Returned: {%p, %p, %p}\n", static_cast<void*>(result.x),
                static_cast<void*>(result.y), static_cast<void*>(result.z));
 #ifdef DEBUG
       CorruptAllCallerSavedCPURegisters();
 #endif
       *sim_result = result;
       break;
     }
 
     case ExternalReference::DIRECT_API_CALL: {
@@ skipping 3528 matching lines @@
   processor->prev_ = nullptr;
   processor->next_ = nullptr;
 }
 
 #endif  // USE_SIMULATOR
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64