[stubs] Enable graph verification for builtins.

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-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/regexp/regexp-utils.h"
 
@@ skipping 416 matching lines @@
 // ES6 section 21.1 String Objects
 
 // ES6 section 21.1.2.1 String.fromCharCode ( ...codeUnits )
 void Builtins::Generate_StringFromCharCode(
     compiler::CodeAssemblerState* state) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
   CodeStubAssembler assembler(state);
 
-  Node* argc = assembler.ChangeInt32ToIntPtr(
-      assembler.Parameter(BuiltinDescriptor::kArgumentsCount));
+  Node* argc = assembler.Parameter(BuiltinDescriptor::kArgumentsCount);
   Node* context = assembler.Parameter(BuiltinDescriptor::kContext);
 
   CodeStubArguments arguments(&assembler, argc);
+  // From now on use word-size argc value.
+  argc = arguments.GetLength();
 
   // Check if we have exactly one argument (plus the implicit receiver), i.e.
   // if the parent frame is not an arguments adaptor frame.
   Label if_oneargument(&assembler), if_notoneargument(&assembler);
   assembler.Branch(assembler.WordEqual(argc, assembler.IntPtrConstant(1)),
                    &if_oneargument, &if_notoneargument);
 
   assembler.Bind(&if_oneargument);
   {
     // Single argument case, perform fast single character string cache lookup
@@ skipping 853 matching lines @@
 compiler::Node* LoadSurrogatePairInternal(CodeStubAssembler* assembler,
                                           compiler::Node* string,
                                           compiler::Node* length,
                                           compiler::Node* index,
                                           UnicodeEncoding encoding) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
   Label handle_surrogate_pair(assembler), return_result(assembler);
   Variable var_result(assembler, MachineRepresentation::kWord32);
-  Variable var_trail(assembler, MachineRepresentation::kWord16);
+  Variable var_trail(assembler, MachineRepresentation::kWord32);
   var_result.Bind(assembler->StringCharCodeAt(string, index));
   var_trail.Bind(assembler->Int32Constant(0));
 
   assembler->GotoIf(assembler->Word32NotEqual(
                         assembler->Word32And(var_result.value(),
                                              assembler->Int32Constant(0xFC00)),
                         assembler->Int32Constant(0xD800)),
                     &return_result);
   Node* next_index =
       assembler->SmiAdd(index, assembler->SmiConstant(Smi::FromInt(1)));
@@ skipping 17 matching lines @@
                                    lead, assembler->Int32Constant(0xD800)));
     CSA_SLOW_ASSERT(assembler, assembler->Uint32LessThan(
                                    lead, assembler->Int32Constant(0xDC00)));
     CSA_SLOW_ASSERT(assembler, assembler->Uint32GreaterThanOrEqual(
                                    trail, assembler->Int32Constant(0xDC00)));
     CSA_SLOW_ASSERT(assembler, assembler->Uint32LessThan(
                                    trail, assembler->Int32Constant(0xE000)));
 
     switch (encoding) {
       case UnicodeEncoding::UTF16:
-        var_result.Bind(assembler->WordOr(
+        var_result.Bind(assembler->Word32Or(
 // Need to swap the order for big-endian platforms
 #if V8_TARGET_BIG_ENDIAN
-            assembler->WordShl(lead, assembler->Int32Constant(16)), trail));
+            assembler->Word32Shl(lead, assembler->Int32Constant(16)), trail));
 #else
-            assembler->WordShl(trail, assembler->Int32Constant(16)), lead));
+            assembler->Word32Shl(trail, assembler->Int32Constant(16)), lead));
 #endif
         break;
 
       case UnicodeEncoding::UTF32: {
         // Convert UTF16 surrogate pair into |word32| code point, encoded as
         // UTF32.
         Node* surrogate_offset =
             assembler->Int32Constant(0x10000 - (0xD800 << 10) - 0xDC00);
 
         // (lead << 10) + trail + SURROGATE_OFFSET
@@ skipping 34 matching lines @@
   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.TaggedIsSmi(iterator), &throw_bad_receiver);
   assembler.GotoUnless(
-      assembler.WordEqual(assembler.LoadInstanceType(iterator),
-                          assembler.Int32Constant(JS_STRING_ITERATOR_TYPE)),
+      assembler.Word32Equal(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);
 
   assembler.Branch(assembler.SmiLessThan(position, length), &next_codepoint,
                    &return_result);
@@ skipping 36 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