[turbofan] Change Float64Max/Float64Min to JavaScript semantics.

src/compiler/arm/code-generator-arm.cc

 // Copyright 2014 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 "src/compiler/code-generator.h"
 
 #include "src/arm/macro-assembler-arm.h"
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
@@ skipping 1342 matching lines @@
       DCHECK_EQ(LeaveCC, i.OutputSBit());
       break;
     case kArmVldrF64:
       __ vldr(i.OutputDoubleRegister(), i.InputOffset());
       DCHECK_EQ(LeaveCC, i.OutputSBit());
       break;
     case kArmVstrF64:
       __ vstr(i.InputDoubleRegister(0), i.InputOffset(1));
       DCHECK_EQ(LeaveCC, i.OutputSBit());
       break;
-    case kArmFloat32Max: {
-      CpuFeatureScope scope(masm(), ARMv8);
-      // (b < a) ? a : b
-      SwVfpRegister a = i.InputFloatRegister(0);
-      SwVfpRegister b = i.InputFloatRegister(1);
-      SwVfpRegister result = i.OutputFloatRegister();
-      __ VFPCompareAndSetFlags(a, b);
-      __ vsel(gt, result, a, b);
-      break;
-    }
-    case kArmFloat32Min: {
-      CpuFeatureScope scope(masm(), ARMv8);
-      // (a < b) ? a : b
-      SwVfpRegister a = i.InputFloatRegister(0);
-      SwVfpRegister b = i.InputFloatRegister(1);
-      SwVfpRegister result = i.OutputFloatRegister();
-      __ VFPCompareAndSetFlags(b, a);
-      __ vsel(gt, result, a, b);
-      break;
-    }
     case kArmFloat64Max: {
-      CpuFeatureScope scope(masm(), ARMv8);
-      // (b < a) ? a : b
-      DwVfpRegister a = i.InputDoubleRegister(0);
-      DwVfpRegister b = i.InputDoubleRegister(1);
-      DwVfpRegister result = i.OutputDoubleRegister();
-      __ VFPCompareAndSetFlags(a, b);
-      __ vsel(gt, result, a, b);
+      DwVfpRegister left_reg = i.InputDoubleRegister(0);
+      DwVfpRegister right_reg = i.InputDoubleRegister(1);
+      DwVfpRegister result_reg = i.OutputDoubleRegister();
+      Label result_is_nan, return_left, return_right, check_zero, done;
+      __ VFPCompareAndSetFlags(left_reg, right_reg);
+      __ b(mi, &return_right);
+      __ b(gt, &return_left);
+      __ b(vs, &result_is_nan);
+      // Left equals right => check for -0.
+      __ VFPCompareAndSetFlags(left_reg, 0.0);
+      if (left_reg.is(result_reg) || right_reg.is(result_reg)) {
+        __ b(ne, &done);  // left == right != 0.
+      } else {
+        __ b(ne, &return_left);  // left == right != 0.
+      }
+      // At this point, both left and right are either 0 or -0.
+      // Since we operate on +0 and/or -0, vadd and vand have the same effect;
+      // the decision for vadd is easy because vand is a NEON instruction.
+      __ vadd(result_reg, left_reg, right_reg);
+      __ b(&done);
+      __ bind(&result_is_nan);
+      __ vadd(result_reg, left_reg, right_reg);
+      __ b(&done);
+      __ bind(&return_right);
+      __ Move(result_reg, right_reg);
+      if (!left_reg.is(result_reg)) __ b(&done);
+      __ bind(&return_left);
+      __ Move(result_reg, left_reg);
+      __ bind(&done);
       break;
     }
     case kArmFloat64Min: {
-      CpuFeatureScope scope(masm(), ARMv8);
-      // (a < b) ? a : b
-      DwVfpRegister a = i.InputDoubleRegister(0);
-      DwVfpRegister b = i.InputDoubleRegister(1);
-      DwVfpRegister result = i.OutputDoubleRegister();
-      __ VFPCompareAndSetFlags(b, a);
-      __ vsel(gt, result, a, b);
+      DwVfpRegister left_reg = i.InputDoubleRegister(0);
+      DwVfpRegister right_reg = i.InputDoubleRegister(1);
+      DwVfpRegister result_reg = i.OutputDoubleRegister();
+      Label result_is_nan, return_left, return_right, check_zero, done;
+      __ VFPCompareAndSetFlags(left_reg, right_reg);
+      __ b(mi, &return_left);
+      __ b(gt, &return_right);
+      __ b(vs, &result_is_nan);
+      // Left equals right => check for -0.
+      __ VFPCompareAndSetFlags(left_reg, 0.0);
+      if (left_reg.is(result_reg) || right_reg.is(result_reg)) {
+        __ b(ne, &done);  // left == right != 0.
+      } else {
+        __ b(ne, &return_left);  // left == right != 0.
+      }
+      // At this point, both left and right are either 0 or -0.
+      // We could use a single 'vorr' instruction here if we had NEON support.
+      // The algorithm is: -((-L) + (-R)), which in case of L and R being
+      // different registers is most efficiently expressed as -((-L) - R).
+      __ vneg(left_reg, left_reg);
+      if (left_reg.is(right_reg)) {
+        __ vadd(result_reg, left_reg, right_reg);
+      } else {
+        __ vsub(result_reg, left_reg, right_reg);
+      }
+      __ vneg(result_reg, result_reg);
+      __ b(&done);
+      __ bind(&result_is_nan);
+      __ vadd(result_reg, left_reg, right_reg);
+      __ b(&done);
+      __ bind(&return_right);
+      __ Move(result_reg, right_reg);
+      if (!left_reg.is(result_reg)) __ b(&done);
+      __ bind(&return_left);
+      __ Move(result_reg, left_reg);
+      __ bind(&done);
       break;
     }
     case kArmFloat64SilenceNaN: {
       DwVfpRegister value = i.InputDoubleRegister(0);
       DwVfpRegister result = i.OutputDoubleRegister();
       __ VFPCanonicalizeNaN(result, value);
       break;
     }
     case kArmPush:
       if (instr->InputAt(0)->IsFPRegister()) {
@@ skipping 551 matching lines @@
       padding_size -= v8::internal::Assembler::kInstrSize;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8