Switch code generation on ARM from softfp ABI to hardfp ABI.

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 783 matching lines @@
 class Redirection {
  public:
   uword address_of_svc_instruction() {
     return reinterpret_cast<uword>(&svc_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) {
+                          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);
+    return new Redirection(external_function, call_kind, argument_count);
   }
 
   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, Simulator::CallKind call_kind)
+  Redirection(uword external_function,
+              Simulator::CallKind call_kind,
+              int argument_count)
       : external_function_(external_function),
         call_kind_(call_kind),
+        argument_count_(argument_count),
         svc_instruction_(kRedirectSvcInstruction),
         next_(list_) {
     list_ = this;
   }
 
   uword external_function_;
   Simulator::CallKind call_kind_;
+  int argument_count_;
   uint32_t svc_instruction_;
   Redirection* next_;
   static Redirection* list_;
 };
 
 
 Redirection* Redirection::list_ = NULL;
 
 
-uword Simulator::RedirectExternalReference(uword function, CallKind call_kind) {
-  Redirection* redirection = Redirection::Get(function, call_kind);
+uword Simulator::RedirectExternalReference(uword function,
+                                           CallKind call_kind,
+                                           int argument_count) {
+  Redirection* redirection =
+      Redirection::Get(function, call_kind, argument_count);
   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 569 matching lines @@
 }
 
 
 // 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 leaf float Dart runtime functions are based on this interface.
+typedef double (*SimulatorLeafFloatRuntimeCall)(double d0, double d1);
+
 // 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%"Pd"\n", external);
         }
 
-        if (redirection->call_kind() != kLeafRuntimeCall) {
+        if ((redirection->call_kind() == kRuntimeCall) ||
+            (redirection->call_kind() == kNativeCall)) {
           // The top_exit_frame_info of the current isolate points to the top of
           // the simulator stack.
           ASSERT((StackTop() - Isolate::Current()->top_exit_frame_info()) <
                  Isolate::GetSpecifiedStackSize());
           // 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.
         } else if (redirection->call_kind() == kLeafRuntimeCall) {
+          ASSERT((0 <= redirection->argument_count()) &&
+                 (redirection->argument_count() <= 4));
           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 if (redirection->call_kind() == kLeafFloatRuntimeCall) {
+          ASSERT((0 <= redirection->argument_count()) &&
+                 (redirection->argument_count() <= 2));
+          // We currently use 'hardfp' ('gnueabihf') rather than 'softfp'
+          // ('gnueabi') float ABI for leaf runtime calls, i.e. double values
+          // are passed and returned in vfp registers rather than in integer
+          // register pairs.
+          SimulatorLeafFloatRuntimeCall target =
+              reinterpret_cast<SimulatorLeafFloatRuntimeCall>(external);
+          double d0 = get_dregister(D0);
+          double d1 = get_dregister(D1);
+          d0 = target(d0, d1);
+          set_dregister(D0, d0);
         } 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.
         }
         set_top_exit_frame_info(0);
 
         // 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_);
         double zap_dvalue = static_cast<double>(icount_);
-        for (int i = D0; i <= D7; i++) {
+        // Do not zap D0, as it may contain a float result.
+        for (int i = D1; i <= D7; i++) {
           set_dregister(static_cast<DRegister>(i), zap_dvalue);
         }
-        // The above loop also zaps overlapping registers S0-S15.
+        // The above loop also zaps overlapping registers S2-S15.
         // Registers D8-D15 (overlapping with S16-S31) are preserved.
 #ifdef VFPv3_D32
         for (int i = D16; i <= D31; i++) {
           set_dregister(static_cast<DRegister>(i), zap_dvalue);
         }
 #endif  // VFPv3_D32
 
         // Return.
         set_pc(saved_lr);
       } else {
@@ skipping 1537 matching lines @@
     set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   }
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM