[Interpreter] Add more bytecode definitions and add operand types.

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"
@@ skipping 12 matching lines @@
 
 void Interpreter::Initialize(bool create_heap_objects) {
   DCHECK(FLAG_ignition);
   if (create_heap_objects) {
     Zone zone;
     HandleScope scope(isolate_);
     Handle<FixedArray> handler_table = isolate_->factory()->NewFixedArray(
         static_cast<int>(Bytecode::kLast) + 1, TENURED);
     isolate_->heap()->public_set_interpreter_table(*handler_table);
 
-#define GENERATE_CODE(Name, _)                                         \
-    {                                                                  \
-      compiler::InterpreterAssembler assembler(isolate_, &zone,        \
-                                               Bytecode::k##Name);     \
-      Do##Name(&assembler);                                            \
-      Handle<Code> code = assembler.GenerateCode();                    \
-      handler_table->set(static_cast<int>(Bytecode::k##Name), *code);  \
-    }
+#define GENERATE_CODE(Name, ...)                                    \
+  {                                                                 \
+    compiler::InterpreterAssembler assembler(isolate_, &zone,       \
+                                             Bytecode::k##Name);    \
+    Do##Name(&assembler);                                           \
+    Handle<Code> code = assembler.GenerateCode();                   \
+    handler_table->set(static_cast<int>(Bytecode::k##Name), *code); \
+  }
     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) {
+void Interpreter::DoLoadSmi0(compiler::InterpreterAssembler* assembler) {

[rmcilroy, 2015/07/27 14:56:58]

I think we should keep this as LoadLiteral0 so that it is distinct from LoadSmi8
(which doesn't actually load '8' but loads 8bits.

[oth, 2015/07/27 16:59:00]

Done.

   Node* register_index = __ BytecodeArg(0);
   __ StoreRegister(__ NumberConstant(0), register_index);
   __ Dispatch();
 }
 
 
+// LoadSmi8 dst, imm8

[rmcilroy, 2015/07/27 14:56:58]

nit - could you update all the comments to have this form and add a small
commentary below it like the other comments.

[oth, 2015/07/27 16:59:00]

Done.

+void Interpreter::DoLoadSmi8(compiler::InterpreterAssembler* assembler) {

[rmcilroy, 2015/07/27 14:56:58]

Is LoadLiteralSmi8 too wordy? (honest question).

[oth, 2015/07/27 16:59:00]

There are two issues here - how handlers are named and what the disassembly
looks like. Personally, I'd lean towards compact and easy to scan disassembler
output. Handlers could have the more descriptive names and the disassembly a
compact and easy scan format by adding an extra argument to DECLARE_BYTECODE?

[rmcilroy, 2015/07/28 08:58:12]

No, I'd rather have the handlers named the same as the bytecode in disassembly.
This is fine I think.

+  UNIMPLEMENTED();
+}
+
+
 // Return the value in register 0.
 void Interpreter::DoReturn(compiler::InterpreterAssembler* assembler) {
   // TODO(rmcilroy) Jump to exit trampoline.
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8