[stubs] Use CSA::IsHeapNumberMap() instead of manual map comparing.

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 {
@@ skipping 971 matching lines @@
       }
     }
 
     Bind(&if_lhsisnotsmi);
     {
       // Load the map of the {lhs}.
       Node* lhs_map = LoadMap(lhs);
 
       // Check if the {lhs} is a HeapNumber.
       Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred);
-      Node* number_map = HeapNumberMapConstant();
-      Branch(WordEqual(lhs_map, number_map), &if_lhsisnumber,
-             &if_lhsisnotnumber);
+      Branch(IsHeapNumberMap(lhs_map), &if_lhsisnumber, &if_lhsisnotnumber);
 
       Bind(&if_lhsisnumber);
       {
         // Check if the {rhs} is a Smi.
         Label if_rhsissmi(this), if_rhsisnotsmi(this);
         Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
 
         Bind(&if_rhsissmi);
         {
           // Perform a floating point subtraction.
           var_fsub_lhs.Bind(LoadHeapNumberValue(lhs));
           var_fsub_rhs.Bind(SmiToFloat64(rhs));
           Goto(&do_fsub);
         }
 
         Bind(&if_rhsisnotsmi);
         {
           // Load the map of the {rhs}.
           Node* rhs_map = LoadMap(rhs);
 
           // Check if the {rhs} is a HeapNumber.
           Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred);
-          Branch(WordEqual(rhs_map, number_map), &if_rhsisnumber,
-                 &if_rhsisnotnumber);
+          Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber);
 
           Bind(&if_rhsisnumber);
           {
             // Perform a floating point subtraction.
             var_fsub_lhs.Bind(LoadHeapNumberValue(lhs));
             var_fsub_rhs.Bind(LoadHeapNumberValue(rhs));
             Goto(&do_fsub);
           }
 
           Bind(&if_rhsisnotnumber);
@@ skipping 31 matching lines @@
 TF_BUILTIN(Multiply, CodeStubAssembler) {
   Node* left = Parameter(0);
   Node* right = Parameter(1);
   Node* context = Parameter(2);
 
   // Shared entry point for floating point multiplication.
   Label do_fmul(this), return_result(this);
   Variable var_lhs_float64(this, MachineRepresentation::kFloat64),
       var_rhs_float64(this, MachineRepresentation::kFloat64);
 
-  Node* number_map = HeapNumberMapConstant();
-
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_lhs(this, MachineRepresentation::kTagged),
       var_rhs(this, MachineRepresentation::kTagged),
       var_result(this, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_lhs, &var_rhs};
   Label loop(this, 2, loop_variables);
   var_lhs.Bind(left);
   var_rhs.Bind(right);
   Goto(&loop);
   Bind(&loop);
@@ skipping 16 matching lines @@
         var_result.Bind(SmiMul(lhs, rhs));
         Goto(&return_result);
       }
 
       Bind(&rhs_is_not_smi);
       {
         Node* rhs_map = LoadMap(rhs);
 
         // Check if {rhs} is a HeapNumber.
         Label rhs_is_number(this), rhs_is_not_number(this, Label::kDeferred);
-        Branch(WordEqual(rhs_map, number_map), &rhs_is_number,
-               &rhs_is_not_number);
+        Branch(IsHeapNumberMap(rhs_map), &rhs_is_number, &rhs_is_not_number);
 
         Bind(&rhs_is_number);
         {
           // Convert {lhs} to a double and multiply it with the value of {rhs}.
           var_lhs_float64.Bind(SmiToFloat64(lhs));
           var_rhs_float64.Bind(LoadHeapNumberValue(rhs));
           Goto(&do_fmul);
         }
 
         Bind(&rhs_is_not_number);
         {
           // Multiplication is commutative, swap {lhs} with {rhs} and loop.
           var_lhs.Bind(rhs);
           var_rhs.Bind(lhs);
           Goto(&loop);
         }
       }
     }
 
     Bind(&lhs_is_not_smi);
     {
       Node* lhs_map = LoadMap(lhs);
 
       // Check if {lhs} is a HeapNumber.
       Label lhs_is_number(this), lhs_is_not_number(this, Label::kDeferred);
-      Branch(WordEqual(lhs_map, number_map), &lhs_is_number,
-             &lhs_is_not_number);
+      Branch(IsHeapNumberMap(lhs_map), &lhs_is_number, &lhs_is_not_number);
 
       Bind(&lhs_is_number);
       {
         // Check if {rhs} is a Smi.
         Label rhs_is_smi(this), rhs_is_not_smi(this);
         Branch(TaggedIsSmi(rhs), &rhs_is_smi, &rhs_is_not_smi);
 
         Bind(&rhs_is_smi);
         {
           // Convert {rhs} to a double and multiply it with the value of {lhs}.
           var_lhs_float64.Bind(LoadHeapNumberValue(lhs));
           var_rhs_float64.Bind(SmiToFloat64(rhs));
           Goto(&do_fmul);
         }
 
         Bind(&rhs_is_not_smi);
         {
           Node* rhs_map = LoadMap(rhs);
 
           // Check if {rhs} is a HeapNumber.
           Label rhs_is_number(this), rhs_is_not_number(this, Label::kDeferred);
-          Branch(WordEqual(rhs_map, number_map), &rhs_is_number,
-                 &rhs_is_not_number);
+          Branch(IsHeapNumberMap(rhs_map), &rhs_is_number, &rhs_is_not_number);
 
           Bind(&rhs_is_number);
           {
             // Both {lhs} and {rhs} are HeapNumbers. Load their values and
             // multiply them.
             var_lhs_float64.Bind(LoadHeapNumberValue(lhs));
             var_rhs_float64.Bind(LoadHeapNumberValue(rhs));
             Goto(&do_fmul);
           }
 
@@ skipping 32 matching lines @@
 TF_BUILTIN(Divide, CodeStubAssembler) {
   Node* left = Parameter(0);
   Node* right = Parameter(1);
   Node* context = Parameter(2);
 
   // Shared entry point for floating point division.
   Label do_fdiv(this), end(this);
   Variable var_dividend_float64(this, MachineRepresentation::kFloat64),
       var_divisor_float64(this, MachineRepresentation::kFloat64);
 
-  Node* number_map = HeapNumberMapConstant();
-
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_dividend(this, MachineRepresentation::kTagged),
       var_divisor(this, MachineRepresentation::kTagged),
       var_result(this, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_dividend, &var_divisor};
   Label loop(this, 2, loop_variables);
   var_dividend.Bind(left);
   var_divisor.Bind(right);
   Goto(&loop);
   Bind(&loop);
@@ skipping 68 matching lines @@
         }
       }
 
       Bind(&divisor_is_not_smi);
       {
         Node* divisor_map = LoadMap(divisor);
 
         // Check if {divisor} is a HeapNumber.
         Label divisor_is_number(this),
             divisor_is_not_number(this, Label::kDeferred);
-        Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
+        Branch(IsHeapNumberMap(divisor_map), &divisor_is_number,
                &divisor_is_not_number);
 
         Bind(&divisor_is_number);
         {
           // Convert {dividend} to a double and divide it with the value of
           // {divisor}.
           var_dividend_float64.Bind(SmiToFloat64(dividend));
           var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
           Goto(&do_fdiv);
         }
 
         Bind(&divisor_is_not_number);
         {
           // Convert {divisor} to a number and loop.
           Callable callable = CodeFactory::NonNumberToNumber(isolate());
           var_divisor.Bind(CallStub(callable, context, divisor));
           Goto(&loop);
         }
       }
     }
 
     Bind(&dividend_is_not_smi);
     {
       Node* dividend_map = LoadMap(dividend);
 
       // Check if {dividend} is a HeapNumber.
       Label dividend_is_number(this),
           dividend_is_not_number(this, Label::kDeferred);
-      Branch(WordEqual(dividend_map, number_map), &dividend_is_number,
+      Branch(IsHeapNumberMap(dividend_map), &dividend_is_number,
              &dividend_is_not_number);
 
       Bind(&dividend_is_number);
       {
         // Check if {divisor} is a Smi.
         Label divisor_is_smi(this), divisor_is_not_smi(this);
         Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
 
         Bind(&divisor_is_smi);
         {
           // Convert {divisor} to a double and use it for a floating point
           // division.
           var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
           var_divisor_float64.Bind(SmiToFloat64(divisor));
           Goto(&do_fdiv);
         }
 
         Bind(&divisor_is_not_smi);
         {
           Node* divisor_map = LoadMap(divisor);
 
           // Check if {divisor} is a HeapNumber.
           Label divisor_is_number(this),
               divisor_is_not_number(this, Label::kDeferred);
-          Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
+          Branch(IsHeapNumberMap(divisor_map), &divisor_is_number,
                  &divisor_is_not_number);
 
           Bind(&divisor_is_number);
           {
             // Both {dividend} and {divisor} are HeapNumbers. Load their values
             // and divide them.
             var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
             var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
             Goto(&do_fdiv);
           }
@@ skipping 35 matching lines @@
   Node* context = Parameter(2);
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Label return_result(this, &var_result);
 
   // Shared entry point for floating point modulus.
   Label do_fmod(this);
   Variable var_dividend_float64(this, MachineRepresentation::kFloat64),
       var_divisor_float64(this, MachineRepresentation::kFloat64);
 
-  Node* number_map = HeapNumberMapConstant();
-
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_dividend(this, MachineRepresentation::kTagged),
       var_divisor(this, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_dividend, &var_divisor};
   Label loop(this, 2, loop_variables);
   var_dividend.Bind(left);
   var_divisor.Bind(right);
   Goto(&loop);
   Bind(&loop);
   {
@@ skipping 16 matching lines @@
         Goto(&return_result);
       }
 
       Bind(&divisor_is_not_smi);
       {
         Node* divisor_map = LoadMap(divisor);
 
         // Check if {divisor} is a HeapNumber.
         Label divisor_is_number(this),
             divisor_is_not_number(this, Label::kDeferred);
-        Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
+        Branch(IsHeapNumberMap(divisor_map), &divisor_is_number,
                &divisor_is_not_number);
 
         Bind(&divisor_is_number);
         {
           // Convert {dividend} to a double and compute its modulus with the
           // value of {dividend}.
           var_dividend_float64.Bind(SmiToFloat64(dividend));
           var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
           Goto(&do_fmod);
         }
 
         Bind(&divisor_is_not_number);
         {
           // Convert {divisor} to a number and loop.
           Callable callable = CodeFactory::NonNumberToNumber(isolate());
           var_divisor.Bind(CallStub(callable, context, divisor));
           Goto(&loop);
         }
       }
     }
 
     Bind(&dividend_is_not_smi);
     {
       Node* dividend_map = LoadMap(dividend);
 
       // Check if {dividend} is a HeapNumber.
       Label dividend_is_number(this),
           dividend_is_not_number(this, Label::kDeferred);
-      Branch(WordEqual(dividend_map, number_map), &dividend_is_number,
+      Branch(IsHeapNumberMap(dividend_map), &dividend_is_number,
              &dividend_is_not_number);
 
       Bind(&dividend_is_number);
       {
         // Check if {divisor} is a Smi.
         Label divisor_is_smi(this), divisor_is_not_smi(this);
         Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
 
         Bind(&divisor_is_smi);
         {
           // Convert {divisor} to a double and compute {dividend}'s modulus with
           // it.
           var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
           var_divisor_float64.Bind(SmiToFloat64(divisor));
           Goto(&do_fmod);
         }
 
         Bind(&divisor_is_not_smi);
         {
           Node* divisor_map = LoadMap(divisor);
 
           // Check if {divisor} is a HeapNumber.
           Label divisor_is_number(this),
               divisor_is_not_number(this, Label::kDeferred);
-          Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
+          Branch(IsHeapNumberMap(divisor_map), &divisor_is_number,
                  &divisor_is_not_number);
 
           Bind(&divisor_is_number);
           {
             // Both {dividend} and {divisor} are HeapNumbers. Load their values
             // and compute their modulus.
             var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
             var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
             Goto(&do_fmod);
           }
@@ skipping 103 matching lines @@
 TF_BUILTIN(StrictNotEqual, CodeStubAssembler) {
   Node* lhs = Parameter(0);
   Node* rhs = Parameter(1);
   Node* context = Parameter(2);
 
   Return(StrictEqual(kNegateResult, lhs, rhs, context));
 }
 
 }  // namespace internal
 }  // namespace v8