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

src/builtins/builtins-string.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.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 
 namespace v8 {
@@ skipping 695 matching lines @@
   // Check that {receiver} is coercible to Object and convert it to a String.
   receiver =
       assembler->ToThisString(context, receiver, "String.prototype.charAt");
 
   // Convert the {position} to a Smi and check that it's in bounds of the
   // {receiver}.
   {
     Label return_emptystring(assembler, Label::kDeferred);
     position = assembler->ToInteger(context, position,
                                     CodeStubAssembler::kTruncateMinusZero);
-    assembler->GotoUnless(assembler->WordIsSmi(position), &return_emptystring);
+    assembler->GotoUnless(assembler->TaggedIsSmi(position),
+                          &return_emptystring);
 
     // Determine the actual length of the {receiver} String.
     Node* receiver_length =
         assembler->LoadObjectField(receiver, String::kLengthOffset);
 
     // Return "" if the Smi {position} is outside the bounds of the {receiver}.
     Label if_positioninbounds(assembler);
     assembler->Branch(assembler->SmiAboveOrEqual(position, receiver_length),
                       &return_emptystring, &if_positioninbounds);
 
@@ skipping 24 matching lines @@
   // Check that {receiver} is coercible to Object and convert it to a String.
   receiver =
       assembler->ToThisString(context, receiver, "String.prototype.charCodeAt");
 
   // Convert the {position} to a Smi and check that it's in bounds of the
   // {receiver}.
   {
     Label return_nan(assembler, Label::kDeferred);
     position = assembler->ToInteger(context, position,
                                     CodeStubAssembler::kTruncateMinusZero);
-    assembler->GotoUnless(assembler->WordIsSmi(position), &return_nan);
+    assembler->GotoUnless(assembler->TaggedIsSmi(position), &return_nan);
 
     // Determine the actual length of the {receiver} String.
     Node* receiver_length =
         assembler->LoadObjectField(receiver, String::kLengthOffset);
 
     // Return NaN if the Smi {position} is outside the bounds of the {receiver}.
     Label if_positioninbounds(assembler);
     assembler->Branch(assembler->SmiAboveOrEqual(position, receiver_length),
                       &return_nan, &if_positioninbounds);
 
@@ skipping 220 matching lines @@
       a->ToThisString(context, receiver, "String.prototype.substr");
 
   Node* const string_length = a->LoadStringLength(string);
 
   // Conversions and bounds-checks for {start}.
   {
     Node* const start_int =
         a->ToInteger(context, start, CodeStubAssembler::kTruncateMinusZero);
 
     Label if_issmi(a), if_isheapnumber(a, Label::kDeferred);
-    a->Branch(a->WordIsSmi(start_int), &if_issmi, &if_isheapnumber);
+    a->Branch(a->TaggedIsSmi(start_int), &if_issmi, &if_isheapnumber);
 
     a->Bind(&if_issmi);
     {
       Node* const length_plus_start = a->SmiAdd(string_length, start_int);
       var_start.Bind(a->Select(a->SmiLessThan(start_int, zero),
                                a->SmiMax(length_plus_start, zero), start_int));
       a->Goto(&handle_length);
     }
 
     a->Bind(&if_isheapnumber);
@@ skipping 23 matching lines @@
 
       a->Bind(&if_isundefined);
       var_length.Bind(string_length);
       a->Goto(&if_issmi);
 
       a->Bind(&if_isnotundefined);
       var_length.Bind(
           a->ToInteger(context, length, CodeStubAssembler::kTruncateMinusZero));
     }
 
-    a->Branch(a->WordIsSmi(var_length.value()), &if_issmi, &if_isheapnumber);
+    a->Branch(a->TaggedIsSmi(var_length.value()), &if_issmi, &if_isheapnumber);
 
     // Set {length} to min(max({length}, 0), {string_length} - {start}
     a->Bind(&if_issmi);
     {
       Node* const positive_length = a->SmiMax(var_length.value(), zero);
 
       Node* const minimal_length = a->SmiSub(string_length, var_start.value());
       var_length.Bind(a->SmiMin(positive_length, minimal_length));
 
       a->GotoUnless(a->SmiLessThanOrEqual(var_length.value(), zero), &out);
@@ skipping 45 matching lines @@
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
   Label out(a);
   Variable var_result(a, MachineRepresentation::kTagged);
 
   Node* const value_int =
       a->ToInteger(context, value, CodeStubAssembler::kTruncateMinusZero);
 
   Label if_issmi(a), if_isnotsmi(a, Label::kDeferred);
-  a->Branch(a->WordIsSmi(value_int), &if_issmi, &if_isnotsmi);
+  a->Branch(a->TaggedIsSmi(value_int), &if_issmi, &if_isnotsmi);
 
   a->Bind(&if_issmi);
   {
     Label if_isinbounds(a), if_isoutofbounds(a, Label::kDeferred);
     a->Branch(a->SmiAbove(value_int, limit), &if_isoutofbounds, &if_isinbounds);
 
     a->Bind(&if_isinbounds);
     {
       var_result.Bind(value_int);
       a->Goto(&out);
@@ skipping 299 matching lines @@
 
   var_value.Bind(assembler->UndefinedConstant());
   var_done.Bind(assembler->BooleanConstant(true));
 
   Label throw_bad_receiver(assembler), next_codepoint(assembler),
       return_result(assembler);
 
   Node* iterator = assembler->Parameter(0);
   Node* context = assembler->Parameter(3);
 
-  assembler->GotoIf(assembler->WordIsSmi(iterator), &throw_bad_receiver);
+  assembler->GotoIf(assembler->TaggedIsSmi(iterator), &throw_bad_receiver);
   assembler->GotoUnless(
       assembler->WordEqual(assembler->LoadInstanceType(iterator),
                            assembler->Int32Constant(JS_STRING_ITERATOR_TYPE)),
       &throw_bad_receiver);
 
   Node* string =
       assembler->LoadObjectField(iterator, JSStringIterator::kStringOffset);
   Node* position =
       assembler->LoadObjectField(iterator, JSStringIterator::kNextIndexOffset);
   Node* length = assembler->LoadObjectField(string, String::kLengthOffset);
@@ skipping 41 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler->HeapConstant(assembler->factory()->NewStringFromAsciiChecked(
             "String Iterator.prototype.next", TENURED)),
         iterator);
     assembler->Return(result);  // Never reached.
   }
 }
 
 }  // namespace internal
 }  // namespace v8