Adds Runtime call stub and Dart entry stub to ARM64.

runtime/vm/simulator_arm64.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <math.h>  // for isnan.
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM64)
@@ skipping 17 matching lines @@
 DEFINE_FLAG(int, stop_sim_at, 0, "Address to stop simulator at.");
 
 
 // This macro provides a platform independent use of sscanf. The reason for
 // SScanF not being implemented in a platform independent way through
 // OS in the same way as SNPrint is that the Windows C Run-Time
 // Library does not provide vsscanf.
 #define SScanF sscanf  // NOLINT
 
 
+// SimulatorSetjmpBuffer are linked together, and the last created one
+// is referenced by the Simulator. When an exception is thrown, the exception
+// runtime looks at where to jump and finds the corresponding
+// SimulatorSetjmpBuffer based on the stack pointer of the exception handler.
+// The runtime then does a Longjmp on that buffer to return to the simulator.
+class SimulatorSetjmpBuffer {
+ public:
+  int Setjmp() { return setjmp(buffer_); }
+  void Longjmp() {
+    // "This" is now the last setjmp buffer.
+    simulator_->set_last_setjmp_buffer(this);
+    longjmp(buffer_, 1);
+  }
+
+  explicit SimulatorSetjmpBuffer(Simulator* sim) {
+    simulator_ = sim;
+    link_ = sim->last_setjmp_buffer();
+    sim->set_last_setjmp_buffer(this);
+    sp_ = static_cast<uword>(sim->get_register(R31, R31IsSP));
+    native_sp_ = reinterpret_cast<uword>(&sim);  // Current C++ stack pointer.
+  }
+
+  ~SimulatorSetjmpBuffer() {
+    ASSERT(simulator_->last_setjmp_buffer() == this);
+    simulator_->set_last_setjmp_buffer(link_);
+  }
+
+  SimulatorSetjmpBuffer* link() { return link_; }
+
+  uword sp() { return sp_; }
+  uword native_sp() { return native_sp_; }
+
+ private:
+  uword sp_;
+  uword native_sp_;
+  Simulator* simulator_;
+  SimulatorSetjmpBuffer* link_;
+  jmp_buf buffer_;
+
+  friend class Simulator;
+};
+
+
 // The SimulatorDebugger class is used by the simulator while debugging
 // simulated ARM64 code.
 class SimulatorDebugger {
  public:
   explicit SimulatorDebugger(Simulator* sim);
   ~SimulatorDebugger();
 
   void Stop(Instr* instr, const char* message);
   void Debug();
   char* ReadLine(const char* prompt);
@@ skipping 334 matching lines @@
 
 Simulator::~Simulator() {
   delete[] stack_;
   Isolate* isolate = Isolate::Current();
   if (isolate != NULL) {
     isolate->set_simulator(NULL);
   }
 }
 
 
+// When the generated code calls an external reference we need to catch that in
+// the simulator.  The external reference will be a function compiled for the
+// host architecture.  We need to call that function instead of trying to
+// execute it with the simulator.  We do that by redirecting the external
+// reference to a svc (supervisor call) instruction that is handled by
+// the simulator.  We write the original destination of the jump just at a known
+// offset from the svc instruction so the simulator knows what to call.
+class Redirection {
+ public:
+  uword address_of_hlt_instruction() {
+    return reinterpret_cast<uword>(&hlt_instruction_);
+  }
+
+  uword external_function() const { return external_function_; }
+
+  Simulator::CallKind call_kind() const { return call_kind_; }
+
+  int argument_count() const { return argument_count_; }
+
+  static Redirection* Get(uword external_function,
+                          Simulator::CallKind call_kind,
+                          int argument_count) {
+    Redirection* current;
+    for (current = list_; current != NULL; current = current->next_) {
+      if (current->external_function_ == external_function) return current;
+    }
+    return new Redirection(external_function, call_kind, argument_count);
+  }
+
+  static Redirection* FromHltInstruction(Instr* hlt_instruction) {
+    char* addr_of_hlt = reinterpret_cast<char*>(hlt_instruction);
+    char* addr_of_redirection =
+        addr_of_hlt - OFFSET_OF(Redirection, hlt_instruction_);
+    return reinterpret_cast<Redirection*>(addr_of_redirection);
+  }
+
+ private:
+  static const int32_t kRedirectInstruction = Instr::kRedirectInstruction;
+  Redirection(uword external_function,
+              Simulator::CallKind call_kind,
+              int argument_count)
+      : external_function_(external_function),
+        call_kind_(call_kind),
+        argument_count_(argument_count),
+        hlt_instruction_(kRedirectInstruction),
+        next_(list_) {
+    list_ = this;
+  }
+
+  uword external_function_;
+  Simulator::CallKind call_kind_;
+  int argument_count_;
+  uint32_t hlt_instruction_;
+  Redirection* next_;
+  static Redirection* list_;
+};
+
+
+Redirection* Redirection::list_ = NULL;
+
+
+uword Simulator::RedirectExternalReference(uword function,
+                                           CallKind call_kind,
+                                           int argument_count) {
+  Redirection* redirection =
+      Redirection::Get(function, call_kind, argument_count);
+  return redirection->address_of_hlt_instruction();
+}
+
+
 // Get the active Simulator for the current isolate.
 Simulator* Simulator::Current() {
   Simulator* simulator = Isolate::Current()->simulator();
   if (simulator == NULL) {
     simulator = new Simulator();
     Isolate::Current()->set_simulator(simulator);
   }
   return simulator;
 }
 
 
 // Sets the register in the architecture state.
 void Simulator::set_register(Register reg, int64_t value, R31Type r31t) {
   // register is in range, and if it is R31, a mode is specified.
   ASSERT((reg >= 0) && (reg < kNumberOfCpuRegisters));
-  ASSERT((reg != R31) || (r31t != R31IsUndef));
   if ((reg != R31) || (r31t != R31IsZR)) {
     registers_[reg] = value;
   }
 }
 
 
 // Get the register from the architecture state.
 int64_t Simulator::get_register(Register reg, R31Type r31t) const {
   ASSERT((reg >= 0) && (reg < kNumberOfCpuRegisters));
-  ASSERT((reg != R31) || (r31t != R31IsUndef));
   if ((reg == R31) && (r31t == R31IsZR)) {
     return 0;
   } else {
     return registers_[reg];
   }
 }
 
 
 void Simulator::set_wregister(Register reg, int32_t value, R31Type r31t) {
   ASSERT((reg >= 0) && (reg < kNumberOfCpuRegisters));
-  ASSERT((reg != R31) || (r31t != R31IsUndef));
   // When setting in W mode, clear the high bits.
   if ((reg != R31) || (r31t != R31IsZR)) {
     registers_[reg] = Utils::LowHighTo64Bits(static_cast<uint32_t>(value), 0);
   }
 }
 
 
 // Get the register from the architecture state.
 int32_t Simulator::get_wregister(Register reg, R31Type r31t) const {
   ASSERT((reg >= 0) && (reg < kNumberOfCpuRegisters));
-  ASSERT((reg != R31) || (r31t != R31IsUndef));
   if ((reg == R31) && (r31t == R31IsZR)) {
     return 0;
   } else {
     return registers_[reg];
   }
 }
 
 
 // Raw access to the PC register.
 void Simulator::set_pc(int64_t value) {
   pc_modified_ = true;
+  last_pc_ = pc_;
   pc_ = value;
 }
 
 
-// Raw access to the PC register without the special adjustment when reading.
+// Raw access to the pc.
 int64_t Simulator::get_pc() const {
   return pc_;
 }
 
 
+int64_t Simulator::get_last_pc() const {
+  return last_pc_;
+}
+
+
 void Simulator::HandleIllegalAccess(uword addr, Instr* instr) {
   uword fault_pc = get_pc();
+  uword last_pc = get_last_pc();
   // TODO(zra): drop into debugger.
   char buffer[128];
   snprintf(buffer, sizeof(buffer),
-           "illegal memory access at 0x%" Px ", pc=0x%" Px "\n",
-           addr, fault_pc);
+      "illegal memory access at 0x%" Px ", pc=0x%" Px ", last_pc=0x%" Px"\n",
+      addr, fault_pc, last_pc);
+  SimulatorDebugger dbg(this);
+  dbg.Stop(instr, buffer);
   // The debugger will return control in non-interactive mode.
   FATAL("Cannot continue execution after illegal memory access.");
 }
 
 
 // The ARMv8 manual advises that an unaligned access may generate a fault,
 // and if not, will likely take a number of additional cycles to execute,
 // so let's just not generate any.
 void Simulator::UnalignedAccess(const char* msg, uword addr, Instr* instr) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer),
            "unaligned %s at 0x%" Px ", pc=%p\n", msg, addr, instr);
-  // TODO(zra): Drop into the simulator debugger when it exists.
+  SimulatorDebugger dbg(this);
+  dbg.Stop(instr, buffer);
   // The debugger will not be able to single step past this instruction, but
   // it will be possible to disassemble the code and inspect registers.
   FATAL("Cannot continue execution after unaligned access.");
 }
 
 
 void Simulator::UnimplementedInstruction(Instr* instr) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer), "Unimplemented instruction: pc=%p\n", instr);
-  // TODO(zra): drop into debugger.
+  SimulatorDebugger dbg(this);
+  dbg.Stop(instr, buffer);
   FATAL("Cannot continue execution after unimplemented instruction.");
 }
 
 
 // Returns the top of the stack area to enable checking for stack pointer
 // validity.
 uword Simulator::StackTop() const {
   // To be safe in potential stack underflows we leave some buffer above and
   // set the stack top.
   return reinterpret_cast<uword>(stack_) +
@@ skipping 417 matching lines @@
     UnimplementedInstruction(instr);
   }
   const int64_t imm19 = instr->SImm19Field();
   const int64_t dest = get_pc() + (imm19 << 2);
   if (ConditionallyExecute(instr)) {
     set_pc(dest);
   }
 }
 
 
+// Calls into the Dart runtime are based on this interface.
+typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
+
+// Calls to leaf Dart runtime functions are based on this interface.
+typedef int32_t (*SimulatorLeafRuntimeCall)(
+    int64_t r0, int64_t r1, int64_t r2, int64_t r3,
+    int64_t r4, int64_t r5, int64_t r6, int64_t r7);
+
+// Calls to leaf float Dart runtime functions are based on this interface.
+typedef double (*SimulatorLeafFloatRuntimeCall)(
+    double d0, double d1, double d2, double d3,
+    double d4, double d5, double d6, double d7);
+
+// Calls to native Dart functions are based on this interface.
+typedef void (*SimulatorBootstrapNativeCall)(NativeArguments* arguments);
+typedef void (*SimulatorNativeCall)(NativeArguments* arguments, uword target);
+
+
+void Simulator::DoRedirectedCall(Instr* instr) {
+  SimulatorSetjmpBuffer buffer(this);
+  if (!setjmp(buffer.buffer_)) {
+    int64_t saved_lr = get_register(LR);
+    Redirection* redirection = Redirection::FromHltInstruction(instr);
+    uword external = redirection->external_function();
+    if (FLAG_trace_sim) {
+      OS::Print("Call to host function at 0x%" Pd "\n", external);
+    }
+
+    if ((redirection->call_kind() == kRuntimeCall) ||
+        (redirection->call_kind() == kBootstrapNativeCall) ||
+        (redirection->call_kind() == kNativeCall)) {
+      // Set the top_exit_frame_info of this simulator to the native stack.
+      set_top_exit_frame_info(reinterpret_cast<uword>(&buffer));
+    }
+    if (redirection->call_kind() == kRuntimeCall) {
+      NativeArguments arguments;
+      ASSERT(sizeof(NativeArguments) == 4*kWordSize);
+      arguments.isolate_ = reinterpret_cast<Isolate*>(get_register(R0));
+      arguments.argc_tag_ = get_register(R1);
+      arguments.argv_ = reinterpret_cast<RawObject*(*)[]>(get_register(R2));
+      arguments.retval_ = reinterpret_cast<RawObject**>(get_register(R3));
+      SimulatorRuntimeCall target =
+          reinterpret_cast<SimulatorRuntimeCall>(external);
+      target(arguments);
+      set_register(R0, icount_);  // Zap result register from void function.
+      set_register(R1, icount_);
+    } else if (redirection->call_kind() == kLeafRuntimeCall) {
+      ASSERT((0 <= redirection->argument_count()) &&
+             (redirection->argument_count() <= 8));
+      int64_t r0 = get_register(R0);
+      int64_t r1 = get_register(R1);
+      int64_t r2 = get_register(R2);
+      int64_t r3 = get_register(R3);
+      int64_t r4 = get_register(R4);
+      int64_t r5 = get_register(R5);
+      int64_t r6 = get_register(R6);
+      int64_t r7 = get_register(R7);
+      SimulatorLeafRuntimeCall target =
+          reinterpret_cast<SimulatorLeafRuntimeCall>(external);
+      r0 = target(r0, r1, r2, r3, r4, r5, r6, r7);
+      set_register(R0, r0);  // Set returned result from function.
+      set_register(R1, icount_);  // Zap unused result register.
+    } else if (redirection->call_kind() == kLeafFloatRuntimeCall) {
+      // TODO(zra): leaf float runtime calls.
+      UNIMPLEMENTED();
+    } else if (redirection->call_kind() == kBootstrapNativeCall) {
+      NativeArguments* arguments;
+      arguments = reinterpret_cast<NativeArguments*>(get_register(R0));
+      SimulatorBootstrapNativeCall target =
+          reinterpret_cast<SimulatorBootstrapNativeCall>(external);
+      target(arguments);
+      set_register(R0, icount_);  // Zap result register from void function.
+    } else {
+      ASSERT(redirection->call_kind() == kNativeCall);
+      NativeArguments* arguments;
+      arguments = reinterpret_cast<NativeArguments*>(get_register(R0));
+      uword target_func = get_register(R1);
+      SimulatorNativeCall target =
+          reinterpret_cast<SimulatorNativeCall>(external);
+      target(arguments, target_func);
+      set_register(R0, icount_);  // Zap result register from void function.
+      set_register(R1, icount_);
+    }
+    set_top_exit_frame_info(0);
+
+    // Zap caller-saved registers, since the actual runtime call could have
+    // used them.
+    set_register(R2, icount_);
+    set_register(R3, icount_);
+    set_register(R4, icount_);
+    set_register(R5, icount_);
+    set_register(R6, icount_);
+    set_register(R7, icount_);
+    set_register(R8, icount_);
+    set_register(R9, icount_);
+    set_register(R10, icount_);
+    set_register(R11, icount_);
+    set_register(R12, icount_);
+    set_register(R13, icount_);
+    set_register(R14, icount_);
+    set_register(R15, icount_);
+    set_register(IP0, icount_);
+    set_register(IP1, icount_);
+    set_register(R18, icount_);
+    set_register(LR, icount_);
+
+    // TODO(zra): Zap caller-saved fpu registers.
+
+    // Return.
+    set_pc(saved_lr);
+  } else {
+    // Coming via long jump from a throw. Continue to exception handler.
+    set_top_exit_frame_info(0);
+  }
+}
+
+
 void Simulator::DecodeExceptionGen(Instr* instr) {
   if ((instr->Bits(0, 2) == 1) && (instr->Bits(2, 3) == 0) &&
       (instr->Bits(21, 3) == 0)) {
     // Format(instr, "svc 'imm16");
     UnimplementedInstruction(instr);
   } else if ((instr->Bits(0, 2) == 0) && (instr->Bits(2, 3) == 0) &&
              (instr->Bits(21, 3) == 1)) {
     // Format(instr, "brk 'imm16");
     UnimplementedInstruction(instr);
   } else if ((instr->Bits(0, 2) == 0) && (instr->Bits(2, 3) == 0) &&
              (instr->Bits(21, 3) == 2)) {
     // Format(instr, "hlt 'imm16");
     uint16_t imm = static_cast<uint16_t>(instr->Imm16Field());
     if (imm == kImmExceptionIsDebug) {
       SimulatorDebugger dbg(this);
       const char* message = *reinterpret_cast<const char**>(
           reinterpret_cast<intptr_t>(instr) - 2 * Instr::kInstrSize);
       set_pc(get_pc() + Instr::kInstrSize);
       dbg.Stop(instr, message);
     } else if (imm == kImmExceptionIsPrintf) {
       const char* message = *reinterpret_cast<const char**>(
           reinterpret_cast<intptr_t>(instr) - 2 * Instr::kInstrSize);
       OS::Print("Simulator hit: %s", message);
+    } else if (imm == kImmExceptionIsRedirectedCall) {
+      DoRedirectedCall(instr);
     } else {
       UnimplementedInstruction(instr);
     }
   }
 }
 
 
 void Simulator::DecodeSystem(Instr* instr) {
   if ((instr->Bits(0, 8) == 0x5f) && (instr->Bits(12, 4) == 2) &&
       (instr->Bits(16, 3) == 3) && (instr->Bits(19, 2) == 0) &&
@@ skipping 784 matching lines @@
   set_register(R21, r21_val);
   set_register(R22, r22_val);
   set_register(R23, r23_val);
   set_register(R24, r24_val);
   set_register(R25, r25_val);
   set_register(R26, r26_val);
   set_register(R27, r27_val);
   set_register(R28, r28_val);
   set_register(R29, r29_val);
 
-  // Restore the SP register and return R1:R0.
+  // Restore the SP register and return R0.
   set_register(R31, sp_before_call, R31IsSP);
   int64_t return_value;
   return_value = get_register(R0);
   return return_value;
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM64)
 
 #endif  // defined TARGET_ARCH_ARM64