A64: Synchronize with r15204.

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 454 matching lines @@
   }
 
   void* external_function() { return external_function_; }
   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) return current;
+      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);
   }
@@ skipping 2516 matching lines @@
 
 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 v8::Handle<v8::Value> (*SimulatorRuntimeDirectApiCall)(int64_t arg0);
 typedef void (*SimulatorRuntimeDirectApiCallNew)(int64_t arg0);
+typedef v8::Handle<v8::Value> (*SimulatorRuntimeProfilingApiCall)(int64_t arg0,
+                                                                  int64_t arg1);
+typedef void (*SimulatorRuntimeProfilingApiCallNew)(int64_t arg0, int64_t arg1);
 
 // This signature supports direct call to accessor getter callback.
 typedef v8::Handle<v8::Value> (*SimulatorRuntimeDirectGetterCall)(int64_t arg0,
                                                                   int64_t arg1);
 typedef void (*SimulatorRuntimeDirectGetterCallNew)(int64_t arg0, int64_t arg1);
+typedef v8::Handle<v8::Value> (*SimulatorRuntimeProfilingGetterCall)(
+    int64_t arg0, int64_t arg1, int64_t arg2);
+typedef void (*SimulatorRuntimeProfilingGetterCallNew)(
+    int64_t arg0, int64_t arg1, int64_t 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")
                                                           : ("");
@@ skipping 95 matching lines @@
 
         // 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());
           ALIGNMENT_EXCEPTION();
         }
 
         switch (redirection->type()) {
           default:
-            TraceSim("  with unrecognized redirection type.");
+            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: {
+            // Handle<Value> f(v8::Arguments&)
+            TraceSim("Type: DIRECT_API_CALL\n");
+            SimulatorRuntimeDirectApiCall target =
+                reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
+            TraceSim("Arguments: 0x%016" PRIx64 "\n", xreg(0));
+            v8::Handle<v8::Value> result = target(xreg(0));
+            TraceSim("Returned %p\n", reinterpret_cast<void *>(*result));
+#ifdef DEBUG
+            CorruptAllCallerSavedCPURegisters();
+#endif
+            set_reg(0, *result);
+            break;
+          }
+
+          case ExternalReference::DIRECT_API_CALL_NEW: {
+            // void f(v8::Arguments&)
+            TraceSim("Type: DIRECT_API_CALL_NEW\n");
+            SimulatorRuntimeDirectApiCallNew target =
+                reinterpret_cast<SimulatorRuntimeDirectApiCallNew>(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_FP_CALL: {
-            // double f(double, double)
-            SimulatorRuntimeFPFPCall target =
-                reinterpret_cast<SimulatorRuntimeFPFPCall>(external);
-            TraceSim("Arguments: %f, %f\n", dreg(0), dreg(1));
-            double result = target(dreg(0), dreg(1));
+          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_CALL: {
-            // double f(double)
-            SimulatorRuntimeFPCall target =
-                reinterpret_cast<SimulatorRuntimeFPCall>(external);
-            TraceSim("Argument: %f\n", dreg(0));
-            double result = target(dreg(0));
+          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_API_CALL: {
-            // Handle<Value> f(v8::Arguments&)
-            SimulatorRuntimeDirectApiCall target =
-                reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
-            TraceSim("Arguments: 0x%016" PRIx64 "\n", xreg(0));
-            v8::Handle<v8::Value> result = target(xreg(0));
-            TraceSim("Returned %p\n", reinterpret_cast<void *>(*result));
+          case ExternalReference::DIRECT_GETTER_CALL: {
+            // Handle<value> f(Local<String> property, AccessorInfo& 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));
+            v8::Handle<v8::Value> result = target(xreg(0), xreg(1));
+            TraceSim("Returned: %p\n", reinterpret_cast<void *>(*result));
 #ifdef DEBUG
             CorruptAllCallerSavedCPURegisters();
 #endif
             set_reg(0, *result);
             break;
           }
 
-          case ExternalReference::DIRECT_API_CALL_NEW: {
-            // void f(v8::Arguments&)
-            SimulatorRuntimeDirectApiCallNew target =
-                reinterpret_cast<SimulatorRuntimeDirectApiCallNew>(external);
-            TraceSim("Arguments: 0x%016" PRIx64 "\n", xreg(0));
-            target(xreg(0));
+          case ExternalReference::DIRECT_GETTER_CALL_NEW: {
+            // void f(Local<String> property, AccessorInfo& info)
+            TraceSim("Type: DIRECT_GETTER_CALL_NEW\n");
+            SimulatorRuntimeDirectGetterCallNew target =
+                reinterpret_cast<SimulatorRuntimeDirectGetterCallNew>(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::DIRECT_GETTER_CALL: {
-            // Handle<value> f(Local<String> property, AccessorInfo& info)
-            SimulatorRuntimeDirectGetterCall target =
-                reinterpret_cast<SimulatorRuntimeDirectGetterCall>(external);
+          case ExternalReference::PROFILING_API_CALL: {
+            TraceSim("Type: PROFILING_API_CALL\n");
+            // Handle<Value> f(v8::Arguments&, v8::InvocationCallback)
+            SimulatorRuntimeProfilingApiCall target =
+                reinterpret_cast<SimulatorRuntimeProfilingApiCall>(external);
             TraceSim("Arguments: 0x%016" PRIx64 ", 0x%016" PRIx64 "\n",
                      xreg(0), xreg(1));
             v8::Handle<v8::Value> result = target(xreg(0), xreg(1));
             TraceSim("Returned: %p\n", reinterpret_cast<void *>(*result));
 #ifdef DEBUG
             CorruptAllCallerSavedCPURegisters();
 #endif
             set_reg(0, *result);
             break;
           }
 
-          case ExternalReference::DIRECT_GETTER_CALL_NEW: {
-            // void f(Local<String> property, AccessorInfo& info)
-            SimulatorRuntimeDirectGetterCallNew target =
-                reinterpret_cast<SimulatorRuntimeDirectGetterCallNew>(external);
+          case ExternalReference::PROFILING_API_CALL_NEW: {
+            // void f(v8::Arguments&, v8::FunctionCallback)
+            TraceSim("Type: PROFILING_API_CALL_NEW\n");
+            SimulatorRuntimeProfilingApiCallNew target =
+                reinterpret_cast<SimulatorRuntimeProfilingApiCallNew>(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::BUILTIN_CALL: {
-            // MaybeObject* f(v8::internal::Arguments).
-            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.
+          case ExternalReference::PROFILING_GETTER_CALL: {
+            // Handle<value> f(Local<String> property, AccessorInfo& info,
+            //                 AccessorGetter getter)
+            TraceSim("Type: PROFILING_GETTER_CALL\n");
+            SimulatorRuntimeProfilingGetterCall target =
+                reinterpret_cast<SimulatorRuntimeProfilingGetterCall>(external);
             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);
+                     "0x%016" PRIx64 ", 0x%016" PRIx64 ", 0x%016" PRIx64 "\n",
+                     xreg(0), xreg(1), xreg(2));
+            v8::Handle<v8::Value> result = target(xreg(0), xreg(1), xreg(2));
+            TraceSim("Returned: %p\n", reinterpret_cast<void *>(*result));
 #ifdef DEBUG
             CorruptAllCallerSavedCPURegisters();
 #endif
-            set_xreg(0, result.res0);
-            set_xreg(1, result.res1);
+            set_reg(0, *result);
+            break;
+          }
+
+          case ExternalReference::PROFILING_GETTER_CALL_NEW: {
+            // void f(Local<String> property, AccessorInfo& info,
+            //        AccessorGetterCallback callback)
+            TraceSim("Type: PROFILING_GETTER_CALL_NEW\n");
+            SimulatorRuntimeProfilingGetterCallNew target =
+                reinterpret_cast<SimulatorRuntimeProfilingGetterCallNew>(
+                    external);
+            TraceSim("Arguments: "
+                     "0x%016" PRIx64 ", 0x%016" PRIx64 ", 0x%016" PRIx64 "\n",
+                     xreg(0), xreg(1), xreg(2));
+            target(xreg(0), xreg(1), xreg(2));
+            TraceSim("No return value.");
+#ifdef DEBUG
+            CorruptAllCallerSavedCPURegisters();
+#endif
             break;
           }
         }
 
         set_lr(return_address);
         set_pc(return_address);
       } else if (instr->ImmException() == kImmExceptionIsPrintf) {
         // Read the argument encoded inline in the instruction stream.
         uint32_t type;
         ASSERT(sizeof(*pc_) == 1);
@@ skipping 42 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64