[refactoring] Split CodeAssemblerState out of CodeAssembler

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/ic/stub-cache.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;
 
-typedef compiler::CodeAssemblerTesterImpl<CodeStubAssembler>
-    CodeStubAssemblerTester;
-
 TEST(FixedArrayAccessSmiIndex) {
   Isolate* isolate(CcTest::InitIsolateOnce());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  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 = m.GenerateCode();
-  FunctionTester ft(descriptor, code);
+  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());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  CodeAssemblerTester data(isolate);
+  CodeStubAssembler m(data.state());
   Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234);
   m.Return(m.SmiTag(
       m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number)))));
-  Handle<Code> code = m.GenerateCode();
-  FunctionTester ft(descriptor, code);
+  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());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  CodeAssemblerTester data(isolate);
+  CodeStubAssembler m(data.state());
   Handle<HeapObject> undefined = isolate->factory()->undefined_value();
   m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined))));
-  Handle<Code> code = m.GenerateCode();
-  FunctionTester ft(descriptor, code);
+  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());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  CodeAssemblerTester data(isolate);
+  CodeStubAssembler m(data.state());
 
   class TestBitField : public BitField<unsigned, 3, 3> {};
   m.Return(
       m.SmiTag(m.DecodeWordFromWord32<TestBitField>(m.Int32Constant(0x2f))));
-  Handle<Code> code = m.GenerateCode();
-  FunctionTester ft(descriptor, code);
+  Handle<Code> code = data.GenerateCode();
+  FunctionTester ft(code);
   MaybeHandle<Object> result = ft.Call();
   // value  = 00101111
   // mask   = 00111000
   // result = 101
   CHECK_EQ(5, Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(JSFunction) {
   const int kNumParams = 3;  // Receiver, left, right.
   Isolate* isolate(CcTest::InitIsolateOnce());
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
   m.Return(m.SmiFromWord32(m.Int32Add(m.SmiToWord32(m.Parameter(1)),
                                       m.SmiToWord32(m.Parameter(2)))));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   MaybeHandle<Object> result = ft.Call(isolate->factory()->undefined_value(),
                                        handle(Smi::FromInt(23), isolate),
                                        handle(Smi::FromInt(34), isolate));
   CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value());
 }
 
 TEST(ComputeIntegerHash) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 2;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
   m.Return(m.SmiFromWord32(m.ComputeIntegerHash(
       m.SmiToWord32(m.Parameter(0)), m.SmiToWord32(m.Parameter(1)))));
 
-  Handle<Code> code = m.GenerateCode();
+  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);
 
     Handle<Smi> key(Smi::FromInt(k), isolate);
     Handle<Object> result = ft.Call(key, hash_seed).ToHandleChecked();
 
     uint32_t hash = ComputeIntegerHash(k, hash_seed->value());
     Smi* expected = Smi::FromInt(hash & Smi::kMaxValue);
     CHECK_EQ(expected, Smi::cast(*result));
   }
 }
 
 TEST(ToString) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 1;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
   m.Return(m.ToString(m.Parameter(kNumParams + 2), m.Parameter(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<FixedArray> test_cases = isolate->factory()->NewFixedArray(5);
   Handle<FixedArray> smi_test = isolate->factory()->NewFixedArray(2);
   smi_test->set(0, Smi::FromInt(42));
   Handle<String> str(isolate->factory()->InternalizeUtf8String("42"));
   smi_test->set(1, *str);
   test_cases->set(0, *smi_test);
 
   Handle<FixedArray> number_test = isolate->factory()->NewFixedArray(2);
@@ skipping 32 matching lines @@
     Handle<String> expected = handle(String::cast(test->get(1)));
     Handle<Object> result = ft.Call(obj).ToHandleChecked();
     CHECK(result->IsString());
     CHECK(String::Equals(Handle<String>::cast(result), expected));
   }
 }
 
 TEST(FlattenString) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 1;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
   m.Return(m.FlattenString(m.Parameter(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<FixedArray> test_cases(isolate->factory()->NewFixedArray(4));
   Handle<String> expected(
       isolate->factory()->InternalizeUtf8String("hello, world!"));
   test_cases->set(0, *expected);
 
   Handle<String> string(
       isolate->factory()->InternalizeUtf8String("filler hello, world! filler"));
   Handle<String> sub_string(
@@ skipping 19 matching lines @@
     CHECK(String::Equals(Handle<String>::cast(result), expected));
   }
 }
 
 TEST(TryToName) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 3;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   enum Result { kKeyIsIndex, kKeyIsUnique, kBailout };
   {
     Node* key = m.Parameter(0);
     Node* expected_result = m.Parameter(1);
     Node* expected_arg = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_keyisindex(&m), if_keyisunique(&m), if_bailout(&m);
     Variable var_index(&m, MachineType::PointerRepresentation());
@@ skipping 18 matching lines @@
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Object> expect_index(Smi::FromInt(kKeyIsIndex), isolate);
   Handle<Object> expect_unique(Smi::FromInt(kKeyIsUnique), isolate);
   Handle<Object> expect_bailout(Smi::FromInt(kBailout), isolate);
 
   {
     // TryToName(<zero smi>) => if_keyisindex: smi value.
     Handle<Object> key(Smi::kZero, isolate);
     ft.CheckTrue(key, expect_index, key);
@@ skipping 70 matching lines @@
   }
 }
 
 namespace {
 
 template <typename Dictionary>
 void TestEntryToIndex() {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
   {
     Node* entry = m.SmiUntag(m.Parameter(0));
     Node* result = m.EntryToIndex<Dictionary>(entry);
     m.Return(m.SmiTag(result));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   // Test a wide range of entries but staying linear in the first 100 entries.
   for (int entry = 0; entry < Dictionary::kMaxCapacity;
        entry = entry * 1.01 + 1) {
     Handle<Object> result =
         ft.Call(handle(Smi::FromInt(entry), isolate)).ToHandleChecked();
     CHECK_EQ(Dictionary::EntryToIndex(entry), Smi::cast(*result)->value());
   }
 }
 
 TEST(NameDictionaryEntryToIndex) { TestEntryToIndex<NameDictionary>(); }
 TEST(GlobalDictionaryEntryToIndex) { TestEntryToIndex<GlobalDictionary>(); }
 
 }  // namespace
 
 namespace {
 
 template <typename Dictionary>
 void TestNameDictionaryLookup() {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  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);
@@ skipping 13 matching lines @@
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
   Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
 
   Handle<Dictionary> dictionary = Dictionary::New(isolate, 40);
   PropertyDetails fake_details = PropertyDetails::Empty();
 
   Factory* factory = isolate->factory();
   Handle<Name> keys[] = {
@@ skipping 51 matching lines @@
 
 namespace {
 
 template <typename Dictionary>
 void TestNumberDictionaryLookup() {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  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* expected_result = m.Parameter(2);
     Node* expected_arg = m.Parameter(3);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m);
@@ skipping 13 matching lines @@
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
   Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
 
   const int kKeysCount = 1000;
   Handle<Dictionary> dictionary = Dictionary::New(isolate, kKeysCount);
   uint32_t keys[kKeysCount];
 
   Handle<Object> fake_value(Smi::FromInt(42), isolate);
@@ skipping 82 matching lines @@
   }
 }
 
 }  // namespace
 
 TEST(TryHasOwnProperty) {
   typedef CodeStubAssembler::Label Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   enum Result { kFound, kNotFound, kBailout };
   {
     Node* object = m.Parameter(0);
     Node* unique_name = 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);
 
@@ skipping 17 matching lines @@
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
   Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
   Handle<Object> expect_bailout(Smi::FromInt(kBailout), isolate);
 
   Factory* factory = isolate->factory();
 
   Handle<Name> deleted_property_name =
       factory->InternalizeUtf8String("deleted");
@@ skipping 127 matching lines @@
   }
 }
 
 TEST(TryGetOwnProperty) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
   Factory* factory = isolate->factory();
 
   const int kNumParams = 2;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   Handle<Symbol> not_found_symbol = factory->NewSymbol();
   Handle<Symbol> bailout_symbol = factory->NewSymbol();
   {
     Node* object = m.Parameter(0);
     Node* unique_name = m.Parameter(1);
     Node* context = m.Parameter(kNumParams + 2);
 
     Variable var_value(&m, MachineRepresentation::kTagged);
     Label if_found(&m), if_not_found(&m), if_bailout(&m);
 
     Node* map = m.LoadMap(object);
     Node* instance_type = m.LoadMapInstanceType(map);
 
     m.TryGetOwnProperty(context, object, object, map, instance_type,
                         unique_name, &if_found, &var_value, &if_not_found,
                         &if_bailout);
 
     m.Bind(&if_found);
     m.Return(var_value.value());
 
     m.Bind(&if_not_found);
     m.Return(m.HeapConstant(not_found_symbol));
 
     m.Bind(&if_bailout);
     m.Return(m.HeapConstant(bailout_symbol));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Name> deleted_property_name =
       factory->InternalizeUtf8String("deleted");
 
   Handle<Name> names[] = {
       factory->InternalizeUtf8String("bb"),
       factory->NewSymbol(),
       factory->InternalizeUtf8String("a"),
       factory->InternalizeUtf8String("ccc"),
@@ skipping 166 matching lines @@
   JSObject::AddDataElement(object, index, value, attributes).ToHandleChecked();
 }
 
 }  // namespace
 
 TEST(TryLookupElement) {
   typedef CodeStubAssembler::Label Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 3;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  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* expected_result = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m), if_bailout(&m);
 
@@ skipping 17 matching lines @@
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Factory* factory = isolate->factory();
   Handle<Object> smi0(Smi::kZero, isolate);
   Handle<Object> smi1(Smi::FromInt(1), isolate);
   Handle<Object> smi7(Smi::FromInt(7), isolate);
   Handle<Object> smi13(Smi::FromInt(13), isolate);
   Handle<Object> smi42(Smi::FromInt(42), isolate);
 
   Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
@@ skipping 127 matching lines @@
     CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
     ft.CheckTrue(object, smi0, expect_bailout);
   }
 }
 
 TEST(DeferredCodePhiHints) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  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(!m.GenerateCode().is_null());
+  CHECK(!data.GenerateCode().is_null());
 }
 
 TEST(TestOutOfScopeVariable) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
-  VoidDescriptor descriptor(isolate);
-  CodeStubAssemblerTester m(isolate, descriptor);
+  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(!m.GenerateCode().is_null());
+  CHECK(!data.GenerateCode().is_null());
 }
 
 namespace {
 
 void TestStubCacheOffsetCalculation(StubCache::Table table) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 2;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   {
     Node* name = m.Parameter(0);
     Node* map = m.Parameter(1);
     Node* primary_offset = m.StubCachePrimaryOffset(name, map);
     Node* result;
     if (table == StubCache::kPrimary) {
       result = primary_offset;
     } else {
       CHECK_EQ(StubCache::kSecondary, table);
       result = m.StubCacheSecondaryOffset(name, primary_offset);
     }
     m.Return(m.SmiFromWord32(result));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Factory* factory = isolate->factory();
   Handle<Name> names[] = {
       factory->NewSymbol(),
       factory->InternalizeUtf8String("a"),
       factory->InternalizeUtf8String("bb"),
       factory->InternalizeUtf8String("ccc"),
       factory->NewPrivateSymbol(),
       factory->InternalizeUtf8String("dddd"),
@@ skipping 47 matching lines @@
 }
 
 TEST(StubCacheSecondaryOffset) {
   TestStubCacheOffsetCalculation(StubCache::kSecondary);
 }
 
 namespace {
 
 Handle<Code> CreateCodeWithFlags(Code::Flags flags) {
   Isolate* isolate(CcTest::InitIsolateOnce());
-  CodeStubAssemblerTester m(isolate, flags);
+  CodeAssemblerTester data(isolate, flags);
+  CodeStubAssembler m(data.state());
   m.Return(m.UndefinedConstant());
-  return m.GenerateCodeCloseAndEscape();
+  return data.GenerateCodeCloseAndEscape();
 }
 
 }  // namespace
 
 TEST(TryProbeStubCache) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 3;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   Code::Kind ic_kind = Code::LOAD_IC;
   StubCache stub_cache(isolate, ic_kind);
   stub_cache.Clear();
 
   {
     Node* receiver = m.Parameter(0);
     Node* name = m.Parameter(1);
     Node* expected_handler = m.Parameter(2);
 
@@ skipping 12 matching lines @@
     m.Branch(m.WordEqual(expected_handler, m.IntPtrConstant(0)), &passed,
              &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
     m.Bind(&failed);
     m.Return(m.BooleanConstant(false));
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   std::vector<Handle<Name>> names;
   std::vector<Handle<JSObject>> receivers;
   std::vector<Handle<Code>> handlers;
 
   base::RandomNumberGenerator rand_gen(FLAG_random_seed);
 
   Factory* factory = isolate->factory();
 
@@ skipping 90 matching lines @@
   // Ensure we performed both kind of queries.
   CHECK(queried_existing && queried_non_existing);
 }
 
 TEST(GotoIfException) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
-  // Emulate TFJ builtin
-  CodeStubAssemblerTester m(isolate, kNumParams, Code::BUILTIN);
+  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 = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result = ft.Call().ToHandleChecked();
 
-  // Should be a TypeError
+  // 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
-  // Emulate TFJ builtin
-  CodeStubAssemblerTester m(isolate, kNumParams, Code::BUILTIN);
+  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);
@@ skipping 21 matching lines @@
   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 = m.GenerateCode();
+  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
+  // 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
+  // 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
+  // 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
+  // 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;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   {
     Node* map = m.Parameter(0);
     Node* properties = m.Parameter(1);
     Node* elements = m.Parameter(2);
 
     Node* result = m.AllocateJSObjectFromMap(map, properties, elements);
 
     m.Return(result);
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Handle<Map> maps[] = {
       handle(isolate->object_function()->initial_map(), isolate),
       handle(isolate->array_function()->initial_map(), isolate),
   };
 
 #define VERIFY(result, map_value, properties_value, elements_value) \
   CHECK_EQ(result->map(), map_value);                               \
   CHECK_EQ(result->properties(), properties_value);                 \
@@ skipping 30 matching lines @@
     isolate->heap()->Verify();
 #endif
   }
 #undef VERIFY
 }
 
 TEST(AllocateNameDictionary) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   {
     Node* capacity = m.Parameter(0);
     Node* result = m.AllocateNameDictionary(m.SmiUntag(capacity));
     m.Return(result);
   }
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   {
     for (int i = 0; i < 256; i = i * 1.1 + 1) {
       Handle<Object> result =
           ft.Call(handle(Smi::FromInt(i), isolate)).ToHandleChecked();
       Handle<NameDictionary> dict = NameDictionary::New(isolate, i);
       // Both dictionaries should be memory equal.
       int size =
           FixedArrayBase::kHeaderSize + (dict->length() - 1) * kPointerSize;
       CHECK_EQ(0, memcmp(*dict, *result, size));
     }
   }
 }
 
 TEST(PopAndReturnConstant) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  const int kNumProgramaticParams = 2;
-  CodeStubAssemblerTester m(isolate, kNumParams - kNumProgramaticParams);
+  const int kNumProgrammaticParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams - kNumProgrammaticParams);
+  CodeStubAssembler m(data.state());
 
   // Call a function that return |kNumProgramaticParams| parameters in addition
   // to those specified by the static descriptor. |kNumProgramaticParams| is
   // specified as a constant.
-  m.PopAndReturn(m.Int32Constant(kNumProgramaticParams),
+  m.PopAndReturn(m.Int32Constant(kNumProgrammaticParams),
                  m.SmiConstant(Smi::FromInt(1234)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result;
   for (int test_count = 0; test_count < 100; ++test_count) {
     result = ft.Call(isolate->factory()->undefined_value(),
                      Handle<Smi>(Smi::FromInt(1234), isolate),
                      isolate->factory()->undefined_value(),
                      isolate->factory()->undefined_value())
                  .ToHandleChecked();
     CHECK_EQ(1234, Handle<Smi>::cast(result)->value());
   }
 }
 
 TEST(PopAndReturnVariable) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  const int kNumProgramaticParams = 2;
-  CodeStubAssemblerTester m(isolate, kNumParams - kNumProgramaticParams);
+  const int kNumProgrammaticParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams - kNumProgrammaticParams);
+  CodeStubAssembler m(data.state());
 
   // Call a function that return |kNumProgramaticParams| parameters in addition
   // to those specified by the static descriptor. |kNumProgramaticParams| is
   // passed in as a parameter to the function so that it can't be recongized as
   // a constant.
   m.PopAndReturn(m.SmiUntag(m.Parameter(1)), m.SmiConstant(Smi::FromInt(1234)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result;
   for (int test_count = 0; test_count < 100; ++test_count) {
     result = ft.Call(isolate->factory()->undefined_value(),
                      Handle<Smi>(Smi::FromInt(1234), isolate),
                      isolate->factory()->undefined_value(),
-                     Handle<Smi>(Smi::FromInt(kNumProgramaticParams), isolate))
+                     Handle<Smi>(Smi::FromInt(kNumProgrammaticParams), isolate))
                  .ToHandleChecked();
     CHECK_EQ(1234, Handle<Smi>::cast(result)->value());
   }
 }
 
 TEST(OneToTwoByteStringCopy) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
-  CodeStubAssemblerTester m(isolate, 2);
+  const int kNumParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   m.CopyStringCharacters(
       m.Parameter(0), m.Parameter(1), m.SmiConstant(Smi::FromInt(0)),
       m.SmiConstant(Smi::FromInt(0)), m.SmiConstant(Smi::FromInt(5)),
       String::ONE_BYTE_ENCODING, String::TWO_BYTE_ENCODING,
       CodeStubAssembler::SMI_PARAMETERS);
   m.Return(m.SmiConstant(Smi::FromInt(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   Handle<String> string1 = isolate->factory()->InternalizeUtf8String("abcde");
   uc16 array[] = {1000, 1001, 1002, 1003, 1004};
   Vector<const uc16> str(array);
   Handle<String> string2 =
       isolate->factory()->NewStringFromTwoByte(str).ToHandleChecked();
   FunctionTester ft(code, 2);
   ft.Call(string1, string2);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[0],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[0]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[1],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[1]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[2],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[2]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[3],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[3]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[4],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[4]);
 }
 
 TEST(OneToOneByteStringCopy) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
-  CodeStubAssemblerTester m(isolate, 2);
+  const int kNumParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   m.CopyStringCharacters(
       m.Parameter(0), m.Parameter(1), m.SmiConstant(Smi::FromInt(0)),
       m.SmiConstant(Smi::FromInt(0)), m.SmiConstant(Smi::FromInt(5)),
       String::ONE_BYTE_ENCODING, String::ONE_BYTE_ENCODING,
       CodeStubAssembler::SMI_PARAMETERS);
   m.Return(m.SmiConstant(Smi::FromInt(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   Handle<String> string1 = isolate->factory()->InternalizeUtf8String("abcde");
   uint8_t array[] = {100, 101, 102, 103, 104};
   Vector<const uint8_t> str(array);
   Handle<String> string2 =
       isolate->factory()->NewStringFromOneByte(str).ToHandleChecked();
   FunctionTester ft(code, 2);
   ft.Call(string1, string2);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[0],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[0]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[1],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[1]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[2],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[2]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[3],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[3]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[4],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[4]);
 }
 
 TEST(OneToOneByteStringCopyNonZeroStart) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
-  CodeStubAssemblerTester m(isolate, 2);
+  const int kNumParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   m.CopyStringCharacters(
       m.Parameter(0), m.Parameter(1), m.SmiConstant(Smi::FromInt(0)),
       m.SmiConstant(Smi::FromInt(3)), m.SmiConstant(Smi::FromInt(2)),
       String::ONE_BYTE_ENCODING, String::ONE_BYTE_ENCODING,
       CodeStubAssembler::SMI_PARAMETERS);
   m.Return(m.SmiConstant(Smi::FromInt(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   Handle<String> string1 = isolate->factory()->InternalizeUtf8String("abcde");
   uint8_t array[] = {100, 101, 102, 103, 104};
   Vector<const uint8_t> str(array);
   Handle<String> string2 =
       isolate->factory()->NewStringFromOneByte(str).ToHandleChecked();
   FunctionTester ft(code, 2);
   ft.Call(string1, string2);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[0],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[3]);
   CHECK_EQ(Handle<SeqOneByteString>::cast(string1)->GetChars()[1],
            Handle<SeqOneByteString>::cast(string2)->GetChars()[4]);
   CHECK_EQ(100, Handle<SeqOneByteString>::cast(string2)->GetChars()[0]);
   CHECK_EQ(101, Handle<SeqOneByteString>::cast(string2)->GetChars()[1]);
   CHECK_EQ(102, Handle<SeqOneByteString>::cast(string2)->GetChars()[2]);
 }
 
 TEST(TwoToTwoByteStringCopy) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
-  CodeStubAssemblerTester m(isolate, 2);
+  const int kNumParams = 2;
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   m.CopyStringCharacters(
       m.Parameter(0), m.Parameter(1), m.SmiConstant(Smi::FromInt(0)),
       m.SmiConstant(Smi::FromInt(0)), m.SmiConstant(Smi::FromInt(5)),
       String::TWO_BYTE_ENCODING, String::TWO_BYTE_ENCODING,
       CodeStubAssembler::SMI_PARAMETERS);
   m.Return(m.SmiConstant(Smi::FromInt(0)));
 
-  Handle<Code> code = m.GenerateCode();
+  Handle<Code> code = data.GenerateCode();
   CHECK(!code.is_null());
 
   uc16 array1[] = {2000, 2001, 2002, 2003, 2004};
   Vector<const uc16> str1(array1);
   Handle<String> string1 =
       isolate->factory()->NewStringFromTwoByte(str1).ToHandleChecked();
   uc16 array2[] = {1000, 1001, 1002, 1003, 1004};
   Vector<const uc16> str2(array2);
   Handle<String> string2 =
       isolate->factory()->NewStringFromTwoByte(str2).ToHandleChecked();
   FunctionTester ft(code, 2);
   ft.Call(string1, string2);
   CHECK_EQ(Handle<SeqTwoByteString>::cast(string1)->GetChars()[0],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[0]);
   CHECK_EQ(Handle<SeqTwoByteString>::cast(string1)->GetChars()[1],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[1]);
   CHECK_EQ(Handle<SeqTwoByteString>::cast(string1)->GetChars()[2],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[2]);
   CHECK_EQ(Handle<SeqTwoByteString>::cast(string1)->GetChars()[3],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[3]);
   CHECK_EQ(Handle<SeqTwoByteString>::cast(string1)->GetChars()[4],
            Handle<SeqTwoByteString>::cast(string2)->GetChars()[4]);
 }
 
 TEST(Arguments) {
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   CodeStubArguments arguments(&m, m.IntPtrConstant(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 = m.GenerateCode();
+  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;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
 
   CodeStubArguments arguments(&m, m.IntPtrConstant(3));
 
-  CodeStubAssemblerTester::Variable sum(&m,
-                                        MachineType::PointerRepresentation());
-  CodeStubAssemblerTester::VariableList list({&sum}, m.zone());
+  CodeStubAssembler::Variable sum(&m, MachineType::PointerRepresentation());
+  CodeStubAssembler::VariableList list({&sum}, m.zone());
 
   sum.Bind(m.IntPtrConstant(0));
 
   arguments.ForEach(list, [&m, &sum](CodeStubAssembler* assembler, Node* arg) {
     sum.Bind(assembler->IntPtrAdd(sum.value(), arg));
   });
 
   m.Return(sum.value());
 
-  Handle<Code> code = m.GenerateCode();
+  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);
 }
 
 }  // namespace internal
 }  // namespace v8