[turbofan] Add Float32(Max|Min) machine operators.

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 1361 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: {
+      FloatRegister left_reg = i.InputFloat32Register(0);
+      FloatRegister right_reg = i.InputFloat32Register(1);
+      FloatRegister result_reg = i.OutputFloat32Register();
+      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 kArmFloat64Max: {
       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.
@@ skipping 12 matching lines @@
       __ 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 kArmFloat32Min: {
+      FloatRegister left_reg = i.InputFloat32Register(0);
+      FloatRegister right_reg = i.InputFloat32Register(1);
+      FloatRegister result_reg = i.OutputFloat32Register();
+      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 kArmFloat64Min: {
       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.
@@ skipping 534 matching lines @@
       padding_size -= v8::internal::Assembler::kInstrSize;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8