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

src/compiler/interpreter-assembler.h

Index: src/compiler/interpreter-assembler.h
diff --git a/src/compiler/interpreter-assembler.h b/src/compiler/interpreter-assembler.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b10e9e13fe8b1caa608102c7bda88fea8649943
--- /dev/null
+++ b/src/compiler/interpreter-assembler.h
@@ -0,0 +1,96 @@
+// 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.
+
+#ifndef V8_COMPILER_INTERPRETER_CODEGEN_H_
+#define V8_COMPILER_INTERPRETER_CODEGEN_H_
+
+// Clients of this interface shouldn't depend on lots of compiler internals.
+// Do not include anything from src/compiler here!
+#include "src/frames.h"
+#include "src/interpreter/bytecodes.h"
+#include "src/smart-pointers.h"
+
+namespace v8 {
+namespace internal {
+
+class Isolate;
+class Zone;
+
+namespace compiler {
+
+class CallDescriptor;
+class CommonOperatorBuilder;
+class Graph;
+class MachineOperatorBuilder;
+class Node;
+class Operator;
+class RawMachineAssembler;
+class Schedule;
+
+class InterpreterAssembler {
+ public:
+  InterpreterAssembler(Isolate* isolate, Zone* zone,
+                       interpreter::Bytecode bytecode);
+  virtual ~InterpreterAssembler();
+
+  Handle<Code> GenerateCode();
+
+  // Constants.
+  Node* Int32Constant(int value);
+  Node* NumberConstant(double value);
+
+  // Returns the bytecode argument |index| for the current bytecode.
+  Node* BytecodeArg(int index);
+
+  // Loads from and stores to the interpreter register file.
+  Node* LoadRegister(int index);
+  Node* LoadRegister(Node* index);
+  void StoreRegister(Node* value, int index);
+  void StoreRegister(Node* value, Node* index);
+
+  // Dispatch to the bytecode.
+  void Dispatch();
+
+ private:
+  static const int kFirstRegsterOffsetFromFp =
+      -kPointerSize - StandardFrameConstants::kFixedFrameSizeFromFp;
+
+  // Returns the pointer to the current bytecode.
+  Node* BytecodePointer();
+  // Returns the pointer to first entry in the interpreter dispatch table.
+  Node* DispatchTablePointer();
+  // Returns the frame pointer for the current function.
+  Node* FramePointer();
+
+  // Returns the offset of register |index|.
+  Node* RegisterFrameOffset(int index);
+  Node* RegisterFrameOffset(Node* index);
+
+  // Returns BytecodePointer() advanced by delta bytecodes. Note: this does not
+  // update BytecodePointer() itself.
+  Node* Advance(int delta);
+
+  // Returns the a call descriptor for interpreter dispatch.
+  const CallDescriptor* GetCallDiscriptorForDispatch();
+
+  // Private helpers which delegate to RawMachineAssembler.
+  Isolate* isolate();
+  Graph* graph();
+  Schedule* schedule();
+  MachineOperatorBuilder* machine();
+  CommonOperatorBuilder* common();
+
+  Zone* zone_;  // Not owned.

[Michael Starzinger, 2015/07/21 13:51:45]

nit: Not sure what the "Not owned" comment tries to convey, can we drop it?

[rmcilroy, 2015/07/23 10:43:54]

This is quite common in Chromium code [1] to identify that the object pointed to
by the pointer is not owned by this class and so shouldn't be deleted in the
destructor. It doesn't seem as common in V8 though so 'll remove it.

[1]
https://code.google.com/p/chromium/codesearch#search/&q=%22Not%20owned%22&sq=...

+  interpreter::Bytecode bytecode_;
+  SmartPointer<RawMachineAssembler> raw_assembler_;
+  bool code_generated_;
+
+  DISALLOW_COPY_AND_ASSIGN(InterpreterAssembler);
+};
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_COMPILER_INTERPRETER_CODEGEN_H_