[Intepreter] Addition of BytecodeArrayBuilder and accumulator based bytecodes.

src/interpreter/bytecodes.h

 // 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_INTERPRETER_BYTECODES_H_
 #define V8_INTERPRETER_BYTECODES_H_
 
 #include <iosfwd>
 
 // Clients of this interface shouldn't depend on lots of interpreter internals.
 // Do not include anything from src/interpreter here!
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 // The list of operand types used by bytecodes.
 #define OPERAND_TYPE_LIST(V) \
   V(None)                    \
   V(Imm8)                    \
   V(Reg)
 
 // The list of bytecodes which are interpreted by the interpreter.
-#define BYTECODE_LIST(V)                             \
-  V(LoadLiteral0, OperandType::kReg)                 \
-  V(LoadSmi8, OperandType::kReg, OperandType::kImm8) \
+#define BYTECODE_LIST(V)              \
+  V(LoadLiteral0, OperandType::kNone) \
+  V(LoadSmi8, OperandType::kImm8)     \

[rmcilroy, 2015/07/30 10:12:25]

nit - can we update the bytecodes above to be in the same form as below (i.e.,
Ldr0, LdrSmi8 and also add Lda0 and LdaSmi8?)

Also, could we split up the list with some heading comments (e.g., Constants,
Register moves, Binary Ops, etc.). And maybe add comments for some of the more
difficult to parse operations (e.g, Ldar - "Loads accumulator from a register.")

[oth, 2015/07/30 15:38:42]

Done.

[oth, 2015/07/30 15:38:43]

The pattern has been to add instructions as needed. Constant loads are to the
accumulator at the moment. Probably better to tweak instructions in the
generator patch.

+  V(LdaUndefined, OperandType::kNone) \
+  V(LdaNull, OperandType::kNone)      \
+  V(LdaTheHole, OperandType::kNone)   \
+  V(LdaTrue, OperandType::kNone)      \
+  V(LdaFalse, OperandType::kNone)     \
+  V(Ldar, OperandType::kReg)          \
+  V(Stra, OperandType::kReg)          \
+  V(Add, OperandType::kReg)           \
+  V(Sub, OperandType::kReg)           \
+  V(Mul, OperandType::kReg)           \
+  V(Div, OperandType::kReg)           \
   V(Return, OperandType::kNone)
 
 
 // Enumeration of operand types used by bytecodes.
 enum class OperandType : uint8_t {
 #define DECLARE_OPERAND_TYPE(Name) k##Name,
   OPERAND_TYPE_LIST(DECLARE_OPERAND_TYPE)
 #undef DECLARE_OPERAND_TYPE
 #define COUNT_OPERAND_TYPES(x) +1
   // The COUNT_OPERAND macro will turn this into kLast = -1 +1 +1... which will
@@ skipping 46 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Bytecodes);
 };
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_