Reland of [refactoring] Split CodeAssemblerState out of CodeAssembler

test/unittests/interpreter/interpreter-assembler-unittest.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 "test/unittests/interpreter/interpreter-assembler-unittest.h"
 
 #include "src/code-factory.h"
-#include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/interface-descriptors.h"
 #include "src/isolate.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/node-test-utils.h"
 
 using ::testing::_;
 
 namespace v8 {
 namespace internal {
 
 using namespace compiler;
 
 namespace interpreter {
 
+InterpreterAssemblerTestState::InterpreterAssemblerTestState(
+    InterpreterAssemblerTest* test, Bytecode bytecode)
+    : compiler::CodeAssemblerState(
+          test->isolate(), test->zone(),
+          InterpreterDispatchDescriptor(test->isolate()),
+          Code::ComputeFlags(Code::BYTECODE_HANDLER),
+          Bytecodes::ToString(bytecode), Bytecodes::ReturnCount(bytecode)) {}
+
 const interpreter::Bytecode kBytecodes[] = {
 #define DEFINE_BYTECODE(Name, ...) interpreter::Bytecode::k##Name,
     BYTECODE_LIST(DEFINE_BYTECODE)
 #undef DEFINE_BYTECODE
 };
 
 Matcher<Node*> IsIntPtrConstant(const intptr_t value) {
   return kPointerSize == 8 ? IsInt64Constant(static_cast<int64_t>(value))
                            : IsInt32Constant(static_cast<int32_t>(value));
 }
@@ skipping 257 matching lines @@
     case OperandSize::kQuad:
       return IsUnsignedQuadOperand(offset);
     case OperandSize::kNone:
       UNREACHABLE();
   }
   return nullptr;
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, Dispatch) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* tail_call_node = m.Dispatch();
 
     OperandScale operand_scale = OperandScale::kSingle;
     Matcher<Node*> next_bytecode_offset_matcher =
         IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                     IsIntPtrConstant(
                         interpreter::Bytecodes::Size(bytecode, operand_scale)));
     Matcher<Node*> target_bytecode_matcher =
         m.IsLoad(MachineType::Uint8(),
                  IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
@@ skipping 45 matching lines @@
 
 TARGET_TEST_F(InterpreterAssemblerTest, Jump) {
   // If debug code is enabled we emit extra code in Jump.
   if (FLAG_debug_code) return;
 
   int jump_offsets[] = {-9710, -77, 0, +3, +97109};
   TRACED_FOREACH(int, jump_offset, jump_offsets) {
     TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
       if (!interpreter::Bytecodes::IsJump(bytecode)) return;
 
-      InterpreterAssemblerForTest m(this, bytecode);
+      InterpreterAssemblerTestState state(this, bytecode);
+      InterpreterAssemblerForTest m(&state, bytecode);
       Node* tail_call_node = m.Jump(m.IntPtrConstant(jump_offset));
 
       Matcher<Node*> next_bytecode_offset_matcher = IsIntPtrAdd(
           IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
           IsIntPtrConstant(jump_offset));
       Matcher<Node*> target_bytecode_matcher =
           m.IsLoad(MachineType::Uint8(), _, next_bytecode_offset_matcher);
       if (kPointerSize == 8) {
         target_bytecode_matcher =
             IsChangeUint32ToUint64(target_bytecode_matcher);
@@ skipping 13 matching lines @@
                      _, _));
     }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) {
   static const OperandScale kOperandScales[] = {
       OperandScale::kSingle, OperandScale::kDouble, OperandScale::kQuadruple};
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     TRACED_FOREACH(interpreter::OperandScale, operand_scale, kOperandScales) {
-      InterpreterAssemblerForTest m(this, bytecode, operand_scale);
+      InterpreterAssemblerTestState state(this, bytecode);
+      InterpreterAssemblerForTest m(&state, bytecode, operand_scale);
       int number_of_operands =
           interpreter::Bytecodes::NumberOfOperands(bytecode);
       for (int i = 0; i < number_of_operands; i++) {
         int offset = interpreter::Bytecodes::GetOperandOffset(bytecode, i,
                                                               operand_scale);
         OperandType operand_type =
             interpreter::Bytecodes::GetOperandType(bytecode, i);
         OperandSize operand_size =
             Bytecodes::SizeOfOperand(operand_type, operand_scale);
         switch (interpreter::Bytecodes::GetOperandType(bytecode, i)) {
@@ skipping 44 matching lines @@
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, GetSetAccumulator) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     if (!interpreter::Bytecodes::ReadsAccumulator(bytecode) ||
         !interpreter::Bytecodes::WritesAccumulator(bytecode)) {
       continue;
     }
 
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     // Should be incoming accumulator if not set.
     EXPECT_THAT(m.GetAccumulator(),
                 IsParameter(InterpreterDispatchDescriptor::kAccumulator));
     // Should be set by SetAccumulator.
     Node* accumulator_value_1 = m.Int32Constant(0xdeadbeef);
     m.SetAccumulator(accumulator_value_1);
     EXPECT_THAT(m.GetAccumulator(), accumulator_value_1);
     Node* accumulator_value_2 = m.Int32Constant(42);
     m.SetAccumulator(accumulator_value_2);
     EXPECT_THAT(m.GetAccumulator(), accumulator_value_2);
 
     // Should be passed to next bytecode handler on dispatch.
     Node* tail_call_node = m.Dispatch();
 
     EXPECT_THAT(tail_call_node,
                 IsTailCall(_, _, accumulator_value_2, _, _, _, _));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, GetContext) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     EXPECT_THAT(
         m.GetContext(),
         m.IsLoad(MachineType::AnyTagged(), IsLoadParentFramePointer(),
                  IsIntPtrConstant(Register::current_context().ToOperand()
                                   << kPointerSizeLog2)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, RegisterLocation) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* reg_index_node = m.IntPtrConstant(44);
     Node* reg_location_node = m.RegisterLocation(reg_index_node);
     EXPECT_THAT(reg_location_node,
                 IsIntPtrAdd(IsLoadParentFramePointer(),
                             IsWordShl(reg_index_node,
                                       IsIntPtrConstant(kPointerSizeLog2))));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadRegister) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* reg_index_node = m.IntPtrConstant(44);
     Node* load_reg_node = m.LoadRegister(reg_index_node);
     EXPECT_THAT(load_reg_node,
                 m.IsLoad(MachineType::AnyTagged(), IsLoadParentFramePointer(),
                          IsWordShl(reg_index_node,
                                    IsIntPtrConstant(kPointerSizeLog2))));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, StoreRegister) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* store_value = m.Int32Constant(0xdeadbeef);
     Node* reg_index_node = m.IntPtrConstant(44);
     Node* store_reg_node = m.StoreRegister(store_value, reg_index_node);
     EXPECT_THAT(
         store_reg_node,
         m.IsStore(StoreRepresentation(MachineRepresentation::kTagged,
                                       kNoWriteBarrier),
                   IsLoadParentFramePointer(),
                   IsWordShl(reg_index_node, IsIntPtrConstant(kPointerSizeLog2)),
                   store_value));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, SmiTag) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* value = m.Int32Constant(44);
     EXPECT_THAT(m.SmiTag(value), IsBitcastWordToTaggedSigned(IsIntPtrConstant(
                                      static_cast<intptr_t>(44)
                                      << (kSmiShiftSize + kSmiTagSize))));
     EXPECT_THAT(m.SmiUntag(value),
                 IsWordSar(IsBitcastTaggedToWord(value),
                           IsIntPtrConstant(kSmiShiftSize + kSmiTagSize)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, IntPtrAdd) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* a = m.Int32Constant(0);
     Node* b = m.Int32Constant(1);
     Node* add = m.IntPtrAdd(a, b);
     EXPECT_THAT(add, IsIntPtrAdd(a, b));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, IntPtrSub) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* a = m.Int32Constant(0);
     Node* b = m.Int32Constant(1);
     Node* add = m.IntPtrSub(a, b);
     EXPECT_THAT(add, IsIntPtrSub(a, b));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, WordShl) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* a = m.IntPtrConstant(0);
     Node* add = m.WordShl(a, 10);
     EXPECT_THAT(add, IsWordShl(a, IsIntPtrConstant(10)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadConstantPoolEntry) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* index = m.IntPtrConstant(2);
     Node* load_constant = m.LoadConstantPoolEntry(index);
     Matcher<Node*> constant_pool_matcher = m.IsLoad(
         MachineType::AnyTagged(),
         IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
         IsIntPtrConstant(BytecodeArray::kConstantPoolOffset - kHeapObjectTag));
     EXPECT_THAT(
         load_constant,
         m.IsLoad(MachineType::AnyTagged(), constant_pool_matcher,
                  IsIntPtrAdd(
                      IsIntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
                      IsWordShl(index, IsIntPtrConstant(kPointerSizeLog2)))));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadObjectField) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* object = m.IntPtrConstant(0xdeadbeef);
     int offset = 16;
     Node* load_field = m.LoadObjectField(object, offset);
     EXPECT_THAT(load_field,
                 m.IsLoad(MachineType::AnyTagged(), object,
                          IsIntPtrConstant(offset - kHeapObjectTag)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime2) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* arg1 = m.Int32Constant(2);
     Node* arg2 = m.Int32Constant(3);
     Node* context = m.Int32Constant(4);
     Node* call_runtime = m.CallRuntime(Runtime::kAdd, context, arg1, arg2);
     EXPECT_THAT(call_runtime,
                 IsCall(_, _, arg1, arg2, _, IsInt32Constant(2), context, _, _));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime) {
   const int kResultSizes[] = {1, 2};
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     TRACED_FOREACH(int, result_size, kResultSizes) {
-      InterpreterAssemblerForTest m(this, bytecode);
+      InterpreterAssemblerTestState state(this, bytecode);
+      InterpreterAssemblerForTest m(&state, bytecode);
       Callable builtin = CodeFactory::InterpreterCEntry(isolate(), result_size);
 
       Node* function_id = m.Int32Constant(0);
       Node* first_arg = m.Int32Constant(1);
       Node* arg_count = m.Int32Constant(2);
       Node* context = m.Int32Constant(4);
 
       Matcher<Node*> function_table = IsExternalConstant(
           ExternalReference::runtime_function_table_address(isolate()));
       Matcher<Node*> function = IsIntPtrAdd(
@@ skipping 10 matching lines @@
                          first_arg, function_entry, context, _, _));
     }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallJS) {
   TailCallMode tail_call_modes[] = {TailCallMode::kDisallow,
                                     TailCallMode::kAllow};
   TRACED_FOREACH(TailCallMode, tail_call_mode, tail_call_modes) {
     TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-      InterpreterAssemblerForTest m(this, bytecode);
+      InterpreterAssemblerTestState state(this, bytecode);
+      InterpreterAssemblerForTest m(&state, bytecode);
       Callable builtin =
           CodeFactory::InterpreterPushArgsAndCall(isolate(), tail_call_mode);
       Node* function = m.Int32Constant(0);
       Node* first_arg = m.Int32Constant(1);
       Node* arg_count = m.Int32Constant(2);
       Node* context = m.Int32Constant(3);
       Node* call_js =
           m.CallJS(function, context, first_arg, arg_count, tail_call_mode);
       EXPECT_THAT(call_js, IsCall(_, IsHeapConstant(builtin.code()), arg_count,
                                   first_arg, function, context, _, _));
     }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadTypeFeedbackVector) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
+    InterpreterAssemblerTestState state(this, bytecode);
+    InterpreterAssemblerForTest m(&state, bytecode);
     Node* feedback_vector = m.LoadTypeFeedbackVector();
 
     Matcher<Node*> load_function_matcher =
         m.IsLoad(MachineType::AnyTagged(), IsLoadParentFramePointer(),
                  IsIntPtrConstant(Register::function_closure().ToOperand()
                                   << kPointerSizeLog2));
     Matcher<Node*> load_literals_matcher = m.IsLoad(
         MachineType::AnyTagged(), load_function_matcher,
         IsIntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag));
 
     EXPECT_THAT(feedback_vector,
                 m.IsLoad(MachineType::AnyTagged(), load_literals_matcher,
                          IsIntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
                                           kHeapObjectTag)));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8