Implement leaf runtime call stub on ARM and corresponding call redirection

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 1283 matching lines @@
       rlist >>= 1;
     }
     ASSERT(end_address == address);
   }
 }
 
 
 // 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)(
+    int32_t r0, int32_t r1, int32_t r2, int32_t r3);
 
 // Calls to native Dart functions are based on this interface.
 typedef void (*SimulatorNativeCall)(NativeArguments* arguments);
 
 
 void Simulator::SupervisorCall(Instr* instr) {
   int svc = instr->SvcField();
   switch (svc) {
     case kRedirectionSvcCode: {
       SimulatorSetjmpBuffer buffer(this);
 
       if (!setjmp(buffer.buffer_)) {
         int32_t saved_lr = get_register(LR);
         Redirection* redirection = Redirection::FromSvcInstruction(instr);
         uword external = redirection->external_function();
         if (FLAG_trace_sim) {
           OS::Print("Call to host function at 0x%d\n", external);
         }
         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.
+        } else if (redirection->call_kind() == kLeafRuntimeCall) {
+          int32_t r0 = get_register(R0);
+          int32_t r1 = get_register(R1);
+          int32_t r2 = get_register(R2);
+          int32_t r3 = get_register(R3);
+          SimulatorLeafRuntimeCall target =
+              reinterpret_cast<SimulatorLeafRuntimeCall>(external);
+          r0 = target(r0, r1, r2, r3);
+          set_register(R0, r0);  // Set returned result from function.
         } else {
           ASSERT(redirection->call_kind() == kNativeCall);
           NativeArguments* arguments;
           arguments = reinterpret_cast<NativeArguments*>(get_register(R0));
           SimulatorNativeCall target =
               reinterpret_cast<SimulatorNativeCall>(external);
           target(arguments);
+          set_register(R0, icount_);  // Zap result register from void function.
         }
 
         // Zap caller-saved registers, since the actual runtime call could have
         // used them.
+        set_register(R1, icount_);
         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);
         }
 #ifdef VFPv3_D32
         double zap_dvalue = static_cast<double>(icount_);
         for (int i = D16; i <= D31; i++) {
           set_dregister(static_cast<DRegister>(i), zap_dvalue);
         }
 #endif  // VFPv3_D32
 
-        // Zap result register pair R0:R1 and return.
-        set_register(R0, icount_);
-        set_register(R1, icount_);
+        // Return.
         set_pc(saved_lr);
       }
 
       break;
     }
     case kBreakpointSvcCode: {
       SimulatorDebugger dbg(this);
       dbg.Stop(instr, "breakpoint");
       break;
     }
@@ skipping 1473 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