[stubs] Enable machine graph verification for CodeStubAssembler and friends by default in debug mode

test/cctest/test-code-stub-assembler.cc

 // Copyright 2015 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/base/utils/random-number-generator.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/compiler/node.h"
 #include "src/isolate.h"
 #include "test/cctest/compiler/code-assembler-tester.h"
 #include "test/cctest/compiler/function-tester.h"
 
 namespace v8 {
 namespace internal {
 
 using compiler::CodeAssemblerTester;
 using compiler::FunctionTester;
 using compiler::Node;
+using compiler::CodeAssemblerLabel;
+using compiler::CodeAssemblerVariable;
+using compiler::CodeAssemblerVariableList;
 
 TEST(FixedArrayAccessSmiIndex) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeAssemblerTester data(isolate);
   CodeStubAssembler m(data.state());
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(5);
   array->set(4, Smi::FromInt(733));
   m.Return(m.LoadFixedArrayElement(m.HeapConstant(array),
                                    m.SmiTag(m.Int32Constant(4)), 0,
                                    CodeStubAssembler::SMI_PARAMETERS));
   Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code);
   MaybeHandle<Object> result = ft.Call();
   CHECK_EQ(733, Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(LoadHeapNumberValue) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeAssemblerTester data(isolate);
   CodeStubAssembler m(data.state());
   Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234);
-  m.Return(m.SmiTag(
+  m.Return(m.SmiFromWord32(
       m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number)))));
   Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code);
   MaybeHandle<Object> result = ft.Call();
   CHECK_EQ(1234, Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(LoadInstanceType) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeAssemblerTester data(isolate);
   CodeStubAssembler m(data.state());
   Handle<HeapObject> undefined = isolate->factory()->undefined_value();
-  m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined))));
+  m.Return(m.SmiFromWord32(m.LoadInstanceType(m.HeapConstant(undefined))));
   Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code);
   MaybeHandle<Object> result = ft.Call();
   CHECK_EQ(InstanceType::ODDBALL_TYPE,
            Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(DecodeWordFromWord32) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeAssemblerTester data(isolate);
@@ skipping 27 matching lines @@
                                        handle(Smi::FromInt(34), isolate));
   CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(ComputeIntegerHash) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 2;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
   m.Return(m.SmiFromWord32(m.ComputeIntegerHash(
-      m.SmiToWord32(m.Parameter(0)), m.SmiToWord32(m.Parameter(1)))));
+      m.SmiUntag(m.Parameter(0)), m.SmiToWord32(m.Parameter(1)))));
 
   Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Smi> hash_seed = isolate->factory()->hash_seed();
 
   base::RandomNumberGenerator rand_gen(FLAG_random_seed);
 
   for (int i = 0; i < 1024; i++) {
     int k = rand_gen.NextInt(Smi::kMaxValue);
@@ skipping 99 matching lines @@
   for (int i = 0; i < 4; ++i) {
     Handle<String> test = handle(String::cast(test_cases->get(i)));
     Handle<Object> result = ft.Call(test).ToHandleChecked();
     CHECK(result->IsString());
     CHECK(Handle<String>::cast(result)->IsFlat());
     CHECK(String::Equals(Handle<String>::cast(result), expected));
   }
 }
 
 TEST(TryToName) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeAssemblerLabel Label;
+  typedef CodeAssemblerVariable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 3;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   enum Result { kKeyIsIndex, kKeyIsUnique, kBailout };
   {
     Node* key = m.Parameter(0);
     Node* expected_result = m.Parameter(1);
@@ skipping 143 matching lines @@
 
 TEST(NameDictionaryEntryToIndex) { TestEntryToIndex<NameDictionary>(); }
 TEST(GlobalDictionaryEntryToIndex) { TestEntryToIndex<GlobalDictionary>(); }
 
 }  // namespace
 
 namespace {
 
 template <typename Dictionary>
 void TestNameDictionaryLookup() {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeAssemblerLabel Label;
+  typedef CodeAssemblerVariable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   enum Result { kFound, kNotFound };
   {
     Node* dictionary = m.Parameter(0);
     Node* unique_name = m.Parameter(1);
     Node* expected_result = m.Parameter(2);
     Node* expected_arg = m.Parameter(3);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m);
     Variable var_name_index(&m, MachineType::PointerRepresentation());
 
     m.NameDictionaryLookup<Dictionary>(dictionary, unique_name, &if_found,
                                        &var_name_index, &if_not_found);
     m.Bind(&if_found);
     m.GotoUnless(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
         &failed);
-    m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_name_index.value()),
+    m.Branch(m.WordEqual(m.SmiUntag(expected_arg), var_name_index.value()),
              &passed, &failed);
 
     m.Bind(&if_not_found);
     m.Branch(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
@@ skipping 61 matching lines @@
 }  // namespace
 
 TEST(NameDictionaryLookup) { TestNameDictionaryLookup<NameDictionary>(); }
 
 TEST(GlobalDictionaryLookup) { TestNameDictionaryLookup<GlobalDictionary>(); }
 
 namespace {
 
 template <typename Dictionary>
 void TestNumberDictionaryLookup() {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeAssemblerLabel Label;
+  typedef CodeAssemblerVariable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   enum Result { kFound, kNotFound };
   {
     Node* dictionary = m.Parameter(0);
-    Node* key = m.SmiToWord32(m.Parameter(1));
+    Node* key = m.SmiUntag(m.Parameter(1));
     Node* expected_result = m.Parameter(2);
     Node* expected_arg = m.Parameter(3);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m);
     Variable var_entry(&m, MachineType::PointerRepresentation());
 
     m.NumberDictionaryLookup<Dictionary>(dictionary, key, &if_found, &var_entry,
                                          &if_not_found);
     m.Bind(&if_found);
     m.GotoUnless(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
         &failed);
-    m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_entry.value()),
-             &passed, &failed);
+    m.Branch(m.WordEqual(m.SmiUntag(expected_arg), var_entry.value()), &passed,
+             &failed);
 
     m.Bind(&if_not_found);
     m.Branch(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
@@ skipping 92 matching lines @@
       JSObject::DefineAccessor(object, names[i], getter, setter, NONE).Check();
     } else {
       JSObject::AddProperty(object, names[i], value, NONE);
     }
   }
 }
 
 }  // namespace
 
 TEST(TryHasOwnProperty) {
-  typedef CodeStubAssembler::Label Label;
+  typedef CodeAssemblerLabel Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   enum Result { kFound, kNotFound, kBailout };
   {
     Node* object = m.Parameter(0);
     Node* unique_name = m.Parameter(1);
@@ skipping 164 matching lines @@
   }
 
   {
     Handle<JSObject> object = isolate->global_proxy();
     CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
     ft.CheckTrue(object, names[0], expect_bailout);
   }
 }
 
 TEST(TryGetOwnProperty) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeAssemblerLabel Label;
+  typedef CodeAssemblerVariable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
   Factory* factory = isolate->factory();
 
   const int kNumParams = 2;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   Handle<Symbol> not_found_symbol = factory->NewSymbol();
   Handle<Symbol> bailout_symbol = factory->NewSymbol();
   {
@@ skipping 197 matching lines @@
 namespace {
 
 void AddElement(Handle<JSObject> object, uint32_t index, Handle<Object> value,
                 PropertyAttributes attributes = NONE) {
   JSObject::AddDataElement(object, index, value, attributes).ToHandleChecked();
 }
 
 }  // namespace
 
 TEST(TryLookupElement) {
-  typedef CodeStubAssembler::Label Label;
+  typedef CodeAssemblerLabel Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 3;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   enum Result { kFound, kNotFound, kBailout };
   {
     Node* object = m.Parameter(0);
-    Node* index = m.SmiToWord32(m.Parameter(1));
+    Node* index = m.SmiUntag(m.Parameter(1));
     Node* expected_result = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m), if_bailout(&m);
 
     Node* map = m.LoadMap(object);
     Node* instance_type = m.LoadMapInstanceType(map);
 
     m.TryLookupElement(object, map, instance_type, index, &if_found,
                        &if_not_found, &if_bailout);
@@ skipping 155 matching lines @@
     ft.CheckTrue(object, smi0, expect_bailout);
   }
 
   {
     Handle<JSObject> object = isolate->global_proxy();
     CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
     ft.CheckTrue(object, smi0, expect_bailout);
   }
 }
 
-TEST(DeferredCodePhiHints) {

[Igor Sheludko, 2016/12/14 15:45:37]

I moved this whole red block to test-code-assembler.cc, updated Variable and
Label typedefs and updated the callsites of SmiFromWord32() and
UndefinedConstant() since these methods do not exist in CodeAssembler().

-  typedef compiler::Node Node;
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  Isolate* isolate(CcTest::InitIsolateOnce());
-  CodeAssemblerTester data(isolate);
-  CodeStubAssembler m(data.state());
-  Label block1(&m, Label::kDeferred);
-  m.Goto(&block1);
-  m.Bind(&block1);
-  {
-    Variable var_object(&m, MachineRepresentation::kTagged);
-    Label loop(&m, &var_object);
-    var_object.Bind(m.IntPtrConstant(0));
-    m.Goto(&loop);
-    m.Bind(&loop);
-    {
-      Node* map = m.LoadMap(var_object.value());
-      var_object.Bind(map);
-      m.Goto(&loop);
-    }
-  }
-  CHECK(!data.GenerateCode().is_null());
-}
-
-TEST(TestOutOfScopeVariable) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  Isolate* isolate(CcTest::InitIsolateOnce());
-  CodeAssemblerTester data(isolate);
-  CodeStubAssembler m(data.state());
-  Label block1(&m);
-  Label block2(&m);
-  Label block3(&m);
-  Label block4(&m);
-  m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block1, &block4);
-  m.Bind(&block4);
-  {
-    Variable var_object(&m, MachineRepresentation::kTagged);
-    m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block2,
-             &block3);
-
-    m.Bind(&block2);
-    var_object.Bind(m.IntPtrConstant(55));
-    m.Goto(&block1);
-
-    m.Bind(&block3);
-    var_object.Bind(m.IntPtrConstant(66));
-    m.Goto(&block1);
-  }
-  m.Bind(&block1);
-  CHECK(!data.GenerateCode().is_null());
-}
-
-TEST(GotoIfException) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  Isolate* isolate(CcTest::InitIsolateOnce());
-
-  const int kNumParams = 1;
-  CodeAssemblerTester data(isolate, kNumParams);
-  CodeStubAssembler m(data.state());
-
-  Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
-  Node* to_string_tag =
-      m.HeapConstant(isolate->factory()->to_string_tag_symbol());
-  Variable exception(&m, MachineRepresentation::kTagged);
-
-  Label exception_handler(&m);
-  Callable to_string = CodeFactory::ToString(isolate);
-  Node* string = m.CallStub(to_string, context, to_string_tag);
-  m.GotoIfException(string, &exception_handler, &exception);
-  m.Return(string);
-
-  m.Bind(&exception_handler);
-  m.Return(exception.value());
-
-  Handle<Code> code = data.GenerateCode();
-  CHECK(!code.is_null());
-
-  FunctionTester ft(code, kNumParams);
-  Handle<Object> result = ft.Call().ToHandleChecked();
-
-  // Should be a TypeError.
-  CHECK(result->IsJSObject());
-
-  Handle<Object> constructor =
-      Object::GetPropertyOrElement(result,
-                                   isolate->factory()->constructor_string())
-          .ToHandleChecked();
-  CHECK(constructor->SameValue(*isolate->type_error_function()));
-}
-
-TEST(GotoIfExceptionMultiple) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  Isolate* isolate(CcTest::InitIsolateOnce());
-
-  const int kNumParams = 4;  // receiver, first, second, third
-  CodeAssemblerTester data(isolate, kNumParams);
-  CodeStubAssembler m(data.state());
-
-  Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
-  Node* first_value = m.Parameter(0);
-  Node* second_value = m.Parameter(1);
-  Node* third_value = m.Parameter(2);
-
-  Label exception_handler1(&m);
-  Label exception_handler2(&m);
-  Label exception_handler3(&m);
-  Variable return_value(&m, MachineRepresentation::kWord32);
-  Variable error(&m, MachineRepresentation::kTagged);
-
-  return_value.Bind(m.Int32Constant(0));
-
-  // try { return ToString(param1) } catch (e) { ... }
-  Callable to_string = CodeFactory::ToString(isolate);
-  Node* string = m.CallStub(to_string, context, first_value);
-  m.GotoIfException(string, &exception_handler1, &error);
-  m.Return(string);
-
-  // try { ToString(param2); return 7 } catch (e) { ... }
-  m.Bind(&exception_handler1);
-  return_value.Bind(m.Int32Constant(7));
-  error.Bind(m.UndefinedConstant());
-  string = m.CallStub(to_string, context, second_value);
-  m.GotoIfException(string, &exception_handler2, &error);
-  m.Return(m.SmiFromWord32(return_value.value()));
-
-  // try { ToString(param3); return 7 & ~2; } catch (e) { return e; }
-  m.Bind(&exception_handler2);
-  // Return returnValue & ~2
-  error.Bind(m.UndefinedConstant());
-  string = m.CallStub(to_string, context, third_value);
-  m.GotoIfException(string, &exception_handler3, &error);
-  m.Return(m.SmiFromWord32(
-      m.Word32And(return_value.value(),
-                  m.Word32Xor(m.Int32Constant(2), m.Int32Constant(-1)))));
-
-  m.Bind(&exception_handler3);
-  m.Return(error.value());
-
-  Handle<Code> code = data.GenerateCode();
-  CHECK(!code.is_null());
-
-  FunctionTester ft(code, kNumParams);
-
-  Handle<Object> result;
-  // First handler does not throw, returns result of first value.
-  result = ft.Call(isolate->factory()->undefined_value(),
-                   isolate->factory()->to_string_tag_symbol())
-               .ToHandleChecked();
-  CHECK(String::cast(*result)->IsOneByteEqualTo(OneByteVector("undefined")));
-
-  // First handler returns a number.
-  result = ft.Call(isolate->factory()->to_string_tag_symbol(),
-                   isolate->factory()->undefined_value())
-               .ToHandleChecked();
-  CHECK_EQ(7, Smi::cast(*result)->value());
-
-  // First handler throws, second handler returns a number.
-  result = ft.Call(isolate->factory()->to_string_tag_symbol(),
-                   isolate->factory()->to_primitive_symbol())
-               .ToHandleChecked();
-  CHECK_EQ(7 & ~2, Smi::cast(*result)->value());
-
-  // First handler throws, second handler throws, third handler returns thrown
-  // value.
-  result = ft.Call(isolate->factory()->to_string_tag_symbol(),
-                   isolate->factory()->to_primitive_symbol(),
-                   isolate->factory()->unscopables_symbol())
-               .ToHandleChecked();
-
-  // Should be a TypeError.
-  CHECK(result->IsJSObject());
-
-  Handle<Object> constructor =
-      Object::GetPropertyOrElement(result,
-                                   isolate->factory()->constructor_string())
-          .ToHandleChecked();
-  CHECK(constructor->SameValue(*isolate->type_error_function()));
-}
-
 TEST(AllocateJSObjectFromMap) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   Factory* factory = isolate->factory();
 
   const int kNumParams = 3;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
   {
     Node* map = m.Parameter(0);
@@ skipping 283 matching lines @@
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[4]);
 }
 
 TEST(Arguments) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
-  CodeStubArguments arguments(&m, m.IntPtrConstant(3));
+  CodeStubArguments arguments(&m, m.Int32Constant(3));
 
   CSA_ASSERT(
       &m, m.WordEqual(arguments.AtIndex(0), m.SmiConstant(Smi::FromInt(12))));
   CSA_ASSERT(
       &m, m.WordEqual(arguments.AtIndex(1), m.SmiConstant(Smi::FromInt(13))));
   CSA_ASSERT(
       &m, m.WordEqual(arguments.AtIndex(2), m.SmiConstant(Smi::FromInt(14))));
 
   m.Return(arguments.GetReceiver());
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result = ft.Call(isolate->factory()->undefined_value(),
                                   Handle<Smi>(Smi::FromInt(12), isolate),
                                   Handle<Smi>(Smi::FromInt(13), isolate),
                                   Handle<Smi>(Smi::FromInt(14), isolate))
                               .ToHandleChecked();
   CHECK_EQ(*isolate->factory()->undefined_value(), *result);
 }
 
 TEST(ArgumentsForEach) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
-  CodeStubArguments arguments(&m, m.IntPtrConstant(3));
+  CodeStubArguments arguments(&m, m.Int32Constant(3));
 
-  CodeStubAssembler::Variable sum(&m, MachineType::PointerRepresentation());
-  CodeStubAssembler::VariableList list({&sum}, m.zone());
+  CodeAssemblerVariable sum(&m, MachineRepresentation::kTagged);
+  CodeAssemblerVariableList list({&sum}, m.zone());
 
-  sum.Bind(m.IntPtrConstant(0));
+  sum.Bind(m.SmiConstant(0));
 
   arguments.ForEach(
-      list, [&m, &sum](Node* arg) { sum.Bind(m.IntPtrAdd(sum.value(), arg)); });
+      list, [&m, &sum](Node* arg) { sum.Bind(m.SmiAdd(sum.value(), arg)); });
 
   m.Return(sum.value());
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result = ft.Call(isolate->factory()->undefined_value(),
                                   Handle<Smi>(Smi::FromInt(12), isolate),
                                   Handle<Smi>(Smi::FromInt(13), isolate),
                                   Handle<Smi>(Smi::FromInt(14), isolate))
                               .ToHandleChecked();
   CHECK_EQ(Smi::FromInt(12 + 13 + 14), *result);
 }
 
 TEST(IsDebugActive) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
   CodeAssemblerTester data(isolate, kNumParams);
   CodeStubAssembler m(data.state());
 
-  CodeStubAssembler::Label if_active(&m), if_not_active(&m);
+  CodeAssemblerLabel if_active(&m), if_not_active(&m);
 
   m.Branch(m.IsDebugActive(), &if_active, &if_not_active);
   m.Bind(&if_active);
   m.Return(m.TrueConstant());
   m.Bind(&if_not_active);
   m.Return(m.FalseConstant());
 
   Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
@@ skipping 18 matching lines @@
 
 class AppendJSArrayCodeStubAssembler : public CodeStubAssembler {
  public:
   AppendJSArrayCodeStubAssembler(compiler::CodeAssemblerState* state,
                                  ElementsKind kind)
       : CodeStubAssembler(state), kind_(kind) {}
 
   void TestAppendJSArrayImpl(Isolate* isolate, CodeAssemblerTester* tester,
                              Object* o1, Object* o2, Object* o3, Object* o4,
                              int initial_size, int result_size) {
-    typedef CodeStubAssembler::Variable Variable;
-    typedef CodeStubAssembler::Label Label;
+    typedef CodeAssemblerVariable Variable;
+    typedef CodeAssemblerLabel Label;
     Handle<JSArray> array = isolate->factory()->NewJSArray(
         kind_, 2, initial_size, INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
     JSObject::SetElement(isolate, array, 0,
                          Handle<Smi>(Smi::FromInt(1), isolate), SLOPPY)
         .Check();
     JSObject::SetElement(isolate, array, 1,
                          Handle<Smi>(Smi::FromInt(2), isolate), SLOPPY)
         .Check();
-    CodeStubArguments args(this, IntPtrConstant(kNumParams));
+    CodeStubArguments args(this, Int32Constant(kNumParams));
     Variable arg_index(this, MachineType::PointerRepresentation());
     Label bailout(this);
     arg_index.Bind(IntPtrConstant(0));
     Node* length = BuildAppendJSArray(
         kind_, HeapConstant(Handle<HeapObject>(isolate->context(), isolate)),
         HeapConstant(array), args, arg_index, &bailout);
     Return(length);
 
     Bind(&bailout);
     Return(SmiTag(IntPtrAdd(arg_index.value(), IntPtrConstant(2))));
@@ skipping 269 matching lines @@
   CHECK_EQ(Smi::FromInt(1), promise_info->value());
   CHECK(promise_info->tasks()->IsFixedArray());
   CHECK(promise_info->deferred()->IsFixedArray());
   CHECK(promise_info->context()->IsContext());
   CHECK(promise_info->debug_id()->IsUndefined(isolate));
   CHECK(promise_info->debug_name()->IsUndefined(isolate));
 }
 
 }  // namespace internal
 }  // namespace v8