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

src/builtins/builtins-regexp.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"
 #include "src/regexp/jsregexp.h"
 #include "src/string-builder.h"
@@ skipping 361 matching lines @@
     {
       Node* const regexp_lastindex =
           LoadLastIndex(a, context, has_initialmap, regexp);
 
       Callable tolength_callable = CodeFactory::ToLength(isolate);
       Node* const lastindex =
           a->CallStub(tolength_callable, context, regexp_lastindex);
       var_lastindex.Bind(lastindex);
 
       Label if_isoob(a, Label::kDeferred);
-      a->GotoUnless(a->WordIsSmi(lastindex), &if_isoob);
+      a->GotoUnless(a->TaggedIsSmi(lastindex), &if_isoob);
       a->GotoUnless(a->SmiLessThanOrEqual(lastindex, string_length), &if_isoob);
       a->Goto(&run_exec);
 
       a->Bind(&if_isoob);
       {
         StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
         a->Return(null);
       }
     }
 
@@ skipping 60 matching lines @@
                                      compiler::Node* context,
                                      compiler::Node* value,
                                      char const* method_name) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   Label out(a), throw_exception(a, Label::kDeferred);
   Variable var_value_map(a, MachineRepresentation::kTagged);
 
-  a->GotoIf(a->WordIsSmi(value), &throw_exception);
+  a->GotoIf(a->TaggedIsSmi(value), &throw_exception);
 
   // Load the instance type of the {value}.
   var_value_map.Bind(a->LoadMap(value));
   Node* const value_instance_type =
       a->LoadMapInstanceType(var_value_map.value());
 
   a->Branch(a->IsJSReceiverInstanceType(value_instance_type), &out,
             &throw_exception);
 
   // The {value} is not a compatible receiver for this method.
@@ skipping 246 matching lines @@
   Node* const receiver = a->Parameter(0);
   Node* const context = a->Parameter(3);
 
   Isolate* isolate = a->isolate();
   Node* const int_zero = a->IntPtrConstant(0);
 
   // Check whether we have an unmodified regexp instance.
   Label if_isunmodifiedjsregexp(a),
       if_isnotunmodifiedjsregexp(a, Label::kDeferred);
 
-  a->GotoIf(a->WordIsSmi(receiver), &if_isnotunmodifiedjsregexp);
+  a->GotoIf(a->TaggedIsSmi(receiver), &if_isnotunmodifiedjsregexp);
 
   Node* const receiver_map = a->LoadMap(receiver);
   Node* const instance_type = a->LoadMapInstanceType(receiver_map);
 
   a->Branch(a->Word32Equal(instance_type, a->Int32Constant(JS_REGEXP_TYPE)),
             &if_isunmodifiedjsregexp, &if_isnotunmodifiedjsregexp);
 
   a->Bind(&if_isunmodifiedjsregexp);
   {
     // Refer to JSRegExp's flag property on the fast-path.
@@ skipping 848 matching lines @@
     Handle<String> substr =
         factory->NewSubString(string, prev_string_index, length);
     elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
   }
 
   return *NewJSArrayWithElements(isolate, elems, num_elems);
 }
 
 }  // namespace internal
 }  // namespace v8