A64: Abstract simulation of runtime calls in a separate function.

src/a64/simulator-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 451 matching lines @@
     Isolate* isolate = Isolate::Current();
     next_ = isolate->simulator_redirection();
     // TODO(all): Simulator flush I cache
     isolate->set_simulator_redirection(this);
   }
 
   void* address_of_redirect_call() {
     return reinterpret_cast<void*>(&redirect_call_);
   }
 
-  void* external_function() { return external_function_; }
+  template <typename T>
+    T external_function() { return reinterpret_cast<T>(external_function_); }

[ulan, 2014/03/19 08:53:19]

Indentation is off

[Alexandre Rames, 2014/03/20 09:49:33]

Fixing before landing.

   ExternalReference::Type type() { return type_; }
 
   static Redirection* Get(void* external_function,
                           ExternalReference::Type type) {
     Isolate* isolate = Isolate::Current();
     Redirection* current = isolate->simulator_redirection();
     for (; current != NULL; current = current->next_) {
       if (current->external_function_ == external_function) {
         ASSERT_EQ(current->type(), type);
         return current;
       }
     }
     return new Redirection(external_function, type);
   }
 
   static Redirection* FromHltInstruction(Instruction* redirect_call) {
     char* addr_of_hlt = reinterpret_cast<char*>(redirect_call);
     char* addr_of_redirection =
         addr_of_hlt - OFFSET_OF(Redirection, redirect_call_);
     return reinterpret_cast<Redirection*>(addr_of_redirection);
   }
 
   static void* ReverseRedirection(int64_t reg) {
     Redirection* redirection =
         FromHltInstruction(reinterpret_cast<Instruction*>(reg));
-    return redirection->external_function();
+    return redirection->external_function<void*>();
   }
 
  private:
   void* external_function_;
   Instruction redirect_call_;
   ExternalReference::Type type_;
   Redirection* next_;
 };
 
 
+// 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.
+struct ObjectPair {
+  int64_t res0;
+  int64_t res1;
+};
+
+
+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 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);
+
+// This signature supports direct call in to API function native callback
+// (refer to InvocationCallback in v8.h).
+typedef void (*SimulatorRuntimeDirectApiCall)(int64_t arg0);
+typedef void (*SimulatorRuntimeProfilingApiCall)(int64_t arg0, void* arg1);
+
+// This signature supports direct call to accessor getter callback.
+typedef void (*SimulatorRuntimeDirectGetterCall)(int64_t arg0, int64_t arg1);
+typedef void (*SimulatorRuntimeProfilingGetterCall)(int64_t arg0, int64_t arg1,
+                                                    void* arg2);
+
+void Simulator::DoRuntimeCall(Instruction* instr) {
+  Redirection* redirection = Redirection::FromHltInstruction(instr);
+
+  // The called C code might itself call simulated code, so any
+  // caller-saved registers (including lr) could still be clobbered by a
+  // redirected call.
+  Instruction* return_address = lr();
+
+  int64_t external = redirection->external_function<int64_t>();
+
+  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");
+  }
+
+  switch (redirection->type()) {
+    default:
+      TraceSim("Type: Unknown.\n");
+      UNREACHABLE();
+      break;
+
+    case ExternalReference::BUILTIN_CALL: {
+      // MaybeObject* 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("Returned: {0x%" PRIx64 ", 0x%" PRIx64 "}\n",
+               result.res0, result.res1);
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      set_xreg(0, result.res0);
+      set_xreg(1, result.res1);
+      break;
+    }
+
+    case ExternalReference::DIRECT_API_CALL: {
+      // void f(v8::FunctionCallbackInfo&)
+      TraceSim("Type: DIRECT_API_CALL\n");
+      SimulatorRuntimeDirectApiCall target =
+        reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
+      TraceSim("Arguments: 0x%016" PRIx64 "\n", xreg(0));
+      target(xreg(0));
+      TraceSim("No return value.");
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      break;
+    }
+
+    case ExternalReference::BUILTIN_COMPARE_CALL: {
+      // int f(double, double)
+      TraceSim("Type: BUILTIN_COMPARE_CALL\n");
+      SimulatorRuntimeCompareCall target =
+        reinterpret_cast<SimulatorRuntimeCompareCall>(external);
+      TraceSim("Arguments: %f, %f\n", dreg(0), dreg(1));
+      int64_t result = target(dreg(0), dreg(1));
+      TraceSim("Returned: %" PRId64 "\n", result);
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      set_xreg(0, result);
+      break;
+    }
+
+    case ExternalReference::BUILTIN_FP_CALL: {
+      // double f(double)
+      TraceSim("Type: BUILTIN_FP_CALL\n");
+      SimulatorRuntimeFPCall target =
+        reinterpret_cast<SimulatorRuntimeFPCall>(external);
+      TraceSim("Argument: %f\n", dreg(0));
+      double result = target(dreg(0));
+      TraceSim("Returned: %f\n", result);
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      set_dreg(0, result);
+      break;
+    }
+
+    case ExternalReference::BUILTIN_FP_FP_CALL: {
+      // double f(double, double)
+      TraceSim("Type: BUILTIN_FP_FP_CALL\n");
+      SimulatorRuntimeFPFPCall target =
+        reinterpret_cast<SimulatorRuntimeFPFPCall>(external);
+      TraceSim("Arguments: %f, %f\n", dreg(0), dreg(1));
+      double result = target(dreg(0), dreg(1));
+      TraceSim("Returned: %f\n", result);
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      set_dreg(0, result);
+      break;
+    }
+
+    case ExternalReference::BUILTIN_FP_INT_CALL: {
+      // double f(double, int)
+      TraceSim("Type: BUILTIN_FP_INT_CALL\n");
+      SimulatorRuntimeFPIntCall target =
+        reinterpret_cast<SimulatorRuntimeFPIntCall>(external);
+      TraceSim("Arguments: %f, %d\n", dreg(0), wreg(0));
+      double result = target(dreg(0), wreg(0));
+      TraceSim("Returned: %f\n", result);
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      set_dreg(0, result);
+      break;
+    }
+
+    case ExternalReference::DIRECT_GETTER_CALL: {
+      // void f(Local<String> property, PropertyCallbackInfo& info)
+      TraceSim("Type: DIRECT_GETTER_CALL\n");
+      SimulatorRuntimeDirectGetterCall target =
+        reinterpret_cast<SimulatorRuntimeDirectGetterCall>(external);
+      TraceSim("Arguments: 0x%016" PRIx64 ", 0x%016" PRIx64 "\n",
+               xreg(0), xreg(1));
+      target(xreg(0), xreg(1));
+      TraceSim("No return value.");
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      break;
+    }
+
+    case ExternalReference::PROFILING_API_CALL: {
+      // void f(v8::FunctionCallbackInfo&, v8::FunctionCallback)
+      TraceSim("Type: PROFILING_API_CALL\n");
+      SimulatorRuntimeProfilingApiCall target =
+        reinterpret_cast<SimulatorRuntimeProfilingApiCall>(external);
+      void* arg1 = Redirection::ReverseRedirection(xreg(1));
+      TraceSim("Arguments: 0x%016" PRIx64 ", %p\n", xreg(0), arg1);
+      target(xreg(0), arg1);
+      TraceSim("No return value.");
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      break;
+    }
+
+    case ExternalReference::PROFILING_GETTER_CALL: {
+      // void f(Local<String> property, PropertyCallbackInfo& info,
+      //        AccessorGetterCallback callback)
+      TraceSim("Type: PROFILING_GETTER_CALL\n");
+      SimulatorRuntimeProfilingGetterCall target =
+        reinterpret_cast<SimulatorRuntimeProfilingGetterCall>(
+            external);
+      void* arg2 = Redirection::ReverseRedirection(xreg(2));
+      TraceSim("Arguments: 0x%016" PRIx64 ", 0x%016" PRIx64 ", %p\n",
+               xreg(0), xreg(1), arg2);
+      target(xreg(0), xreg(1), arg2);
+      TraceSim("No return value.");
+#ifdef DEBUG
+      CorruptAllCallerSavedCPURegisters();
+#endif
+      break;
+    }
+  }
+
+  set_lr(return_address);
+  set_pc(return_address);
+}
+
+
 void* Simulator::RedirectExternalReference(void* external_function,
                                            ExternalReference::Type type) {
   Redirection* redirection = Redirection::Get(external_function, type);
   return redirection->address_of_redirect_call();
 }
 
 
 const char* Simulator::xreg_names[] = {
 "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
@@ skipping 2773 matching lines @@
         PrintF("Use 'help' for more information.\n");
       }
     }
     if (cleared_log_disasm_bit == true) {
       set_log_parameters(log_parameters_ | LOG_DISASM);
     }
   }
 }
 
 
-// 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.
-struct ObjectPair {
-  int64_t res0;
-  int64_t res1;
-};
-
-
-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 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);
-
-// This signature supports direct call in to API function native callback
-// (refer to InvocationCallback in v8.h).
-typedef void (*SimulatorRuntimeDirectApiCall)(int64_t arg0);
-typedef void (*SimulatorRuntimeProfilingApiCall)(int64_t arg0, void* arg1);
-
-// This signature supports direct call to accessor getter callback.
-typedef void (*SimulatorRuntimeDirectGetterCall)(int64_t arg0, int64_t arg1);
-typedef void (*SimulatorRuntimeProfilingGetterCall)(int64_t arg0, int64_t arg1,
-                                                    void* arg2);
-
 void Simulator::VisitException(Instruction* instr) {
   // Define some colour codes to use for log messages.
   // TODO(jbramley): Find a more elegant way of defining these.
   char const* const clr_normal        = (FLAG_log_colour) ? ("\033[m")
                                                           : ("");
   char const* const clr_debug_number  = (FLAG_log_colour) ? ("\033[1;33m")
                                                           : ("");
   char const* const clr_debug_message = (FLAG_log_colour) ? ("\033[0;33m")
                                                           : ("");
   char const* const clr_printf        = (FLAG_log_colour) ? ("\033[0;32m")
@@ skipping 67 matching lines @@
         //  - Verify that the unreachable marker is present.
         ASSERT(pc_->Mask(ExceptionMask) == HLT);
         ASSERT(pc_->ImmException() ==  kImmExceptionIsUnreachable);
         //  - Skip past the unreachable marker.
         set_pc(pc_->following());
 
         // Check if the debugger should break.
         if (parameters & BREAK) Debug();
 
       } else if (instr->ImmException() == kImmExceptionIsRedirectedCall) {
-        // TODO(all): Extract the call redirection code into a separate
-        // function.
-
-        Redirection* redirection = Redirection::FromHltInstruction(instr);
-
-        // The called C code might itself call simulated code, so any
-        // caller-saved registers (including lr) could still be clobbered by a
-        // redirected call.
-        Instruction* return_address = lr();
-
-        // TODO(jbramley): Make external_function() a template so that we don't
-        // have to explicitly cast the result for each redirection type.
-        int64_t external =
-            reinterpret_cast<int64_t>(redirection->external_function());
-
-        TraceSim("Call to host function at %p\n",
-                 reinterpret_cast<void*>(redirection->external_function()));
-
-        // SP must be 16 bytes 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");
-        }
-
-        switch (redirection->type()) {
-          default:
-            TraceSim("Type: Unknown.\n");
-            UNREACHABLE();
-            break;
-
-          case ExternalReference::BUILTIN_CALL: {
-            // MaybeObject* 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("Returned: {0x%" PRIx64 ", 0x%" PRIx64"}\n",
-                     result.res0, result.res1);
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            set_xreg(0, result.res0);
-            set_xreg(1, result.res1);
-            break;
-          }
-
-          case ExternalReference::DIRECT_API_CALL: {
-            // void f(v8::FunctionCallbackInfo&)
-            TraceSim("Type: DIRECT_API_CALL\n");
-            SimulatorRuntimeDirectApiCall target =
-                reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
-            TraceSim("Arguments: 0x%016" PRIx64 "\n", xreg(0));
-            target(xreg(0));
-            TraceSim("No return value.");
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            break;
-          }
-
-          case ExternalReference::BUILTIN_COMPARE_CALL: {
-            // int f(double, double)
-            TraceSim("Type: BUILTIN_COMPARE_CALL\n");
-            SimulatorRuntimeCompareCall target =
-                reinterpret_cast<SimulatorRuntimeCompareCall>(external);
-            TraceSim("Arguments: %f, %f\n", dreg(0), dreg(1));
-            int64_t result = target(dreg(0), dreg(1));
-            TraceSim("Returned: %" PRId64 "\n", result);
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            set_xreg(0, result);
-            break;
-          }
-
-          case ExternalReference::BUILTIN_FP_CALL: {
-            // double f(double)
-            TraceSim("Type: BUILTIN_FP_CALL\n");
-            SimulatorRuntimeFPCall target =
-                reinterpret_cast<SimulatorRuntimeFPCall>(external);
-            TraceSim("Argument: %f\n", dreg(0));
-            double result = target(dreg(0));
-            TraceSim("Returned: %f\n", result);
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            set_dreg(0, result);
-            break;
-          }
-
-          case ExternalReference::BUILTIN_FP_FP_CALL: {
-            // double f(double, double)
-            TraceSim("Type: BUILTIN_FP_FP_CALL\n");
-            SimulatorRuntimeFPFPCall target =
-                reinterpret_cast<SimulatorRuntimeFPFPCall>(external);
-            TraceSim("Arguments: %f, %f\n", dreg(0), dreg(1));
-            double result = target(dreg(0), dreg(1));
-            TraceSim("Returned: %f\n", result);
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            set_dreg(0, result);
-            break;
-          }
-
-          case ExternalReference::BUILTIN_FP_INT_CALL: {
-            // double f(double, int)
-            TraceSim("Type: BUILTIN_FP_INT_CALL\n");
-            SimulatorRuntimeFPIntCall target =
-                reinterpret_cast<SimulatorRuntimeFPIntCall>(external);
-            TraceSim("Arguments: %f, %d\n", dreg(0), wreg(0));
-            double result = target(dreg(0), wreg(0));
-            TraceSim("Returned: %f\n", result);
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            set_dreg(0, result);
-            break;
-          }
-
-          case ExternalReference::DIRECT_GETTER_CALL: {
-            // void f(Local<String> property, PropertyCallbackInfo& info)
-            TraceSim("Type: DIRECT_GETTER_CALL\n");
-            SimulatorRuntimeDirectGetterCall target =
-                reinterpret_cast<SimulatorRuntimeDirectGetterCall>(external);
-            TraceSim("Arguments: 0x%016" PRIx64 ", 0x%016" PRIx64 "\n",
-                     xreg(0), xreg(1));
-            target(xreg(0), xreg(1));
-            TraceSim("No return value.");
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            break;
-          }
-
-          case ExternalReference::PROFILING_API_CALL: {
-            // void f(v8::FunctionCallbackInfo&, v8::FunctionCallback)
-            TraceSim("Type: PROFILING_API_CALL\n");
-            SimulatorRuntimeProfilingApiCall target =
-                reinterpret_cast<SimulatorRuntimeProfilingApiCall>(external);
-            void* arg1 = Redirection::ReverseRedirection(xreg(1));
-            TraceSim("Arguments: 0x%016" PRIx64 ", %p\n", xreg(0), arg1);
-            target(xreg(0), arg1);
-            TraceSim("No return value.");
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            break;
-          }
-
-          case ExternalReference::PROFILING_GETTER_CALL: {
-            // void f(Local<String> property, PropertyCallbackInfo& info,
-            //        AccessorGetterCallback callback)
-            TraceSim("Type: PROFILING_GETTER_CALL\n");
-            SimulatorRuntimeProfilingGetterCall target =
-                reinterpret_cast<SimulatorRuntimeProfilingGetterCall>(
-                    external);
-            void* arg2 = Redirection::ReverseRedirection(xreg(2));
-            TraceSim("Arguments: 0x%016" PRIx64 ", 0x%016" PRIx64 ", %p\n",
-                     xreg(0), xreg(1), arg2);
-            target(xreg(0), xreg(1), arg2);
-            TraceSim("No return value.");
-#ifdef DEBUG
-            CorruptAllCallerSavedCPURegisters();
-#endif
-            break;
-          }
-        }
-
-        set_lr(return_address);
-        set_pc(return_address);
+        DoRuntimeCall(instr);
       } else if (instr->ImmException() == kImmExceptionIsPrintf) {
         // Read the argument encoded inline in the instruction stream.
         uint32_t type;
         memcpy(&type,
                pc_->InstructionAtOffset(kPrintfTypeOffset),
                sizeof(type));
 
         const char* format = reg<const char*>(0);
 
         // Pass all of the relevant PCS registers onto printf. It doesn't
@@ skipping 37 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64