[turbofan] Implemented the optional Float32RoundTruncate operator.

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>
 
 #if V8_TARGET_ARCH_ARM
 
@@ skipping 3159 matching lines @@
         }
       } else if (instr->Opc3Value() == 0x0) {
         // vmov immediate.
         if (instr->SzValue() == 0x1) {
           set_d_register_from_double(vd, instr->DoubleImmedVmov());
         } else {
           UNREACHABLE();  // Not used by v8.
         }
       } else if (((instr->Opc2Value() == 0x6)) && (instr->Opc3Value() == 0x3)) {
         // vrintz - truncate
-        double dm_value = get_double_from_d_register(vm);
-        double dd_value = trunc(dm_value);
-        dd_value = canonicalizeNaN(dd_value);
-        set_d_register_from_double(vd, dd_value);
+        if (instr->SzValue() == 0x1) {
+          double dm_value = get_double_from_d_register(vm);
+          double dd_value = trunc(dm_value);
+          dd_value = canonicalizeNaN(dd_value);
+          set_d_register_from_double(vd, dd_value);
+        } else {
+          float sm_value = get_float_from_s_register(m);
+          float sd_value = truncf(sm_value);
+          sd_value = canonicalizeNaN(sd_value);
+          set_s_register_from_float(d, sd_value);
+        }
       } else {
         UNREACHABLE();  // Not used by V8.
       }
     } else if (instr->Opc1Value() == 0x3) {
       if (instr->Opc3Value() & 0x1) {
         // vsub
         if (instr->SzValue() == 0x1) {
           double dn_value = get_double_from_d_register(vn);
           double dm_value = get_double_from_d_register(vm);
           double dd_value = dn_value - dm_value;
@@ skipping 680 matching lines @@
           int vm = instr->VFPMRegValue(kDoublePrecision);
           int vd = instr->VFPDRegValue(kDoublePrecision);
           double dm_value = get_double_from_d_register(vm);
           double dd_value = 0.0;
           int rounding_mode = instr->Bits(17, 16);
           switch (rounding_mode) {
             case 0x0:  // vrinta - round with ties to away from zero
               dd_value = round(dm_value);
               break;
             case 0x1: {  // vrintn - round with ties to even
-              dd_value = std::floor(dm_value);
-              double error = dm_value - dd_value;
-              // Take care of correctly handling the range [-0.5, -0.0], which
-              // must yield -0.0.
-              if ((-0.5 <= dm_value) && (dm_value < 0.0)) {
-                dd_value = -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(dd_value, 2) != 0))) {
-                dd_value++;
-              }
+              dd_value = nearbyint(dm_value);
               break;
             }
             case 0x2:  // vrintp - ceil
-              dd_value = std::ceil(dm_value);
+              dd_value = ceil(dm_value);
               break;
             case 0x3:  // vrintm - floor
-              dd_value = std::floor(dm_value);
+              dd_value = floor(dm_value);
               break;
             default:
               UNREACHABLE();  // Case analysis is exhaustive.
               break;
           }
           dd_value = canonicalizeNaN(dd_value);
           set_d_register_from_double(vd, dd_value);
         } else {
           int m = instr->VFPMRegValue(kSinglePrecision);
           int d = instr->VFPDRegValue(kSinglePrecision);
@@ skipping 272 matching lines @@
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM