[stubs] Enable graph verification for builtins.

src/builtins/builtins-promise.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/promise-utils.h"
 
@@ skipping 254 matching lines @@
                                   compiler::Node* promise) {
   typedef compiler::Node Node;
 
   Node* const flags = a->LoadObjectField(promise, JSPromise::kFlagsOffset);
   return a->IsSetWord(a->SmiUntag(flags), 1 << JSPromise::kHasHandlerBit);
 }
 
 void PromiseSetHasHandler(CodeStubAssembler* a, compiler::Node* promise) {
   typedef compiler::Node Node;
 
-  Node* const flags = a->LoadObjectField(promise, JSPromise::kFlagsOffset);
+  Node* const flags =
+      a->SmiUntag(a->LoadObjectField(promise, JSPromise::kFlagsOffset));
   Node* const new_flags =
       a->WordOr(flags, a->IntPtrConstant(1 << JSPromise::kHasHandlerBit));
   a->StoreObjectField(promise, JSPromise::kFlagsOffset, a->SmiTag(new_flags));
 }
 
 compiler::Node* SpeciesConstructor(CodeStubAssembler* a, Isolate* isolate,
                                    compiler::Node* context,
                                    compiler::Node* object,
                                    compiler::Node* default_constructor) {
   typedef compiler::Node Node;
@@ skipping 52 matching lines @@
   return var_result.value();
 }
 
 void AppendPromiseCallback(CodeStubAssembler* a, int offset,
                            compiler::Node* promise, compiler::Node* value) {
   typedef compiler::Node Node;
 
   Node* elements = a->LoadObjectField(promise, offset);
   Node* length = a->LoadFixedArrayBaseLength(elements);
   CodeStubAssembler::ParameterMode mode = a->OptimalParameterMode();
-  length = a->UntagParameter(length, mode);
+  length = a->TaggedToParameter(length, mode);
 
   Node* delta = a->IntPtrOrSmiConstant(1, mode);
-  Node* new_capacity = a->IntPtrAdd(length, delta);
+  Node* new_capacity = a->IntPtrOrSmiAdd(length, delta, mode);
 
   const ElementsKind kind = FAST_ELEMENTS;
   const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
   const CodeStubAssembler::AllocationFlags flags =
       CodeStubAssembler::kAllowLargeObjectAllocation;
   int additional_offset = 0;
 
   Node* new_elements = a->AllocateFixedArray(kind, new_capacity, mode, flags);
 
   a->CopyFixedArrayElements(kind, elements, new_elements, length, barrier_mode,
@@ skipping 500 matching lines @@
 
   Label out(&a);
   InternalResolvePromise(&a, context, promise, result, &out);
 
   a.Bind(&out);
   a.Return(a.UndefinedConstant());
 }
 
 }  // namespace internal
 }  // namespace v8