[interpreter] Add basic framework for bytecode handler code generation.

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 "src/compiler.h"
+#include "src/compiler/interpreter-assembler.h"
+#include "src/factory.h"
+#include "src/interpreter/bytecodes.h"
+#include "src/zone.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+using compiler::Node;
+#define __ assembler->
+
+
+Interpreter::Interpreter() {}
+
+
+void Interpreter::Initialize(Isolate* isolate, bool create_heap_objects) {
+  if (create_heap_objects) {
+    Zone zone;
+    HandleScope scope(isolate);
+    Handle<FixedArray> handler_table = isolate->factory()->NewFixedArray(
+        static_cast<int>(Bytecode::kLast) + 1, TENURED);

[picksi, 2015/07/16 09:08:10]

It's probably macro magic, but Bytecode::kLast is set to -1 in the enum, and I
don't see it being changed later... Should it just be declared in the enum
without being set to -1?

[rmcilroy, 2015/07/16 15:11:09]

This is macro magic ;). It is assigned -1 but then the following two lines:
#define COUNT_BYTECODE(x, _) +1
   BYTECODE_LIST(COUNT_BYTECODE)

are part of the same expression and turn the expressions after post processing
into:
kLast = -1 +1 +1 +1... etc.

I agree this is pretty horrid, however if I just put another entry at the end of
the enum (e.g., kCount) then that will be a new enum value which will need to be
handled specially in any switch statements.  Right now since kLast overlaps with
the last bytecode it doesn't require an extra "case" in switch statements, which
makes the switch code cleaner I think. If you would still prefer to avoid this
then I can change it. 

+    isolate->heap()->public_set_interpreter_table(*handler_table);
+
+#define GENERATE_CODE(Name, _)                                     \
+    {                                                              \
+      compiler::InterpreterAssembler assembler(isolate, &zone,     \
+                                               Bytecode::k##Name); \
+      Do##Name(&assembler);                                        \
+      handler_table->set(static_cast<int>(Bytecode::k##Name),      \
+                         *assembler.GenerateCode());               \
+    }
+    BYTECODE_LIST(GENERATE_CODE)
+#undef GENERATE_CODE
+  }
+}
+
+
+// Load literal '0' into the register index specified by the bytecode's
+// argument.
+void Interpreter::DoLoadLiteral0(compiler::InterpreterAssembler* assembler) {
+  Node* register_index = __ BytecodeArg(0);
+  __ StoreRegister(__ NumberConstant(0), register_index);
+  __ Dispatch();
+}
+
+
+// Return the value in register 0.
+void Interpreter::DoReturn(compiler::InterpreterAssembler* assembler) {
+  __ Return(__ LoadRegister(0));
+}
+
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8