[refactoring] Split CodeAssemblerState out of CodeAssembler

src/interpreter/interpreter.cc

Index: src/interpreter/interpreter.cc
diff --git a/src/interpreter/interpreter.cc b/src/interpreter/interpreter.cc
index 81aecafecfdfbba9b465c7f54b6f1b685f6bf5e7..e3bafa63140342c9b54ea441c7efa6826a915ad7 100644
--- a/src/interpreter/interpreter.cc
+++ b/src/interpreter/interpreter.cc
@@ -76,10 +76,16 @@ void Interpreter::Initialize() {
 #define GENERATE_CODE(Name, ...)                                               \
   {                                                                            \
     if (Bytecodes::BytecodeHasHandler(Bytecode::k##Name, operand_scale)) {     \
-      InterpreterAssembler assembler(isolate_, &zone, Bytecode::k##Name,       \
+      InterpreterDispatchDescriptor descriptor(isolate_);                      \
+      compiler::CodeAssemblerState state(                                      \

[Michael Starzinger, 2016/11/15 11:53:08]

Actually, come to think of it, we could use the same approach I suggested for
the unit-test here. Make the {CodeAssemblerState} an embedded field inside of
{InterpreterAssembler}. In the case of the interpreter the state is never
separated from the assembler and coupling them together makes the
{InterpreterAssembler} easier to understand. WDYT?

[Igor Sheludko, 2016/11/15 13:06:35]

Then we will be passing a pointer to not yet constructed embedded field to the
base class constructor.

[Jakob Kummerow, 2016/11/15 13:40:32]

For now that would work; but our plans for further cleanup are to have the
interpreter pass State objects (with partially created stubs in them) around to
other generators, in order to share implementation with stub/builtin generation.
To keep the flexibility needed for that, it makes sense not to embed the State
object.

+          isolate_, &zone, descriptor,                                         \
+          Code::ComputeFlags(Code::BYTECODE_HANDLER),                          \
+          Bytecodes::ToString(Bytecode::k##Name),                              \
+          Bytecodes::ReturnCount(Bytecode::k##Name));                          \
+      InterpreterAssembler assembler(&state, Bytecode::k##Name,                \
                                      operand_scale);                           \
       Do##Name(&assembler);                                                    \
-      Handle<Code> code = assembler.GenerateCode();                            \
+      Handle<Code> code = state.GenerateCode();                                \
       size_t index = GetDispatchTableIndex(Bytecode::k##Name, operand_scale);  \
       dispatch_table_[index] = code->entry();                                  \
       TraceCodegen(code);                                                      \