Implement native call stub on ARM and native call redirection in ARM simulator.

runtime/vm/simulator_arm.cc

 // Copyright (c) 2013, 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_ARM)
@@ skipping 664 matching lines @@
 // 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_svc_instruction() {
     return reinterpret_cast<uword>(&svc_instruction_);
   }
 
   uword external_function() const { return external_function_; }
 
-  uint32_t argument_count() const { return argument_count_; }
+  Simulator::CallKind call_kind() const { return call_kind_; }
 
-  static Redirection* Get(uword external_function, uint32_t argument_count) {
+  static Redirection* Get(uword external_function,
+                          Simulator::CallKind call_kind) {
     Redirection* current;
     for (current = list_; current != NULL; current = current->next_) {
       if (current->external_function_ == external_function) return current;
     }
-    return new Redirection(external_function, argument_count);
+    return new Redirection(external_function, call_kind);
   }
 
   static Redirection* FromSvcInstruction(Instr* svc_instruction) {
     char* addr_of_svc = reinterpret_cast<char*>(svc_instruction);
     char* addr_of_redirection =
         addr_of_svc - OFFSET_OF(Redirection, svc_instruction_);
     return reinterpret_cast<Redirection*>(addr_of_redirection);
   }
 
  private:
   static const int32_t kRedirectSvcInstruction =
     ((AL << kConditionShift) | (0xf << 24) | kRedirectionSvcCode);
-  Redirection(uword external_function, uint32_t argument_count)
+  Redirection(uword external_function, Simulator::CallKind call_kind)
       : external_function_(external_function),
-        argument_count_(argument_count),
+        call_kind_(call_kind),
         svc_instruction_(kRedirectSvcInstruction),
         next_(list_) {
     list_ = this;
   }
 
   uword external_function_;
-  const uint32_t argument_count_;
+  Simulator::CallKind call_kind_;
   uint32_t svc_instruction_;
   Redirection* next_;
   static Redirection* list_;
 };
 
 
 Redirection* Redirection::list_ = NULL;
 
 
-uword Simulator::RedirectExternalReference(uword function,
-                                           uint32_t argument_count) {
-  Redirection* redirection = Redirection::Get(function, argument_count);
+uword Simulator::RedirectExternalReference(uword function, CallKind call_kind) {
+  Redirection* redirection = Redirection::Get(function, call_kind);
   return redirection->address_of_svc_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);
@@ skipping 554 matching lines @@
         address += 4;
       }
       reg++;
       rlist >>= 1;
     }
     ASSERT(end_address == address);
   }
 }
 
 
-// Calls into the Dart runtime are based on this simple interface.
+// Calls into the Dart runtime are based on this interface.
 typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
 
 
-static void PrintExternalCallTrace(intptr_t external,
-                                   NativeArguments arguments) {
-  // TODO(regis): Do a reverse lookup on this address and print the symbol.
-  UNIMPLEMENTED();
+// Calls to native Dart functions are based on this interface.
+typedef void (*SimulatorNativeCall)(NativeArguments* arguments);
+
+
+static void PrintExternalCallTrace(uword external) {
+  const char* external_symbol = OS::ReverseLookupSymbol(external);
+  if (external_symbol != NULL) {
+    OS::Print("Call to host function %s\n", external_symbol);
+  } else {
+    OS::Print("Call to host function at 0x%d\n", external);
+  }
 }
 
 
 void Simulator::SupervisorCall(Instr* instr) {
   int svc = instr->SvcField();
   switch (svc) {
     case kRedirectionSvcCode: {
       SimulatorSetjmpBuffer buffer(this);
 
       if (!setjmp(buffer.buffer_)) {
-        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));
-
         int32_t saved_lr = get_register(LR);
         Redirection* redirection = Redirection::FromSvcInstruction(instr);
         uword external = redirection->external_function();
-        SimulatorRuntimeCall target =
-            reinterpret_cast<SimulatorRuntimeCall>(external);
-        if (FLAG_trace_sim) {
-          PrintExternalCallTrace(external, arguments);
+        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);
+          if (FLAG_trace_sim) {
+            PrintExternalCallTrace(external);
+          }
+          target(arguments);
+        } else {
+          ASSERT(redirection->call_kind() == kNativeCall);
+          NativeArguments* arguments;
+          arguments = reinterpret_cast<NativeArguments*>(get_register(R0));
+          SimulatorNativeCall target =
+              reinterpret_cast<SimulatorNativeCall>(external);
+          if (FLAG_trace_sim) {
+            PrintExternalCallTrace(external);
+          }
+          target(arguments);
         }
-        target(arguments);
 
         // Zap caller-saved registers, since the actual runtime call could have
         // used them.
         set_register(R2, icount_);
         set_register(R3, icount_);
         set_register(IP, icount_);
         set_register(LR, icount_);
         float zap_fvalue = static_cast<float>(icount_);
         for (int i = S0; i <= S15; i++) {
           set_sregister(static_cast<SRegister>(i), zap_fvalue);
@@ skipping 1494 matching lines @@
   // isolate->ChangeStateToGeneratedCode();
   set_register(kExceptionObjectReg, bit_cast<int32_t>(object.raw()));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM