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

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 662 matching lines @@
   // Shared entry for floating point addition.
   Label do_fadd(assembler), end(assembler),
       call_add_stub(assembler, Label::kDeferred);
   Variable var_fadd_lhs(assembler, MachineRepresentation::kFloat64),
       var_fadd_rhs(assembler, MachineRepresentation::kFloat64),
       var_type_feedback(assembler, MachineRepresentation::kWord32),
       var_result(assembler, MachineRepresentation::kTagged);
 
   // 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, &if_rhsisnotsmi);
+    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);
       assembler->Branch(overflow, &if_overflow, &if_notoverflow);
@@ skipping 35 matching lines @@
 
     // Load the map of {lhs}.
     Node* lhs_map = assembler->LoadMap(lhs);
 
     // Check if {lhs} is a HeapNumber.
     Label if_lhsisnumber(assembler), if_lhsisnotnumber(assembler);
     assembler->GotoUnless(assembler->IsHeapNumberMap(lhs_map), &check_string);
 
     // Check if the {rhs} is Smi.
     Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
+                      &if_rhsisnotsmi);
 
     assembler->Bind(&if_rhsissmi);
     {
       var_fadd_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fadd_rhs.Bind(assembler->SmiToFloat64(rhs));
       assembler->Goto(&do_fadd);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
       // Load the map of {rhs}.
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if the {rhs} is a HeapNumber.
       assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
                             &call_add_stub);
 
       var_fadd_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fadd_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fadd);
     }
 
     assembler->Bind(&check_string);
     {
       // Check if the {rhs} is a smi, and exit the string check early if it is.
-      assembler->GotoIf(assembler->WordIsSmi(rhs), &call_add_stub);
+      assembler->GotoIf(assembler->TaggedIsSmi(rhs), &call_add_stub);
 
       Node* lhs_instance_type = assembler->LoadMapInstanceType(lhs_map);
 
       // Exit unless {lhs} is a string
       assembler->GotoUnless(assembler->IsStringInstanceType(lhs_instance_type),
                             &call_add_stub);
 
       Node* rhs_instance_type = assembler->LoadInstanceType(rhs);
 
       // Exit unless {rhs} is a string
@@ skipping 49 matching lines @@
   Label do_fsub(assembler), end(assembler), call_subtract_stub(assembler),
       if_lhsisnotnumber(assembler), check_rhsisoddball(assembler),
       call_with_any_feedback(assembler);
   Variable var_fsub_lhs(assembler, MachineRepresentation::kFloat64),
       var_fsub_rhs(assembler, MachineRepresentation::kFloat64),
       var_type_feedback(assembler, MachineRepresentation::kWord32),
       var_result(assembler, MachineRepresentation::kTagged);
 
   // 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, &if_rhsisnotsmi);
+    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);
       assembler->Branch(overflow, &if_overflow, &if_notoverflow);
@@ skipping 35 matching lines @@
   {
     // Load the map of the {lhs}.
     Node* lhs_map = assembler->LoadMap(lhs);
 
     // Check if the {lhs} is a HeapNumber.
     assembler->GotoUnless(assembler->IsHeapNumberMap(lhs_map),
                           &if_lhsisnotnumber);
 
     // Check if the {rhs} is a Smi.
     Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
+    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);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
@@ skipping 26 matching lines @@
   assembler->Bind(&if_lhsisnotnumber);
   {
     // No checks on rhs are done yet. We just know lhs is not a number or Smi.
     // Check if lhs is an oddball.
     Node* lhs_instance_type = assembler->LoadInstanceType(lhs);
     Node* lhs_is_oddball = assembler->Word32Equal(
         lhs_instance_type, assembler->Int32Constant(ODDBALL_TYPE));
     assembler->GotoUnless(lhs_is_oddball, &call_with_any_feedback);
 
     Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(rhs), &if_rhsissmi,
+                      &if_rhsisnotsmi);
 
     assembler->Bind(&if_rhsissmi);
     {
       var_type_feedback.Bind(
           assembler->Int32Constant(BinaryOperationFeedback::kNumberOrOddball));
       assembler->Goto(&call_subtract_stub);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
@@ skipping 58 matching lines @@
   Label do_fmul(assembler), end(assembler),
       call_multiply_stub(assembler, Label::kDeferred);
   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->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, &rhs_is_not_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));
       var_type_feedback.Bind(assembler->Select(
-          assembler->WordIsSmi(var_result.value()),
+          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);
 
@@ skipping 11 matching lines @@
   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),
                           &call_multiply_stub);
 
     // Check if {rhs} is a Smi.
     Label rhs_is_smi(assembler), rhs_is_not_smi(assembler);
-    assembler->Branch(assembler->WordIsSmi(rhs), &rhs_is_smi, &rhs_is_not_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);
     }
 
     assembler->Bind(&rhs_is_not_smi);
@@ skipping 51 matching lines @@
   // Shared entry point for floating point division.
   Label do_fdiv(assembler), end(assembler), call_divide_stub(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->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 76 matching lines @@
     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),
                             &call_divide_stub);
 
       // 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 52 matching lines @@
   // Shared entry point for floating point division.
   Label do_fmod(assembler), end(assembler), call_modulus_stub(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->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);
     {
       var_result.Bind(assembler->SmiMod(dividend, divisor));
       var_type_feedback.Bind(assembler->Select(
-          assembler->WordIsSmi(var_result.value()),
+          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.
@@ skipping 11 matching lines @@
   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),
                           &call_modulus_stub);
 
     // 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_fmod);
     }
@@ skipping 61 matching lines @@
   Label start(assembler, 2, loop_vars);
   value_var.Bind(value);
   var_type_feedback.Bind(
       assembler->Int32Constant(BinaryOperationFeedback::kNone));
   assembler->Goto(&start);
   assembler->Bind(&start);
   {
     value = value_var.value();
 
     Label if_issmi(assembler), if_isnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(value), &if_issmi, &if_isnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(value), &if_issmi, &if_isnotsmi);
 
     assembler->Bind(&if_issmi);
     {
       // Try fast Smi addition first.
       Node* one = assembler->SmiConstant(Smi::FromInt(1));
       Node* pair = assembler->SmiAddWithOverflow(value, one);
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi addition overflowed.
       Label if_overflow(assembler), if_notoverflow(assembler);
@@ skipping 89 matching lines @@
   Label start(assembler, 2, loop_vars);
   var_type_feedback.Bind(
       assembler->Int32Constant(BinaryOperationFeedback::kNone));
   value_var.Bind(value);
   assembler->Goto(&start);
   assembler->Bind(&start);
   {
     value = value_var.value();
 
     Label if_issmi(assembler), if_isnotsmi(assembler);
-    assembler->Branch(assembler->WordIsSmi(value), &if_issmi, &if_isnotsmi);
+    assembler->Branch(assembler->TaggedIsSmi(value), &if_issmi, &if_isnotsmi);
 
     assembler->Bind(&if_issmi);
     {
       // Try fast Smi subtraction first.
       Node* one = assembler->SmiConstant(Smi::FromInt(1));
       Node* pair = assembler->SmiSubWithOverflow(value, one);
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi subtraction overflowed.
       Label if_overflow(assembler), if_notoverflow(assembler);
@@ skipping 151 matching lines @@
     Node* map_cell = assembler->HeapConstant(isolate()->factory()->NewWeakCell(
         StoreGlobalStub::global_map_placeholder(isolate())));
     Node* expected_map = assembler->LoadWeakCellValue(map_cell);
     Node* map = assembler->LoadMap(global);
     assembler->GotoIf(assembler->WordNotEqual(expected_map, map), &miss);
   }
 
   Node* weak_cell = assembler->HeapConstant(isolate()->factory()->NewWeakCell(
       StoreGlobalStub::property_cell_placeholder(isolate())));
   Node* cell = assembler->LoadWeakCellValue(weak_cell);
-  assembler->GotoIf(assembler->WordIsSmi(cell), &miss);
+  assembler->GotoIf(assembler->TaggedIsSmi(cell), &miss);
 
   // Load the payload of the global parameter cell. A hole indicates that the
   // cell has been invalidated and that the store must be handled by the
   // runtime.
   Node* cell_contents =
       assembler->LoadObjectField(cell, PropertyCell::kValueOffset);
 
   PropertyCellType cell_type = this->cell_type();
   if (cell_type == PropertyCellType::kConstant ||
       cell_type == PropertyCellType::kUndefined) {
     // This is always valid for all states a cell can be in.
     assembler->GotoIf(assembler->WordNotEqual(cell_contents, value), &miss);
   } else {
     assembler->GotoIf(assembler->IsTheHole(cell_contents), &miss);
 
     // When dealing with constant types, the type may be allowed to change, as
     // long as optimized code remains valid.
     bool value_is_smi = false;
     if (cell_type == PropertyCellType::kConstantType) {
       switch (constant_type()) {
         case PropertyCellConstantType::kSmi:
-          assembler->GotoUnless(assembler->WordIsSmi(value), &miss);
+          assembler->GotoUnless(assembler->TaggedIsSmi(value), &miss);
           value_is_smi = true;
           break;
         case PropertyCellConstantType::kStableMap: {
           // It is sufficient here to check that the value and cell contents
           // have identical maps, no matter if they are stable or not or if they
           // are the maps that were originally in the cell or not. If optimized
           // code will deopt when a cell has a unstable map and if it has a
           // dependency on a stable map, it will deopt if the map destabilizes.
-          assembler->GotoIf(assembler->WordIsSmi(value), &miss);
-          assembler->GotoIf(assembler->WordIsSmi(cell_contents), &miss);
+          assembler->GotoIf(assembler->TaggedIsSmi(value), &miss);
+          assembler->GotoIf(assembler->TaggedIsSmi(cell_contents), &miss);
           Node* expected_map = assembler->LoadMap(cell_contents);
           Node* map = assembler->LoadMap(value);
           assembler->GotoIf(assembler->WordNotEqual(expected_map, map), &miss);
           break;
         }
       }
     }
     if (value_is_smi) {
       assembler->StoreObjectFieldNoWriteBarrier(
           cell, PropertyCell::kValueOffset, value);
@@ skipping 1122 matching lines @@
                                      AllocationSiteMode mode) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
 
   Label ok(assembler);
   Label smi_size(assembler);
   Label small_smi_size(assembler);
   Label call_runtime(assembler, Label::kDeferred);
 
   Node* size = assembler->Parameter(Descriptor::kArraySizeSmiParameter);
-  assembler->Branch(assembler->WordIsSmi(size), &smi_size, &call_runtime);
+  assembler->Branch(assembler->TaggedIsSmi(size), &smi_size, &call_runtime);
 
   assembler->Bind(&smi_size);
 
   if (IsFastPackedElementsKind(elements_kind)) {
     Label abort(assembler, Label::kDeferred);
     assembler->Branch(
         assembler->SmiEqual(size, assembler->SmiConstant(Smi::kZero)),
         &small_smi_size, &abort);
 
     assembler->Bind(&abort);
@@ skipping 109 matching lines @@
 
   if (type == MachineType::Pointer()) {
     return Representation::External();
   }
 
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8