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

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/bootstrapper.h"
@@ skipping 1029 matching lines @@
   // Shared entry point for floating point multiplication.
   Label do_fmul(assembler), if_lhsisnotnumber(assembler, Label::kDeferred),
       check_rhsisoddball(assembler, Label::kDeferred),
       call_with_oddball_feedback(assembler), call_with_any_feedback(assembler),
       call_multiply_stub(assembler), end(assembler);
   Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64),
       var_rhs_float64(assembler, MachineRepresentation::kFloat64),
       var_result(assembler, MachineRepresentation::kTagged),
       var_type_feedback(assembler, MachineRepresentation::kWord32);
 
-  Node* number_map = assembler->HeapNumberMapConstant();
-
   Label lhs_is_smi(assembler), lhs_is_not_smi(assembler);
   assembler->Branch(assembler->TaggedIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
 
   assembler->Bind(&lhs_is_smi);
   {
     Label rhs_is_smi(assembler), rhs_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(rhs), &rhs_is_smi,
                       &rhs_is_not_smi);
 
     assembler->Bind(&rhs_is_smi);
     {
       // Both {lhs} and {rhs} are Smis. The result is not necessarily a smi,
       // in case of overflow.
       var_result.Bind(assembler->SmiMul(lhs, rhs));
       var_type_feedback.Bind(assembler->Select(
           assembler->TaggedIsSmi(var_result.value()),
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall),
           assembler->Int32Constant(BinaryOperationFeedback::kNumber),
           MachineRepresentation::kWord32));
       assembler->Goto(&end);
     }
 
     assembler->Bind(&rhs_is_not_smi);
     {
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if {rhs} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(rhs_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
                             &check_rhsisoddball);
 
       // Convert {lhs} to a double and multiply it with the value of {rhs}.
       var_lhs_float64.Bind(assembler->SmiToFloat64(lhs));
       var_rhs_float64.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fmul);
     }
   }
 
   assembler->Bind(&lhs_is_not_smi);
   {
     Node* lhs_map = assembler->LoadMap(lhs);
 
     // Check if {lhs} is a HeapNumber.
-    assembler->GotoUnless(assembler->WordEqual(lhs_map, number_map),
+    assembler->GotoUnless(assembler->IsHeapNumberMap(lhs_map),
                           &if_lhsisnotnumber);
 
     // Check if {rhs} is a Smi.
     Label rhs_is_smi(assembler), rhs_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(rhs), &rhs_is_smi,
                       &rhs_is_not_smi);
 
     assembler->Bind(&rhs_is_smi);
     {
       // Convert {rhs} to a double and multiply it with the value of {lhs}.
       var_lhs_float64.Bind(assembler->LoadHeapNumberValue(lhs));
       var_rhs_float64.Bind(assembler->SmiToFloat64(rhs));
       assembler->Goto(&do_fmul);
     }
 
     assembler->Bind(&rhs_is_not_smi);
     {
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if {rhs} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(rhs_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
                             &check_rhsisoddball);
 
       // Both {lhs} and {rhs} are HeapNumbers. Load their values and
       // multiply them.
       var_lhs_float64.Bind(assembler->LoadHeapNumberValue(lhs));
       var_rhs_float64.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fmul);
     }
   }
 
@@ skipping 78 matching lines @@
   // Shared entry point for floating point division.
   Label do_fdiv(assembler), dividend_is_not_number(assembler, Label::kDeferred),
       check_divisor_for_oddball(assembler, Label::kDeferred),
       call_with_oddball_feedback(assembler), call_with_any_feedback(assembler),
       call_divide_stub(assembler), end(assembler);
   Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
       var_divisor_float64(assembler, MachineRepresentation::kFloat64),
       var_result(assembler, MachineRepresentation::kTagged),
       var_type_feedback(assembler, MachineRepresentation::kWord32);
 
-  Node* number_map = assembler->HeapNumberMapConstant();
-
   Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
   assembler->Branch(assembler->TaggedIsSmi(dividend), &dividend_is_smi,
                     &dividend_is_not_smi);
 
   assembler->Bind(&dividend_is_smi);
   {
     Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                       &divisor_is_not_smi);
 
@@ skipping 64 matching lines @@
         var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
         assembler->Goto(&do_fdiv);
       }
     }
 
     assembler->Bind(&divisor_is_not_smi);
     {
       Node* divisor_map = assembler->LoadMap(divisor);
 
       // Check if {divisor} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(divisor_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(divisor_map),
                             &check_divisor_for_oddball);
 
       // Convert {dividend} to a double and divide it with the value of
       // {divisor}.
       var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
       var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
       assembler->Goto(&do_fdiv);
     }
 
     assembler->Bind(&dividend_is_not_smi);
     {
       Node* dividend_map = assembler->LoadMap(dividend);
 
       // Check if {dividend} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(dividend_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(dividend_map),
                             &dividend_is_not_number);
 
       // Check if {divisor} is a Smi.
       Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
       assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                         &divisor_is_not_smi);
 
       assembler->Bind(&divisor_is_smi);
       {
         // Convert {divisor} to a double and use it for a floating point
         // division.
         var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
         var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
         assembler->Goto(&do_fdiv);
       }
 
       assembler->Bind(&divisor_is_not_smi);
       {
         Node* divisor_map = assembler->LoadMap(divisor);
 
         // Check if {divisor} is a HeapNumber.
-        assembler->GotoUnless(assembler->WordEqual(divisor_map, number_map),
+        assembler->GotoUnless(assembler->IsHeapNumberMap(divisor_map),
                               &check_divisor_for_oddball);
 
         // Both {dividend} and {divisor} are HeapNumbers. Load their values
         // and divide them.
         var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
         var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
         assembler->Goto(&do_fdiv);
       }
     }
   }
@@ skipping 78 matching lines @@
   // Shared entry point for floating point division.
   Label do_fmod(assembler), dividend_is_not_number(assembler, Label::kDeferred),
       check_divisor_for_oddball(assembler, Label::kDeferred),
       call_with_oddball_feedback(assembler), call_with_any_feedback(assembler),
       call_modulus_stub(assembler), end(assembler);
   Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
       var_divisor_float64(assembler, MachineRepresentation::kFloat64),
       var_result(assembler, MachineRepresentation::kTagged),
       var_type_feedback(assembler, MachineRepresentation::kWord32);
 
-  Node* number_map = assembler->HeapNumberMapConstant();
-
   Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
   assembler->Branch(assembler->TaggedIsSmi(dividend), &dividend_is_smi,
                     &dividend_is_not_smi);
 
   assembler->Bind(&dividend_is_smi);
   {
     Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                       &divisor_is_not_smi);
 
     assembler->Bind(&divisor_is_smi);
     {
       var_result.Bind(assembler->SmiMod(dividend, divisor));
       var_type_feedback.Bind(assembler->Select(
           assembler->TaggedIsSmi(var_result.value()),
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall),
           assembler->Int32Constant(BinaryOperationFeedback::kNumber)));
       assembler->Goto(&end);
     }
 
     assembler->Bind(&divisor_is_not_smi);
     {
       Node* divisor_map = assembler->LoadMap(divisor);
 
       // Check if {divisor} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(divisor_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(divisor_map),
                             &check_divisor_for_oddball);
 
       // Convert {dividend} to a double and divide it with the value of
       // {divisor}.
       var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
       var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
       assembler->Goto(&do_fmod);
     }
   }
 
   assembler->Bind(&dividend_is_not_smi);
   {
     Node* dividend_map = assembler->LoadMap(dividend);
 
     // Check if {dividend} is a HeapNumber.
-    assembler->GotoUnless(assembler->WordEqual(dividend_map, number_map),
+    assembler->GotoUnless(assembler->IsHeapNumberMap(dividend_map),
                           &dividend_is_not_number);
 
     // Check if {divisor} is a Smi.
     Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
     assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                       &divisor_is_not_smi);
 
     assembler->Bind(&divisor_is_smi);
     {
       // Convert {divisor} to a double and use it for a floating point
       // division.
       var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
       var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
       assembler->Goto(&do_fmod);
     }
 
     assembler->Bind(&divisor_is_not_smi);
     {
       Node* divisor_map = assembler->LoadMap(divisor);
 
       // Check if {divisor} is a HeapNumber.
-      assembler->GotoUnless(assembler->WordEqual(divisor_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(divisor_map),
                             &check_divisor_for_oddball);
 
       // Both {dividend} and {divisor} are HeapNumbers. Load their values
       // and divide them.
       var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
       var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
       assembler->Goto(&do_fmod);
     }
   }
 
@@ skipping 1700 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8