ARM: add AArch32 support and new vcvt instructions

src/arm/simulator-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #include "src/v8.h"
 
@@ skipping 1903 matching lines @@
   }
 }
 
 
 double Simulator::canonicalizeNaN(double value) {
   return (FPSCR_default_NaN_mode_ && std::isnan(value)) ?
     FixedDoubleArray::canonical_not_the_hole_nan_as_double() : value;
 }
 
 
+double Simulator::FPRoundInt(double value, VCVTRoundingMode rounding_mode) {
+  Double double_value(value);
+  if ((value == 0.0) || double_value.IsInfinite()) {
+    return value;
+  } else if (std::isnan(value)) {
+    return canonicalizeNaN(value);
+  }
+
+  double int_result = floor(value);
+  double error = value - int_result;
+  switch (rounding_mode) {
+    case kVcvtTiesToAway: {
+      // Take care of correctly handling the range ]-0.5, -0.0], which must
+      // yield -0.0.
+      if ((-0.5 < value) && (value < 0.0)) {
+        int_result = -0.0;
+
+      } else if ((error > 0.5) || ((error == 0.5) && (int_result >= 0.0))) {
+        // If the error is greater than 0.5, or is equal to 0.5 and the integer
+        // result is positive, round up.
+        int_result++;
+      }
+      break;
+    }
+    case kVcvtTiesToEven: {
+      // Take care of correctly handling the range [-0.5, -0.0], which must
+      // yield -0.0.
+      if ((-0.5 <= value) && (value < 0.0)) {
+        int_result = -0.0;
+
+      // If the error is greater than 0.5, or is equal to 0.5 and the integer
+      // result is odd, round up.
+      } else if ((error > 0.5) ||
+          ((error == 0.5) && (fmod(int_result, 2) != 0))) {
+        int_result++;
+      }
+      break;
+    }
+    case kVcvtTowardPlusInfinity: {
+      int_result = -floor(-value);
+      break;
+    }
+    case kVcvtTowardMinusInfinity: {
+      // We always use floor(value).
+      break;
+    }
+    default: UNREACHABLE();
+  }
+  return int_result;
+}
+
+
+int32_t Simulator::FPToInt32(double value, VCVTRoundingMode rounding_mode) {
+  value = FPRoundInt(value, rounding_mode);
+  if (value >= kMaxInt) {
+    return kMaxInt;
+  } else if (value < kMinInt) {
+    return kMinInt;
+  }
+  return std::isnan(value) ? 0 : static_cast<int32_t>(value);
+}
+
+
+uint32_t Simulator::FPToUInt32(double value, VCVTRoundingMode rounding_mode) {
+  value = FPRoundInt(value, rounding_mode);
+  if (value >= kMaxUInt32) {
+    return kMaxUInt32;
+  } else if (value < 0.0) {
+    return 0;
+  }
+  return std::isnan(value) ? 0 : static_cast<uint32_t>(value);
+}
+
+
 // Stop helper functions.
 bool Simulator::isStopInstruction(Instruction* instr) {
   return (instr->Bits(27, 24) == 0xF) && (instr->SvcValue() >= kStopCode);
 }
 
 
 bool Simulator::isWatchedStop(uint32_t code) {
   ASSERT(code <= kMaxStopCode);
   return code < kNumOfWatchedStops;
 }
@@ skipping 1645 matching lines @@
       }
       break;
     case 0xA:
     case 0xB:
       if ((instr->Bits(22, 20) == 5) && (instr->Bits(15, 12) == 0xf)) {
         // pld: ignore instruction.
       } else {
         UNIMPLEMENTED();
       }
       break;
+    case 0x1D:
+      if ((instr->Bits(21, 18) == 0xF) && (instr->Bits(11, 9) == 5) &&
+          (instr->Bit(6) == 1) && (instr->Bit(4) == 0)) {
+        // AArch32 vcvt instructions.
+        int size = instr->Bit(8);
+        int Vd = instr->VFPDRegValue(kSinglePrecision);
+        int Vm = instr->VFPMRegValue(static_cast<VFPRegPrecision>(size));
+        VCVTRoundingMode rounding_mode =
+            static_cast<VCVTRoundingMode>(instr->Bits(17, 16));
+        int data_type = instr->Bit(7);
+        double value;
+        if (size == 0) {
+          value = get_float_from_s_register(Vm);
+        } else {
+          value = get_double_from_d_register(Vm);
+        }
+        if (data_type == 0) {
+          uint32_t result = FPToUInt32(value, rounding_mode);
+          set_s_register_from_sinteger(Vd, result);
+        } else {
+          int32_t result = FPToInt32(value, rounding_mode);
+          set_s_register_from_sinteger(Vd, result);
+        }
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
     default:
       UNIMPLEMENTED();
       break;
   }
 }
 
 
 // Executes the current instruction.
 void Simulator::InstructionDecode(Instruction* instr) {
   if (v8::internal::FLAG_check_icache) {
@@ skipping 230 matching lines @@
   uintptr_t address = *stack_slot;
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 } }  // namespace v8::internal
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM