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

src/builtins/builtins-conversion.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 {
 namespace internal {
@@ skipping 42 matching lines @@
     // representation of the {hint}.
     Callable callable = CodeFactory::Call(assembler->isolate());
     Node* hint_string = assembler->HeapConstant(
         assembler->factory()->ToPrimitiveHintString(hint));
     Node* result = assembler->CallJS(callable, context, exotic_to_prim, input,
                                      hint_string);
 
     // Verify that the {result} is actually a primitive.
     Label if_resultisprimitive(assembler),
         if_resultisnotprimitive(assembler, Label::kDeferred);
-    assembler->GotoIf(assembler->WordIsSmi(result), &if_resultisprimitive);
+    assembler->GotoIf(assembler->TaggedIsSmi(result), &if_resultisprimitive);
     Node* result_instance_type = assembler->LoadInstanceType(result);
     STATIC_ASSERT(FIRST_PRIMITIVE_TYPE == FIRST_TYPE);
     assembler->Branch(assembler->Int32LessThanOrEqual(
                           result_instance_type,
                           assembler->Int32Constant(LAST_PRIMITIVE_TYPE)),
                       &if_resultisprimitive, &if_resultisnotprimitive);
 
     assembler->Bind(&if_resultisprimitive);
     {
       // Just return the {result}.
@@ skipping 81 matching lines @@
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef TypeConversionDescriptor Descriptor;
 
   Node* input = assembler->Parameter(Descriptor::kArgument);
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   Label is_number(assembler);
   Label runtime(assembler);
 
-  assembler->GotoIf(assembler->WordIsSmi(input), &is_number);
+  assembler->GotoIf(assembler->TaggedIsSmi(input), &is_number);
 
   Node* input_map = assembler->LoadMap(input);
   Node* input_instance_type = assembler->LoadMapInstanceType(input_map);
 
   Label not_string(assembler);
   assembler->GotoUnless(assembler->IsStringInstanceType(input_instance_type),
                         &not_string);
   assembler->Return(input);
 
   Label not_heap_number(assembler);
@@ skipping 69 matching lines @@
   }
   for (Handle<String> name : method_names) {
     // Lookup the {name} on the {input}.
     Callable callable = CodeFactory::GetProperty(assembler->isolate());
     Node* name_string = assembler->HeapConstant(name);
     Node* method = assembler->CallStub(callable, context, input, name_string);
 
     // Check if the {method} is callable.
     Label if_methodiscallable(assembler),
         if_methodisnotcallable(assembler, Label::kDeferred);
-    assembler->GotoIf(assembler->WordIsSmi(method), &if_methodisnotcallable);
+    assembler->GotoIf(assembler->TaggedIsSmi(method), &if_methodisnotcallable);
     Node* method_map = assembler->LoadMap(method);
     Node* method_bit_field = assembler->LoadMapBitField(method_map);
     assembler->Branch(
         assembler->Word32Equal(
             assembler->Word32And(method_bit_field, assembler->Int32Constant(
                                                        1 << Map::kIsCallable)),
             assembler->Int32Constant(0)),
         &if_methodisnotcallable, &if_methodiscallable);
 
     assembler->Bind(&if_methodiscallable);
     {
       // Call the {method} on the {input}.
       Callable callable = CodeFactory::Call(assembler->isolate());
       Node* result = assembler->CallJS(callable, context, method, input);
       var_result.Bind(result);
 
       // Return the {result} if it is a primitive.
-      assembler->GotoIf(assembler->WordIsSmi(result), &return_result);
+      assembler->GotoIf(assembler->TaggedIsSmi(result), &return_result);
       Node* result_instance_type = assembler->LoadInstanceType(result);
       STATIC_ASSERT(FIRST_PRIMITIVE_TYPE == FIRST_TYPE);
       assembler->GotoIf(assembler->Int32LessThanOrEqual(
                             result_instance_type,
                             assembler->Int32Constant(LAST_PRIMITIVE_TYPE)),
                         &return_result);
     }
 
     // Just continue with the next {name} if the {method} is not callable.
     assembler->Goto(&if_methodisnotcallable);
@@ skipping 54 matching lines @@
         return_two53minus1(assembler, Label::kDeferred),
         return_zero(assembler, Label::kDeferred);
 
     // Load the current {len} value.
     Node* len = var_len.value();
 
     // Check if {len} is a positive Smi.
     assembler->GotoIf(assembler->WordIsPositiveSmi(len), &return_len);
 
     // Check if {len} is a (negative) Smi.
-    assembler->GotoIf(assembler->WordIsSmi(len), &return_zero);
+    assembler->GotoIf(assembler->TaggedIsSmi(len), &return_zero);
 
     // Check if {len} is a HeapNumber.
     Label if_lenisheapnumber(assembler),
         if_lenisnotheapnumber(assembler, Label::kDeferred);
     assembler->Branch(assembler->IsHeapNumberMap(assembler->LoadMap(len)),
                       &if_lenisheapnumber, &if_lenisnotheapnumber);
 
     assembler->Bind(&if_lenisheapnumber);
     {
       // Load the floating-point value of {len}.
@@ skipping 54 matching lines @@
   Label if_number(assembler, Label::kDeferred), if_notsmi(assembler),
       if_jsreceiver(assembler), if_noconstructor(assembler, Label::kDeferred),
       if_wrapjsvalue(assembler);
 
   Node* object = assembler->Parameter(Descriptor::kArgument);
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   Variable constructor_function_index_var(assembler,
                                           MachineType::PointerRepresentation());
 
-  assembler->Branch(assembler->WordIsSmi(object), &if_number, &if_notsmi);
+  assembler->Branch(assembler->TaggedIsSmi(object), &if_number, &if_notsmi);
 
   assembler->Bind(&if_notsmi);
   Node* map = assembler->LoadMap(object);
 
   assembler->GotoIf(assembler->IsHeapNumberMap(map), &if_number);
 
   Node* instance_type = assembler->LoadMapInstanceType(map);
   assembler->GotoIf(assembler->IsJSReceiverInstanceType(instance_type),
                     &if_jsreceiver);
 
@@ skipping 43 matching lines @@
   typedef TypeofDescriptor Descriptor;
 
   Node* object = assembler->Parameter(Descriptor::kObject);
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   assembler->Return(assembler->Typeof(object, context));
 }
 
 }  // namespace internal
 }  // namespace v8