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 "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 {
 
 // -----------------------------------------------------------------------------
 // ES6 section 20.2.2 Function Properties of the Math Object
 
 class MathBuiltinsAssembler : public CodeStubAssembler {
  public:
   explicit MathBuiltinsAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
  protected:
   void MathRoundingOperation(Node* (CodeStubAssembler::*float64op)(Node*));
   void MathUnaryOperation(Node* (CodeStubAssembler::*float64op)(Node*));
+  void MathMaxMin(Node* (CodeStubAssembler::*float64op)(Node*, Node*),
+                  double default_val);
 };
 
 // ES6 section - 20.2.2.1 Math.abs ( x )
 TF_BUILTIN(MathAbs, CodeStubAssembler) {
   Node* context = Parameter(4);
 
   // We might need to loop once for ToNumber conversion.
   Variable var_x(this, MachineRepresentation::kTagged);
   Label loop(this, &var_x);
   var_x.Bind(Parameter(1));
@@ skipping 120 matching lines @@
 void MathBuiltinsAssembler::MathUnaryOperation(
     Node* (CodeStubAssembler::*float64op)(Node*)) {
   Node* x = Parameter(1);
   Node* context = Parameter(4);
   Node* x_value = TruncateTaggedToFloat64(context, x);
   Node* value = (this->*float64op)(x_value);
   Node* result = AllocateHeapNumberWithValue(value);
   Return(result);
 }
 
+void MathBuiltinsAssembler::MathMaxMin(
+    Node* (CodeStubAssembler::*float64op)(Node*, Node*), double default_val) {
+  Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
+  Node* context = Parameter(BuiltinDescriptor::kContext);
+
+  CodeStubArguments arguments(this, ChangeInt32ToIntPtr(argc));
+  argc = arguments.GetLength();
+
+  Variable result(this, MachineRepresentation::kFloat64);
+  result.Bind(Float64Constant(default_val));
+
+  CodeStubAssembler::VariableList vars({&result}, zone());
+  arguments.ForEach(vars, [this, float64op, context, &result](Node* arg) {
+    Node* float_value = TruncateTaggedToFloat64(context, arg);
+    result.Bind((this->*float64op)(result.value(), float_value));
+  });
+
+  arguments.PopAndReturn(ChangeFloat64ToTagged(result.value()));
+}
+
 // ES6 section 20.2.2.2 Math.acos ( x )
 TF_BUILTIN(MathAcos, MathBuiltinsAssembler) {
   MathUnaryOperation(&CodeStubAssembler::Float64Acos);
 }
 
 // ES6 section 20.2.2.3 Math.acosh ( x )
 TF_BUILTIN(MathAcosh, MathBuiltinsAssembler) {
   MathUnaryOperation(&CodeStubAssembler::Float64Acosh);
 }
 
@@ skipping 311 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) {
+  MathMaxMin(&CodeStubAssembler::Float64Max, -1.0 * V8_INFINITY);
 }
 
-void Builtins::Generate_MathMin(MacroAssembler* masm) {
-  Generate_MathMaxMin(masm, MathMaxMinKind::kMin);
+// ES6 section 20.2.2.25 Math.min ( value1, value2 , ...values )
+TF_BUILTIN(MathMin, MathBuiltinsAssembler) {
+  MathMaxMin(&CodeStubAssembler::Float64Min, V8_INFINITY);
 }
 
 }  // namespace internal
 }  // namespace v8