Adds arm64 double arithmetic instructions.

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 341 matching lines @@
             end = start + (length * Instr::kInstrSize);
           }
         }
         Disassembler::Disassemble(start, end);
       } else if (strcmp(cmd, "flags") == 0) {
         OS::Print("APSR: ");
         OS::Print("N flag: %d; ", sim_->n_flag_);
         OS::Print("Z flag: %d; ", sim_->z_flag_);
         OS::Print("C flag: %d; ", sim_->c_flag_);
         OS::Print("V flag: %d\n", sim_->v_flag_);
-        OS::Print("FPSCR: ");
-        OS::Print("N flag: %d; ", sim_->fp_n_flag_);
-        OS::Print("Z flag: %d; ", sim_->fp_z_flag_);
-        OS::Print("C flag: %d; ", sim_->fp_c_flag_);
-        OS::Print("V flag: %d\n", sim_->fp_v_flag_);
       } else if (strcmp(cmd, "gdb") == 0) {
         OS::Print("relinquishing control to gdb\n");
         OS::DebugBreak();
         OS::Print("regaining control from gdb\n");
       } else {
         OS::Print("Unknown command: %s\n", cmd);
       }
     }
     delete[] line;
   }
@@ skipping 95 matching lines @@
   }
   n_flag_ = false;
   z_flag_ = false;
   c_flag_ = false;
   v_flag_ = false;
 
   for (int i = 0; i < kNumberOfVRegisters; i++) {
     vregisters_[i].lo = 0;
     vregisters_[i].hi = 0;
   }
-  fp_n_flag_ = false;
-  fp_z_flag_ = false;
-  fp_c_flag_ = false;
-  fp_v_flag_ = false;
 
   // The sp is initialized to point to the bottom (high address) of the
   // allocated stack area.
   registers_[R31] = StackTop();
   // The lr and pc are initialized to a known bad value that will cause an
   // access violation if the simulator ever tries to execute it.
   registers_[LR] = kBadLR;
   pc_ = kBadLR;
 }
 
@@ skipping 1464 matching lines @@
         static_cast<__int128>(rn_val) * static_cast<__int128>(rm_val);
     const int64_t alu_out = static_cast<int64_t>(res >> 64);
     set_register(rd, alu_out, R31IsZR);
   } else {
     UnimplementedInstruction(instr);
   }
 }
 
 
 void Simulator::DecodeConditionalSelect(Instr* instr) {
+  const Register rd = instr->RdField();
+  const Register rn = instr->RnField();
+  const Register rm = instr->RmField();
+  const int64_t rm_val64 = get_register(rm, R31IsZR);
+  const int32_t rm_val32 = get_wregister(rm, R31IsZR);
+  const int64_t rn_val64 = get_register(rn, instr->RnMode());
+  const int32_t rn_val32 = get_wregister(rn, instr->RnMode());
+  int64_t result64 = 0;
+  int32_t result32 = 0;
+
   if ((instr->Bits(29, 2) == 0) && (instr->Bits(10, 2) == 0)) {
     // Format(instr, "mov'sf'cond 'rd, 'rn, 'rm");
-    const Register rd = instr->RdField();
-    const Register rn = instr->RnField();
-    const Register rm = instr->RmField();
-    if (instr->SFField() == 1) {
-      int64_t res = 0;
-      if (ConditionallyExecute(instr)) {
-        res = get_register(rn, instr->RnMode());
-      } else {
-        res = get_register(rm, R31IsZR);
-      }
-      set_register(rd, res, instr->RdMode());
-    } else {
-      int32_t res = 0;
-      if (ConditionallyExecute(instr)) {
-        res = get_wregister(rn, instr->RnMode());
-      } else {
-        res = get_wregister(rm, R31IsZR);
-      }
-      set_wregister(rd, res, instr->RdMode());
+    result64 = rm_val64;
+    result32 = rm_val32;
+    if (ConditionallyExecute(instr)) {
+      result64 = rn_val64;
+      result32 = rn_val32;
     }
-
+  } else if ((instr->Bits(29, 2) == 0) && (instr->Bits(10, 2) == 1)) {
+    // Format(instr, "csinc'sf'cond 'rd, 'rn, 'rm");
+    result64 = rm_val64 + 1;
+    result32 = rm_val32 + 1;
+    if (ConditionallyExecute(instr)) {
+      result64 = rn_val64;
+      result32 = rn_val32;
+    }
   } else {
     UnimplementedInstruction(instr);
+    return;
+  }
+
+  if (instr->SFField() == 1) {
+    set_register(rd, result64, instr->RdMode());
+  } else {
+    set_wregister(rd, result32, instr->RdMode());
   }
 }
 
 
 void Simulator::DecodeDPRegister(Instr* instr) {
   if (instr->IsAddSubShiftExtOp()) {
     DecodeAddSubShiftExt(instr);
   } else if (instr->IsLogicalShiftOp()) {
     DecodeLogicalShift(instr);
   } else if (instr->IsMiscDP2SourceOp()) {
@@ skipping 26 matching lines @@
     const int64_t immd = Instr::VFPExpandImm(instr->Imm8Field());
     set_vregisterd(vd, immd);
   } else {
     // Single.
     UnimplementedInstruction(instr);
   }
 }
 
 
 void Simulator::DecodeFPIntCvt(Instr* instr) {
+  const VRegister vd = instr->VdField();
+  const VRegister vn = instr->VnField();
+  const Register rd = instr->RdField();
+  const Register rn = instr->RnField();
+
   if ((instr->SFField() != 1) || (instr->Bit(29) != 0) ||
       (instr->Bits(22, 2) != 1)) {
     UnimplementedInstruction(instr);
     return;
   }
-  if (instr->Bits(16, 3) == 6) {
+  if (instr->Bits(16, 5) == 2) {
+    // Format(instr, "scvtfd 'vd, 'vn");
+    const int64_t rn_val = get_register(rn, instr->RnMode());
+    const double vn_dbl = static_cast<double>(rn_val);
+    set_vregisterd(vd, bit_cast<int64_t, double>(vn_dbl));
+  } else if (instr->Bits(16, 5) == 6) {
     // Format(instr, "fmovrd 'rd, 'vn");
-    const VRegister vn = instr->VnField();
-    const Register rd = instr->RdField();
     const int64_t vn_val = get_vregisterd(vn);
     set_register(rd, vn_val, R31IsZR);
-  } else if (instr->Bits(16, 3) == 7) {
+  } else if (instr->Bits(16, 5) == 7) {
     // Format(instr, "fmovdr 'vd, 'rn");
-    const VRegister vd = instr->VdField();
-    const Register rn = instr->RnField();
     const int64_t rn_val = get_register(rn, R31IsZR);
     set_vregisterd(vd, rn_val);
+  } else if (instr->Bits(16, 5) == 24) {
+    // Format(instr, "fcvtzds 'rd, 'vn");
+    const double vn_val = bit_cast<double, int64_t>(get_vregisterd(vn));
+    set_register(rd, static_cast<int64_t>(vn_val), instr->RdMode());
   } 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();
   switch (opc) {
     case 0:
       // Format("fmovdd 'vd, 'vn");
       set_vregisterd(vd, get_vregisterd(vn));
       break;
     default:
       UnimplementedInstruction(instr);
       break;
   }
 }
 
 
+void Simulator::DecodeFPTwoSource(Instr* instr) {
+  if (instr->Bits(22, 2) != 1) {
+    UnimplementedInstruction(instr);
+    return;
+  }
+  const VRegister vd = instr->VdField();
+  const VRegister vn = instr->VnField();
+  const VRegister vm = instr->VmField();
+  const double vn_val = bit_cast<double, int64_t>(get_vregisterd(vn));
+  const double vm_val = bit_cast<double, int64_t>(get_vregisterd(vm));
+  const int opc = instr->Bits(12, 4);
+  double result;
+
+  switch (opc) {
+    case 0:
+      // Format(instr, "fmuld 'vd, 'vn, 'vm");
+      result = vn_val * vm_val;
+      break;
+    case 1:
+      // Format(instr, "fdivd 'vd, 'vn, 'vm");
+      result = vn_val / vm_val;
+      break;
+    case 2:
+      // Format(instr, "faddd 'vd, 'vn, 'vm");
+      result = vn_val + vm_val;
+      break;
+    case 3:
+      // Format(instr, "fsubd 'vd, 'vn, 'vm");
+      result = vn_val - vm_val;
+      break;
+    default:
+      // Unknown(instr);
+      break;
+  }
+
+  set_vregisterd(vd, bit_cast<int64_t, double>(result));
+}
+
+
+void Simulator::DecodeFPCompare(Instr* instr) {
+  const VRegister vn = instr->VnField();
+  const VRegister vm = instr->VmField();
+  const double vn_val = get_vregisterd(vn);
+  double vm_val;
+
+  if ((instr->Bit(22) == 1) && (instr->Bits(3, 2) == 0)) {
+    // Format(instr, "fcmpd 'vn, 'vm");
+    vm_val = get_vregisterd(vm);
+  } else if ((instr->Bit(22) == 1) && (instr->Bits(3, 2) == 1)) {
+    if (instr->VmField() == V0) {
+      // Format(instr, "fcmpd 'vn, #0.0");
+      vm_val = 0.0;
+    } else {
+      UnimplementedInstruction(instr);
+      return;
+    }
+  } else {
+    UnimplementedInstruction(instr);
+    return;
+  }
+
+  n_flag_ = false;
+  z_flag_ = false;
+  c_flag_ = false;
+  v_flag_ = false;
+
+  if (isnan(vn_val) || isnan(vm_val)) {
+    c_flag_ = true;
+    v_flag_ = true;
+  } else if (vn_val == vm_val) {
+    z_flag_ = true;
+    c_flag_ = true;
+  } else if (vn_val < vm_val) {
+    n_flag_ = true;
+  } else {
+    c_flag_ = true;
+  }
+}
+
+
 void Simulator::DecodeFP(Instr* instr) {
   if (instr->IsFPImmOp()) {
     DecodeFPImm(instr);
   } else if (instr->IsFPIntCvtOp()) {
     DecodeFPIntCvt(instr);
   } else if (instr->IsFPOneSourceOp()) {
     DecodeFPOneSource(instr);
+  } else if (instr->IsFPTwoSourceOp()) {
+    DecodeFPTwoSource(instr);
+  } else if (instr->IsFPCompareOp()) {
+    DecodeFPCompare(instr);
   } else {
     UnimplementedInstruction(instr);
   }
 }
 
 
 void Simulator::DecodeDPSimd2(Instr* instr) {
   if (instr->IsFPOp()) {
     DecodeFP(instr);
   } else {
@@ skipping 189 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