[interpreter, debugger] support debug breaks via bytecode array copy

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.
@@ skipping 42 matching lines @@
 
 #define NON_REGISTER_OPERAND_TYPE_LIST(V) \
   INVALID_OPERAND_TYPE_LIST(V)            \
   SCALAR_OPERAND_TYPE_LIST(V)
 
 // The list of operand types used by bytecodes.
 #define OPERAND_TYPE_LIST(V)        \
   NON_REGISTER_OPERAND_TYPE_LIST(V) \
   REGISTER_OPERAND_TYPE_LIST(V)
 
+// Define one debug break bytecode for each size.
+#define DEBUG_BREAK_BYTECODE_LIST(V)                                           \
+  V(DebugBreak1, OperandType::kNone)                                           \
+  V(DebugBreak2, OperandType::kReg8)                                           \
+  V(DebugBreak3, OperandType::kReg16)                                          \
+  V(DebugBreak4, OperandType::kReg16, OperandType::kReg8)                      \
+  V(DebugBreak5, OperandType::kReg16, OperandType::kReg16)                     \
+  V(DebugBreak6, OperandType::kReg16, OperandType::kReg16, OperandType::kReg8) \
+  V(DebugBreak7, OperandType::kReg16, OperandType::kReg16,                     \
+    OperandType::kReg16)                                                       \
+  V(DebugBreak8, OperandType::kReg16, OperandType::kReg16,                     \
+    OperandType::kReg16, OperandType::kReg8)                                   \
+  V(DebugBreak9, OperandType::kReg16, OperandType::kReg16,                     \
+    OperandType::kReg16, OperandType::kReg16)

[Yang, 2016/02/16 09:22:20]

These are more than I originally thought. But we do have instructions of these
sizes. See for example CallRuntimeForPairWide, which has 4 16-bit operands.

[rmcilroy, 2016/02/16 10:46:38]

Yeah, I realized this yesterday after leaving work. I guess this still works for
now. Could you name them by operand size (DebugBreak0 - DebugBreak8) please.

[Yang, 2016/02/19 13:09:18]

Done.

+
 // The list of bytecodes which are interpreted by the interpreter.
 #define BYTECODE_LIST(V)                                                       \
                                                                                \
   /* Loading the accumulator */                                                \
   V(LdaZero, OperandType::kNone)                                               \
   V(LdaSmi8, OperandType::kImm8)                                               \
   V(LdaUndefined, OperandType::kNone)                                          \
   V(LdaNull, OperandType::kNone)                                               \
   V(LdaTheHole, OperandType::kNone)                                            \
   V(LdaTrue, OperandType::kNone)                                               \
@@ skipping 190 matching lines @@
                                                                                \
   /* Perform a stack guard check */                                            \
   V(StackCheck, OperandType::kNone)                                            \
                                                                                \
   /* Non-local flow control */                                                 \
   V(Throw, OperandType::kNone)                                                 \
   V(ReThrow, OperandType::kNone)                                               \
   V(Return, OperandType::kNone)                                                \
                                                                                \
   /* Debugger */                                                               \
-  V(Debugger, OperandType::kNone)
+  V(Debugger, OperandType::kNone)                                              \
+  DEBUG_BREAK_BYTECODE_LIST(V)
 
 // Enumeration of the size classes of operand types used by bytecodes.
 enum class OperandSize : uint8_t {
   kNone = 0,
   kByte = 1,
   kShort = 2,
 };
 
 
 // Enumeration of operand types used by bytecodes.
@@ skipping 130 matching lines @@
   static OperandSize GetOperandSize(Bytecode bytecode, int i);
 
   // Returns the offset of the i-th operand of |bytecode| relative to the start
   // of the bytecode.
   static int GetOperandOffset(Bytecode bytecode, int i);
 
   // Returns a zero-based bitmap of the register operand positions of
   // |bytecode|.
   static int GetRegisterOperandBitmap(Bytecode bytecode);
 
+  // Returns a debug break bytecode with a matching operand size.
+  static Bytecode GetDebugBreak(Bytecode bytecode);
+
   // Returns the size of the bytecode including its operands.
   static int Size(Bytecode bytecode);
 
   // Returns the size of |operand|.
   static OperandSize SizeOfOperand(OperandType operand);
 
   // Returns true if the bytecode is a conditional jump taking
   // an immediate byte operand (OperandType::kImm8).
   static bool IsConditionalJumpImmediate(Bytecode bytecode);
 
@@ skipping 24 matching lines @@
   // Returns true if the bytecode is a jump or conditional jump taking
   // any kind of operand.
   static bool IsJump(Bytecode bytecode);
 
   // Returns true if the bytecode is a conditional jump, a jump, or a return.
   static bool IsJumpOrReturn(Bytecode bytecode);
 
   // Returns true if the bytecode is a call or a constructor call.
   static bool IsCallOrNew(Bytecode bytecode);
 
+  // Returns true if the bytecode is a debug break.
+  static bool IsDebugBreak(Bytecode bytecode);
+
   // Returns true if |operand_type| is a register index operand (kIdx8/kIdx16).
   static bool IsIndexOperandType(OperandType operand_type);
 
   // Returns true if |operand_type| represents an immediate.
   static bool IsImmediateOperandType(OperandType operand_type);
 
   // Returns true if |operand_type| is a register count operand
   // (kRegCount8/kRegCount16).
   static bool IsRegisterCountOperandType(OperandType operand_type);
 
@@ skipping 20 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_type);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_