Adds unary double operations to ARM64, enables many tests.

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 1167 matching lines @@
       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.
+      const int64_t r0 = get_register(R0);
+      const int64_t r1 = get_register(R1);
+      const int64_t r2 = get_register(R2);
+      const int64_t r3 = get_register(R3);
+      const int64_t r4 = get_register(R4);
+      const int64_t r5 = get_register(R5);
+      const int64_t r6 = get_register(R6);
+      const int64_t r7 = get_register(R7);
+      const int64_t res = target(r0, r1, r2, r3, r4, r5, r6, r7);
+      set_register(R0, res);  // 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();
+      ASSERT((0 <= redirection->argument_count()) &&
+             (redirection->argument_count() <= 8));
+      SimulatorLeafFloatRuntimeCall target =
+          reinterpret_cast<SimulatorLeafFloatRuntimeCall>(external);
+      const double d0 = bit_cast<double, int64_t>(get_vregisterd(V0));
+      const double d1 = bit_cast<double, int64_t>(get_vregisterd(V1));
+      const double d2 = bit_cast<double, int64_t>(get_vregisterd(V2));
+      const double d3 = bit_cast<double, int64_t>(get_vregisterd(V3));
+      const double d4 = bit_cast<double, int64_t>(get_vregisterd(V4));
+      const double d5 = bit_cast<double, int64_t>(get_vregisterd(V5));
+      const double d6 = bit_cast<double, int64_t>(get_vregisterd(V6));
+      const double d7 = bit_cast<double, int64_t>(get_vregisterd(V7));
+      const double res = target(d0, d1, d2, d3, d4, d5, d6, d7);
+      set_vregisterd(V0, bit_cast<int64_t, double>(res));
     } 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;
@@ skipping 855 matching lines @@
   } else {
     UnimplementedInstruction(instr);
   }
 }
 
 
 void Simulator::DecodeFPOneSource(Instr* instr) {
   const int opc = instr->Bits(15, 2);
   const VRegister vd = instr->VdField();
   const VRegister vn = instr->VnField();
+  const int64_t vn_val = get_vregisterd(vn);
+  const double vn_dbl = bit_cast<double, int64_t>(vn_val);
+
+  int64_t res_val = 0;
   switch (opc) {
     case 0:
       // Format("fmovdd 'vd, 'vn");
-      set_vregisterd(vd, get_vregisterd(vn));
+      res_val = get_vregisterd(vn);
+      break;
+    case 1:
+      // Format("fabsd 'vd, 'vn");
+      res_val = bit_cast<int64_t, double>(fabs(vn_dbl));
+      break;
+    case 2:
+      // Format("fnegd 'vd, 'vn");
+      res_val = bit_cast<int64_t, double>(-vn_dbl);
+      break;
+    case 3:
+      // Format("fsqrtd 'vd, 'vn");
+      res_val = bit_cast<int64_t, double>(sqrt(vn_dbl));
       break;
     default:
-      UnimplementedInstruction(instr);
+      UNREACHABLE();
       break;
   }
+
+  set_vregisterd(vd, res_val);
 }
 
 
 void Simulator::DecodeFPTwoSource(Instr* instr) {
   if (instr->Bits(22, 2) != 1) {
     UnimplementedInstruction(instr);
     return;
   }
   const VRegister vd = instr->VdField();
   const VRegister vn = instr->VnField();
@@ skipping 283 matching lines @@
   set_register(kExceptionObjectReg, bit_cast<int64_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int64_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM64)
 
 #endif  // defined TARGET_ARCH_ARM64