[stubs] Renames WordIsSmi to TaggedIsSmi, introducing an appropriate bitcast of the parameter.

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"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // ES6 section 20.1 Number Objects
 
 // ES6 section 20.1.2.2 Number.isFinite ( number )
 void Builtins::Generate_NumberIsFinite(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* number = assembler->Parameter(1);
 
   Label return_true(assembler), return_false(assembler);
 
   // Check if {number} is a Smi.
-  assembler->GotoIf(assembler->WordIsSmi(number), &return_true);
+  assembler->GotoIf(assembler->TaggedIsSmi(number), &return_true);
 
   // Check if {number} is a HeapNumber.
   assembler->GotoUnless(
       assembler->WordEqual(assembler->LoadMap(number),
                            assembler->HeapNumberMapConstant()),
       &return_false);
 
   // Check if {number} contains a finite, non-NaN value.
   Node* number_value = assembler->LoadHeapNumberValue(number);
   assembler->BranchIfFloat64IsNaN(
@@ skipping 10 matching lines @@
 // ES6 section 20.1.2.3 Number.isInteger ( number )
 void Builtins::Generate_NumberIsInteger(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* number = assembler->Parameter(1);
 
   Label return_true(assembler), return_false(assembler);
 
   // Check if {number} is a Smi.
-  assembler->GotoIf(assembler->WordIsSmi(number), &return_true);
+  assembler->GotoIf(assembler->TaggedIsSmi(number), &return_true);
 
   // Check if {number} is a HeapNumber.
   assembler->GotoUnless(
       assembler->WordEqual(assembler->LoadMap(number),
                            assembler->HeapNumberMapConstant()),
       &return_false);
 
   // Load the actual value of {number}.
   Node* number_value = assembler->LoadHeapNumberValue(number);
 
@@ skipping 15 matching lines @@
 // ES6 section 20.1.2.4 Number.isNaN ( number )
 void Builtins::Generate_NumberIsNaN(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* number = assembler->Parameter(1);
 
   Label return_true(assembler), return_false(assembler);
 
   // Check if {number} is a Smi.
-  assembler->GotoIf(assembler->WordIsSmi(number), &return_false);
+  assembler->GotoIf(assembler->TaggedIsSmi(number), &return_false);
 
   // Check if {number} is a HeapNumber.
   assembler->GotoUnless(
       assembler->WordEqual(assembler->LoadMap(number),
                            assembler->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));
 }
 
 // ES6 section 20.1.2.5 Number.isSafeInteger ( number )
 void Builtins::Generate_NumberIsSafeInteger(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* number = assembler->Parameter(1);
 
   Label return_true(assembler), return_false(assembler);
 
   // Check if {number} is a Smi.
-  assembler->GotoIf(assembler->WordIsSmi(number), &return_true);
+  assembler->GotoIf(assembler->TaggedIsSmi(number), &return_true);
 
   // Check if {number} is a HeapNumber.
   assembler->GotoUnless(
       assembler->WordEqual(assembler->LoadMap(number),
                            assembler->HeapNumberMapConstant()),
       &return_false);
 
   // Load the actual value of {number}.
   Node* number_value = assembler->LoadHeapNumberValue(number);
 
@@ skipping 31 matching lines @@
   Label loop(assembler, &var_input);
   var_input.Bind(assembler->Parameter(1));
   assembler->Goto(&loop);
   assembler->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->WordIsSmi(input), &if_inputissmi,
+    assembler->Branch(assembler->TaggedIsSmi(input), &if_inputissmi,
                       &if_inputisnotsmi);
 
     assembler->Bind(&if_inputissmi);
     {
       // The {input} is already a Number, no need to do anything.
       assembler->Return(input);
     }
 
     assembler->Bind(&if_inputisnotsmi);
     {
@@ skipping 320 matching lines @@
   var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     // Load the current {lhs} and {rhs} values.
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     // Check if the {lhs} is a Smi or a HeapObject.
     Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(lhs), &if_lhsissmi,
+                      &if_lhsisnotsmi);
 
     assembler->Bind(&if_lhsissmi);
     {
       // Check if the {rhs} is also a Smi.
       Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-      assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi,
+      assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
                         &if_rhsisnotsmi);
 
       assembler->Bind(&if_rhsissmi);
       {
         // Try fast Smi addition first.
         Node* pair = assembler->SmiAddWithOverflow(lhs, rhs);
         Node* overflow = assembler->Projection(1, pair);
 
         // Check if the Smi additon overflowed.
         Label if_overflow(assembler), if_notoverflow(assembler);
@@ skipping 92 matching lines @@
       {
         var_lhs.Bind(lhs);
         var_rhs.Bind(rhs);
         assembler->Goto(&string_add_convert_right);
       }
 
       assembler->Bind(&if_lhsisnotstring);
       {
         // Check if {rhs} is a Smi.
         Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-        assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi,
+        assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
                           &if_rhsisnotsmi);
 
         assembler->Bind(&if_rhsissmi);
         {
           // Check if {lhs} is a Number.
           Label if_lhsisnumber(assembler),
               if_lhsisnotnumber(assembler, Label::kDeferred);
           assembler->Branch(assembler->Word32Equal(
                                 lhs_instance_type,
                                 assembler->Int32Constant(HEAP_NUMBER_TYPE)),
@@ skipping 221 matching lines @@
   var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     // Load the current {lhs} and {rhs} values.
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     // Check if the {lhs} is a Smi or a HeapObject.
     Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(lhs), &if_lhsissmi,
+                      &if_lhsisnotsmi);
 
     assembler->Bind(&if_lhsissmi);
     {
       // Check if the {rhs} is also a Smi.
       Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-      assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi,
+      assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
                         &if_rhsisnotsmi);
 
       assembler->Bind(&if_rhsissmi);
       {
         // Try a fast Smi subtraction first.
         Node* pair = assembler->SmiSubWithOverflow(lhs, rhs);
         Node* overflow = assembler->Projection(1, pair);
 
         // Check if the Smi subtraction overflowed.
         Label if_overflow(assembler), if_notoverflow(assembler);
@@ skipping 51 matching lines @@
       Label if_lhsisnumber(assembler),
           if_lhsisnotnumber(assembler, Label::kDeferred);
       Node* number_map = assembler->HeapNumberMapConstant();
       assembler->Branch(assembler->WordEqual(lhs_map, number_map),
                         &if_lhsisnumber, &if_lhsisnotnumber);
 
       assembler->Bind(&if_lhsisnumber);
       {
         // Check if the {rhs} is a Smi.
         Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-        assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi,
+        assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
                           &if_rhsisnotsmi);
 
         assembler->Bind(&if_rhsissmi);
         {
           // Perform a floating point subtraction.
           var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
           var_fsub_rhs.Bind(assembler->SmiToFloat64(rhs));
           assembler->Goto(&do_fsub);
         }
 
@@ skipping 74 matching lines @@
   Label loop(assembler, 2, loop_variables);
   var_lhs.Bind(left);
   var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     Label lhs_is_smi(assembler), lhs_is_not_smi(assembler);
-    assembler->Branch(assembler->WordIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
+    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->WordIsSmi(rhs), &rhs_is_smi,
+      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));
         assembler->Goto(&return_result);
       }
 
@@ skipping 32 matching lines @@
       // Check if {lhs} is a HeapNumber.
       Label lhs_is_number(assembler),
           lhs_is_not_number(assembler, Label::kDeferred);
       assembler->Branch(assembler->WordEqual(lhs_map, number_map),
                         &lhs_is_number, &lhs_is_not_number);
 
       assembler->Bind(&lhs_is_number);
       {
         // Check if {rhs} is a Smi.
         Label rhs_is_smi(assembler), rhs_is_not_smi(assembler);
-        assembler->Branch(assembler->WordIsSmi(rhs), &rhs_is_smi,
+        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);
         }
 
@@ skipping 74 matching lines @@
   Label loop(assembler, 2, loop_variables);
   var_dividend.Bind(left);
   var_divisor.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* dividend = var_dividend.value();
     Node* divisor = var_divisor.value();
 
     Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
-    assembler->Branch(assembler->WordIsSmi(dividend), &dividend_is_smi,
+    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->WordIsSmi(divisor), &divisor_is_smi,
+      assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                         &divisor_is_not_smi);
 
       assembler->Bind(&divisor_is_smi);
       {
         Label bailout(assembler);
 
         // Do floating point division if {divisor} is zero.
         assembler->GotoIf(
             assembler->WordEqual(divisor, assembler->IntPtrConstant(0)),
             &bailout);
@@ skipping 96 matching lines @@
       // Check if {dividend} is a HeapNumber.
       Label dividend_is_number(assembler),
           dividend_is_not_number(assembler, Label::kDeferred);
       assembler->Branch(assembler->WordEqual(dividend_map, number_map),
                         &dividend_is_number, &dividend_is_not_number);
 
       assembler->Bind(&dividend_is_number);
       {
         // Check if {divisor} is a Smi.
         Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
-        assembler->Branch(assembler->WordIsSmi(divisor), &divisor_is_smi,
+        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);
         }
@@ skipping 76 matching lines @@
   Label loop(assembler, 2, loop_variables);
   var_dividend.Bind(left);
   var_divisor.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* dividend = var_dividend.value();
     Node* divisor = var_divisor.value();
 
     Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
-    assembler->Branch(assembler->WordIsSmi(dividend), &dividend_is_smi,
+    assembler->Branch(assembler->TaggedIsSmi(dividend), &dividend_is_smi,
                       &dividend_is_not_smi);
 
     assembler->Bind(&dividend_is_smi);
     {
       Label dividend_is_not_zero(assembler);
       Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
-      assembler->Branch(assembler->WordIsSmi(divisor), &divisor_is_smi,
+      assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                         &divisor_is_not_smi);
 
       assembler->Bind(&divisor_is_smi);
       {
         // Compute the modulus of two Smis.
         var_result.Bind(assembler->SmiMod(dividend, divisor));
         assembler->Goto(&return_result);
       }
 
       assembler->Bind(&divisor_is_not_smi);
@@ skipping 33 matching lines @@
       // Check if {dividend} is a HeapNumber.
       Label dividend_is_number(assembler),
           dividend_is_not_number(assembler, Label::kDeferred);
       assembler->Branch(assembler->WordEqual(dividend_map, number_map),
                         &dividend_is_number, &dividend_is_not_number);
 
       assembler->Bind(&dividend_is_number);
       {
         // Check if {divisor} is a Smi.
         Label divisor_is_smi(assembler), divisor_is_not_smi(assembler);
-        assembler->Branch(assembler->WordIsSmi(divisor), &divisor_is_smi,
+        assembler->Branch(assembler->TaggedIsSmi(divisor), &divisor_is_smi,
                           &divisor_is_not_smi);
 
         assembler->Bind(&divisor_is_smi);
         {
           // Convert {divisor} to a double and compute {dividend}'s modulus with
           // it.
           var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
           var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
           assembler->Goto(&do_fmod);
         }
@@ skipping 208 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