Migrate Math.Min/Max to CodeStubAssembler

src/builtins/builtins-math.cc

 // Copyright 2016 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 <limits>
+
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/counters.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 472 matching lines @@
 // ES6 section 20.2.2.34 Math.tanh ( x )
 TF_BUILTIN(MathTanh, MathBuiltinsAssembler) {
   MathUnaryOperation(&CodeStubAssembler::Float64Tanh);
 }
 
 // ES6 section 20.2.2.35 Math.trunc ( x )
 TF_BUILTIN(MathTrunc, MathBuiltinsAssembler) {
   MathRoundingOperation(&CodeStubAssembler::Float64Trunc);
 }
 
-void Builtins::Generate_MathMax(MacroAssembler* masm) {
-  Generate_MathMaxMin(masm, MathMaxMinKind::kMax);
+// ES6 section 20.2.2.24 Math.max ( value1, value2 , ...values )
+TF_BUILTIN(MathMax, MathBuiltinsAssembler) {
+  Label return_result(this), return_nan(this);
+
+  Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
+  Node* context = Parameter(BuiltinDescriptor::kContext);
+
+  CodeStubArguments arguments(this, ChangeInt32ToIntPtr(argc));
+  // From now on use word-size argc value.
+  argc = arguments.GetLength();
+
+  // If no arguments are given, the result is -infinity.
+  Variable result(this, MachineRepresentation::kFloat64);
+  result.Bind(Float64Constant(-1.0 * V8_INFINITY));
+  GotoIf(IntPtrEqual(argc, IntPtrConstant(0)), &return_result);
+
+  Node* nan = Float64Constant(std::numeric_limits<double>::quiet_NaN());
+  CodeStubAssembler::VariableList vars({&result}, zone());
+  arguments.ForEach(vars,
+                    [this, context, nan, &result, &return_nan](Node* arg) {
+                      Node* float_value = TruncateTaggedToFloat64(context, arg);
+                      GotoIf(Float64Equal(float_value, nan), &return_nan);

[vabr (Chromium), 2017/03/03 10:39:14]

Interestingly, when I remove this jump, the performance of max drops to about
490ms, similar to the 480ms of min.
(Still no idea why even the min jumped up from 430ms after this change.)

I need to follow the spec on returning NaN if some of the numbers are NaN, but
that can be arranged without the jump if I'm fine with finishing the whole loop
in all cases.

+                      result.Bind(Float64Max(result.value(), float_value));
+                    });
+
+  Goto(&return_result);
+  Bind(&return_result);
+  { arguments.PopAndReturn(AllocateHeapNumberWithValue(result.value())); }
+
+  Bind(&return_nan);
+  { arguments.PopAndReturn(AllocateHeapNumberWithValue(nan)); }
 }
 
 void Builtins::Generate_MathMin(MacroAssembler* masm) {
   Generate_MathMaxMin(masm, MathMaxMinKind::kMin);
 }
 
 }  // namespace internal
 }  // namespace v8