[refactoring] Split CodeAssemblerState out of CodeAssembler

src/interpreter/interpreter.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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 58 matching lines @@
   const OperandScale kOperandScales[] = {
 #define VALUE(Name, _) OperandScale::k##Name,
       OPERAND_SCALE_LIST(VALUE)
 #undef VALUE
   };
 
   for (OperandScale operand_scale : kOperandScales) {
 #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);                                                      \
       PROFILE(                                                                 \
           isolate_,                                                            \
           CodeCreateEvent(                                                     \
               CodeEventListener::BYTECODE_HANDLER_TAG,                         \
               AbstractCode::cast(*code),                                       \
               Bytecodes::ToString(Bytecode::k##Name, operand_scale).c_str())); \
     }                                                                          \
@@ skipping 2590 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8