[cleanup] Refactor builtins-number.cc

src/builtins/builtins-number.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"
 
 namespace v8 {
 namespace internal {
 
+class NumberBuiltinsAssembler : public CodeStubAssembler {
+ public:
+  explicit NumberBuiltinsAssembler(compiler::CodeAssemblerState* state)
+      : CodeStubAssembler(state) {}
+
+ protected:
+  // TODO(jkummerow): Add useful helpers here, and derive from
+  // NumberBuiltinsAssembler below.
+};
+
 // -----------------------------------------------------------------------------
 // ES6 section 20.1 Number Objects
 
 // ES6 section 20.1.2.2 Number.isFinite ( number )
-void Builtins::Generate_NumberIsFinite(compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
-
-  Node* number = assembler.Parameter(1);
-
-  Label return_true(&assembler), return_false(&assembler);
-
-  // Check if {number} is a Smi.
-  assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
-
-  // Check if {number} is a HeapNumber.
-  assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
-                                           assembler.HeapNumberMapConstant()),
-                       &return_false);
+TF_BUILTIN(NumberIsFinite, CodeStubAssembler) {
+  Node* number = Parameter(1);
+
+  Label return_true(this), return_false(this);
+
+  // Check if {number} is a Smi.
+  GotoIf(TaggedIsSmi(number), &return_true);
+
+  // Check if {number} is a HeapNumber.
+  GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+             &return_false);
 
   // Check if {number} contains a finite, non-NaN value.
-  Node* number_value = assembler.LoadHeapNumberValue(number);
-  assembler.BranchIfFloat64IsNaN(
-      assembler.Float64Sub(number_value, number_value), &return_false,
-      &return_true);
-
-  assembler.Bind(&return_true);
-  assembler.Return(assembler.BooleanConstant(true));
-
-  assembler.Bind(&return_false);
-  assembler.Return(assembler.BooleanConstant(false));
+  Node* number_value = LoadHeapNumberValue(number);
+  BranchIfFloat64IsNaN(Float64Sub(number_value, number_value), &return_false,
+                       &return_true);
+
+  Bind(&return_true);
+  Return(BooleanConstant(true));
+
+  Bind(&return_false);
+  Return(BooleanConstant(false));
 }
 
 // ES6 section 20.1.2.3 Number.isInteger ( number )
-void Builtins::Generate_NumberIsInteger(compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
-
-  Node* number = assembler.Parameter(1);
-
-  Label return_true(&assembler), return_false(&assembler);
-
-  // Check if {number} is a Smi.
-  assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
-
-  // Check if {number} is a HeapNumber.
-  assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
-                                           assembler.HeapNumberMapConstant()),
-                       &return_false);
+TF_BUILTIN(NumberIsInteger, CodeStubAssembler) {
+  Node* number = Parameter(1);
+
+  Label return_true(this), return_false(this);
+
+  // Check if {number} is a Smi.
+  GotoIf(TaggedIsSmi(number), &return_true);
+
+  // Check if {number} is a HeapNumber.
+  GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+             &return_false);
 
   // Load the actual value of {number}.
-  Node* number_value = assembler.LoadHeapNumberValue(number);
+  Node* number_value = LoadHeapNumberValue(number);
 
   // Truncate the value of {number} to an integer (or an infinity).
-  Node* integer = assembler.Float64Trunc(number_value);
+  Node* integer = Float64Trunc(number_value);
 
   // Check if {number}s value matches the integer (ruling out the infinities).
-  assembler.Branch(
-      assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
-                             assembler.Float64Constant(0.0)),
-      &return_true, &return_false);
-
-  assembler.Bind(&return_true);
-  assembler.Return(assembler.BooleanConstant(true));
-
-  assembler.Bind(&return_false);
-  assembler.Return(assembler.BooleanConstant(false));
+  Branch(Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
+         &return_true, &return_false);
+
+  Bind(&return_true);
+  Return(BooleanConstant(true));
+
+  Bind(&return_false);
+  Return(BooleanConstant(false));
 }
 
 // ES6 section 20.1.2.4 Number.isNaN ( number )
-void Builtins::Generate_NumberIsNaN(compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
-
-  Node* number = assembler.Parameter(1);
-
-  Label return_true(&assembler), return_false(&assembler);
-
-  // Check if {number} is a Smi.
-  assembler.GotoIf(assembler.TaggedIsSmi(number), &return_false);
-
-  // Check if {number} is a HeapNumber.
-  assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
-                                           assembler.HeapNumberMapConstant()),
-                       &return_false);
+TF_BUILTIN(NumberIsNaN, CodeStubAssembler) {
+  Node* number = Parameter(1);
+
+  Label return_true(this), return_false(this);
+
+  // Check if {number} is a Smi.
+  GotoIf(TaggedIsSmi(number), &return_false);
+
+  // Check if {number} is a HeapNumber.
+  GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+             &return_false);
 
   // Check if {number} contains a NaN value.
-  Node* number_value = assembler.LoadHeapNumberValue(number);
-  assembler.BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
-
-  assembler.Bind(&return_true);
-  assembler.Return(assembler.BooleanConstant(true));
-
-  assembler.Bind(&return_false);
-  assembler.Return(assembler.BooleanConstant(false));
+  Node* number_value = LoadHeapNumberValue(number);
+  BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
+
+  Bind(&return_true);
+  Return(BooleanConstant(true));
+
+  Bind(&return_false);
+  Return(BooleanConstant(false));
 }
 
 // ES6 section 20.1.2.5 Number.isSafeInteger ( number )
-void Builtins::Generate_NumberIsSafeInteger(
-    compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
-
-  Node* number = assembler.Parameter(1);
-
-  Label return_true(&assembler), return_false(&assembler);
-
-  // Check if {number} is a Smi.
-  assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
-
-  // Check if {number} is a HeapNumber.
-  assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
-                                           assembler.HeapNumberMapConstant()),
-                       &return_false);
+TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) {
+  Node* number = Parameter(1);
+
+  Label return_true(this), return_false(this);
+
+  // Check if {number} is a Smi.
+  GotoIf(TaggedIsSmi(number), &return_true);
+
+  // Check if {number} is a HeapNumber.
+  GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+             &return_false);
 
   // Load the actual value of {number}.
-  Node* number_value = assembler.LoadHeapNumberValue(number);
+  Node* number_value = LoadHeapNumberValue(number);
 
   // Truncate the value of {number} to an integer (or an infinity).
-  Node* integer = assembler.Float64Trunc(number_value);
+  Node* integer = Float64Trunc(number_value);
 
   // Check if {number}s value matches the integer (ruling out the infinities).
-  assembler.GotoUnless(
-      assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
-                             assembler.Float64Constant(0.0)),
+  GotoUnless(
+      Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
       &return_false);
 
   // Check if the {integer} value is in safe integer range.
-  assembler.Branch(assembler.Float64LessThanOrEqual(
-                       assembler.Float64Abs(integer),
-                       assembler.Float64Constant(kMaxSafeInteger)),
-                   &return_true, &return_false);
-
-  assembler.Bind(&return_true);
-  assembler.Return(assembler.BooleanConstant(true));
-
-  assembler.Bind(&return_false);
-  assembler.Return(assembler.BooleanConstant(false));
+  Branch(Float64LessThanOrEqual(Float64Abs(integer),
+                                Float64Constant(kMaxSafeInteger)),
+         &return_true, &return_false);
+
+  Bind(&return_true);
+  Return(BooleanConstant(true));
+
+  Bind(&return_false);
+  Return(BooleanConstant(false));
 }
 
 // ES6 section 20.1.2.12 Number.parseFloat ( string )
-void Builtins::Generate_NumberParseFloat(compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  typedef CodeStubAssembler::Variable Variable;
-  CodeStubAssembler assembler(state);
-
-  Node* context = assembler.Parameter(4);
+TF_BUILTIN(NumberParseFloat, CodeStubAssembler) {
+  Node* context = Parameter(4);
 
   // We might need to loop once for ToString conversion.
-  Variable var_input(&assembler, MachineRepresentation::kTagged);
-  Label loop(&assembler, &var_input);
-  var_input.Bind(assembler.Parameter(1));
-  assembler.Goto(&loop);
-  assembler.Bind(&loop);
+  Variable var_input(this, MachineRepresentation::kTagged);
+  Label loop(this, &var_input);
+  var_input.Bind(Parameter(1));
+  Goto(&loop);
+  Bind(&loop);
   {
     // Load the current {input} value.
     Node* input = var_input.value();
 
     // Check if the {input} is a HeapObject or a Smi.
-    Label if_inputissmi(&assembler), if_inputisnotsmi(&assembler);
-    assembler.Branch(assembler.TaggedIsSmi(input), &if_inputissmi,
-                     &if_inputisnotsmi);
-
-    assembler.Bind(&if_inputissmi);
+    Label if_inputissmi(this), if_inputisnotsmi(this);
+    Branch(TaggedIsSmi(input), &if_inputissmi, &if_inputisnotsmi);
+
+    Bind(&if_inputissmi);
     {
       // The {input} is already a Number, no need to do anything.
-      assembler.Return(input);
+      Return(input);
     }
 
-    assembler.Bind(&if_inputisnotsmi);
+    Bind(&if_inputisnotsmi);
     {
       // The {input} is a HeapObject, check if it's already a String.
-      Label if_inputisstring(&assembler), if_inputisnotstring(&assembler);
-      Node* input_map = assembler.LoadMap(input);
-      Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
-      assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
-                       &if_inputisstring, &if_inputisnotstring);
-
-      assembler.Bind(&if_inputisstring);
+      Label if_inputisstring(this), if_inputisnotstring(this);
+      Node* input_map = LoadMap(input);
+      Node* input_instance_type = LoadMapInstanceType(input_map);
+      Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
+             &if_inputisnotstring);
+
+      Bind(&if_inputisstring);
       {
         // The {input} is already a String, check if {input} contains
         // a cached array index.
-        Label if_inputcached(&assembler), if_inputnotcached(&assembler);
-        Node* input_hash = assembler.LoadNameHashField(input);
-        Node* input_bit = assembler.Word32And(
-            input_hash,
-            assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
-        assembler.Branch(
-            assembler.Word32Equal(input_bit, assembler.Int32Constant(0)),
-            &if_inputcached, &if_inputnotcached);
-
-        assembler.Bind(&if_inputcached);
+        Label if_inputcached(this), if_inputnotcached(this);
+        Node* input_hash = LoadNameHashField(input);
+        Node* input_bit = Word32And(
+            input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
+        Branch(Word32Equal(input_bit, Int32Constant(0)), &if_inputcached,
+               &if_inputnotcached);
+
+        Bind(&if_inputcached);
         {
           // Just return the {input}s cached array index.
           Node* input_array_index =
-              assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
-                  input_hash);
-          assembler.Return(assembler.SmiTag(input_array_index));
-        }
-
-        assembler.Bind(&if_inputnotcached);
+              DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
+          Return(SmiTag(input_array_index));
+        }
+
+        Bind(&if_inputnotcached);
         {
           // Need to fall back to the runtime to convert {input} to double.
-          assembler.Return(assembler.CallRuntime(Runtime::kStringParseFloat,
-                                                 context, input));
+          Return(CallRuntime(Runtime::kStringParseFloat, context, input));
         }
       }
 
-      assembler.Bind(&if_inputisnotstring);
+      Bind(&if_inputisnotstring);
       {
         // The {input} is neither a String nor a Smi, check for HeapNumber.
-        Label if_inputisnumber(&assembler),
-            if_inputisnotnumber(&assembler, Label::kDeferred);
-        assembler.Branch(
-            assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
-            &if_inputisnumber, &if_inputisnotnumber);
-
-        assembler.Bind(&if_inputisnumber);
+        Label if_inputisnumber(this),
+            if_inputisnotnumber(this, Label::kDeferred);
+        Branch(WordEqual(input_map, HeapNumberMapConstant()), &if_inputisnumber,
+               &if_inputisnotnumber);
+
+        Bind(&if_inputisnumber);
         {
           // The {input} is already a Number, take care of -0.
-          Label if_inputiszero(&assembler), if_inputisnotzero(&assembler);
-          Node* input_value = assembler.LoadHeapNumberValue(input);
-          assembler.Branch(assembler.Float64Equal(
-                               input_value, assembler.Float64Constant(0.0)),
-                           &if_inputiszero, &if_inputisnotzero);
-
-          assembler.Bind(&if_inputiszero);
-          assembler.Return(assembler.SmiConstant(0));
-
-          assembler.Bind(&if_inputisnotzero);
-          assembler.Return(input);
-        }
-
-        assembler.Bind(&if_inputisnotnumber);
+          Label if_inputiszero(this), if_inputisnotzero(this);
+          Node* input_value = LoadHeapNumberValue(input);
+          Branch(Float64Equal(input_value, Float64Constant(0.0)),
+                 &if_inputiszero, &if_inputisnotzero);
+
+          Bind(&if_inputiszero);
+          Return(SmiConstant(0));
+
+          Bind(&if_inputisnotzero);
+          Return(input);
+        }
+
+        Bind(&if_inputisnotnumber);
         {
           // Need to convert the {input} to String first.
           // TODO(bmeurer): This could be more efficient if necessary.
-          Callable callable = CodeFactory::ToString(assembler.isolate());
-          var_input.Bind(assembler.CallStub(callable, context, input));
-          assembler.Goto(&loop);
+          Callable callable = CodeFactory::ToString(isolate());
+          var_input.Bind(CallStub(callable, context, input));
+          Goto(&loop);
         }
       }
     }
   }
 }
 
 // ES6 section 20.1.2.13 Number.parseInt ( string, radix )
-void Builtins::Generate_NumberParseInt(compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
-
-  Node* input = assembler.Parameter(1);
-  Node* radix = assembler.Parameter(2);
-  Node* context = assembler.Parameter(5);
+TF_BUILTIN(NumberParseInt, CodeStubAssembler) {
+  Node* input = Parameter(1);
+  Node* radix = Parameter(2);
+  Node* context = Parameter(5);
 
   // Check if {radix} is treated as 10 (i.e. undefined, 0 or 10).
-  Label if_radix10(&assembler), if_generic(&assembler, Label::kDeferred);
-  assembler.GotoIf(assembler.WordEqual(radix, assembler.UndefinedConstant()),
-                   &if_radix10);
-  assembler.GotoIf(
-      assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(10))),
-      &if_radix10);
-  assembler.GotoIf(
-      assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(0))),
-      &if_radix10);
-  assembler.Goto(&if_generic);
+  Label if_radix10(this), if_generic(this, Label::kDeferred);
+  GotoIf(WordEqual(radix, UndefinedConstant()), &if_radix10);
+  GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(10))), &if_radix10);
+  GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(0))), &if_radix10);
+  Goto(&if_generic);
 
-  assembler.Bind(&if_radix10);
+  Bind(&if_radix10);
   {
     // Check if we can avoid the ToString conversion on {input}.
-    Label if_inputissmi(&assembler), if_inputisheapnumber(&assembler),
-        if_inputisstring(&assembler);
-    assembler.GotoIf(assembler.TaggedIsSmi(input), &if_inputissmi);
-    Node* input_map = assembler.LoadMap(input);
-    assembler.GotoIf(
-        assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
-        &if_inputisheapnumber);
-    Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
-    assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
-                     &if_inputisstring, &if_generic);
+    Label if_inputissmi(this), if_inputisheapnumber(this),
+        if_inputisstring(this);
+    GotoIf(TaggedIsSmi(input), &if_inputissmi);
+    Node* input_map = LoadMap(input);
+    GotoIf(WordEqual(input_map, HeapNumberMapConstant()),
+           &if_inputisheapnumber);
+    Node* input_instance_type = LoadMapInstanceType(input_map);
+    Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
+           &if_generic);
 
-    assembler.Bind(&if_inputissmi);
+    Bind(&if_inputissmi);
     {
       // Just return the {input}.
-      assembler.Return(input);
+      Return(input);
     }
 
-    assembler.Bind(&if_inputisheapnumber);
+    Bind(&if_inputisheapnumber);
     {
       // Check if the {input} value is in Signed32 range.
-      Label if_inputissigned32(&assembler);
-      Node* input_value = assembler.LoadHeapNumberValue(input);
-      Node* input_value32 = assembler.TruncateFloat64ToWord32(input_value);
-      assembler.GotoIf(
-          assembler.Float64Equal(input_value,
-                                 assembler.ChangeInt32ToFloat64(input_value32)),
-          &if_inputissigned32);
+      Label if_inputissigned32(this);
+      Node* input_value = LoadHeapNumberValue(input);
+      Node* input_value32 = TruncateFloat64ToWord32(input_value);
+      GotoIf(Float64Equal(input_value, ChangeInt32ToFloat64(input_value32)),
+             &if_inputissigned32);
 
       // Check if the absolute {input} value is in the ]0.01,1e9[ range.
-      Node* input_value_abs = assembler.Float64Abs(input_value);
+      Node* input_value_abs = Float64Abs(input_value);
 
-      assembler.GotoUnless(assembler.Float64LessThan(
-                               input_value_abs, assembler.Float64Constant(1e9)),
-                           &if_generic);
-      assembler.Branch(assembler.Float64LessThan(
-                           assembler.Float64Constant(0.01), input_value_abs),
-                       &if_inputissigned32, &if_generic);
+      GotoUnless(Float64LessThan(input_value_abs, Float64Constant(1e9)),
+                 &if_generic);
+      Branch(Float64LessThan(Float64Constant(0.01), input_value_abs),
+             &if_inputissigned32, &if_generic);
 
       // Return the truncated int32 value, and return the tagged result.
-      assembler.Bind(&if_inputissigned32);
-      Node* result = assembler.ChangeInt32ToTagged(input_value32);
-      assembler.Return(result);
+      Bind(&if_inputissigned32);
+      Node* result = ChangeInt32ToTagged(input_value32);
+      Return(result);
     }
 
-    assembler.Bind(&if_inputisstring);
+    Bind(&if_inputisstring);
     {
       // Check if the String {input} has a cached array index.
-      Node* input_hash = assembler.LoadNameHashField(input);
-      Node* input_bit = assembler.Word32And(
-          input_hash,
-          assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
-      assembler.GotoIf(
-          assembler.Word32NotEqual(input_bit, assembler.Int32Constant(0)),
-          &if_generic);
+      Node* input_hash = LoadNameHashField(input);
+      Node* input_bit = Word32And(
+          input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
+      GotoIf(Word32NotEqual(input_bit, Int32Constant(0)), &if_generic);
 
       // Return the cached array index as result.
       Node* input_index =
-          assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
-              input_hash);
-      Node* result = assembler.SmiTag(input_index);
-      assembler.Return(result);
+          DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
+      Node* result = SmiTag(input_index);
+      Return(result);
     }
   }
 
-  assembler.Bind(&if_generic);
+  Bind(&if_generic);
   {
-    Node* result =
-        assembler.CallRuntime(Runtime::kStringParseInt, context, input, radix);
-    assembler.Return(result);
+    Node* result = CallRuntime(Runtime::kStringParseInt, context, input, radix);
+    Return(result);
   }
 }
 
 // ES6 section 20.1.3.2 Number.prototype.toExponential ( fractionDigits )
 BUILTIN(NumberPrototypeToExponential) {
   HandleScope scope(isolate);
   Handle<Object> value = args.at<Object>(0);
   Handle<Object> fraction_digits = args.atOrUndefined(isolate, 1);
 
   // Unwrap the receiver {value}.
@@ skipping 1458 matching lines @@
   compiler::Node* lhs = assembler.Parameter(0);
   compiler::Node* rhs = assembler.Parameter(1);
   compiler::Node* context = assembler.Parameter(2);
 
   assembler.Return(assembler.StrictEqual(CodeStubAssembler::kNegateResult, lhs,
                                          rhs, context));
 }
 
 }  // namespace internal
 }  // namespace v8