[interpreter] Add support for scalable operands.

src/debug/debug.cc

Index: src/debug/debug.cc
diff --git a/src/debug/debug.cc b/src/debug/debug.cc
index 67ca2410da43fd5c342974bcf3f3137ed24d9e07..9c862700f22ce8e35091a12676ce377e6a5922c8 100644
--- a/src/debug/debug.cc
+++ b/src/debug/debug.cc
@@ -217,11 +217,40 @@ void BreakLocation::BytecodeArrayIterator::Next() {
   }
 }
 
+namespace {
+class BytecodePrefixHelper final {

[rmcilroy, 2016/03/16 11:55:54]

As discussed offline, I think we could get rid of the need for the debugger to
need to know about how to read prefix bytecodes if we instead set the breakpoint
on the actual prefix bytecode instead of the subsiquent bytecode. This would
mean we would need to introduce two additional debug break bytecodes which
represent wide and extra wide prefixes, but I think we can git rid of some other
scaled debug break bytecodes anyway.

[oth, 2016/03/17 13:48:38]

Done.

+ public:
+  BytecodePrefixHelper(BytecodeArray* bytecode_array, int offset) {
+    bytecode_ = interpreter::Bytecodes::FromByte(bytecode_array->get(offset));
+    operand_scale_ = interpreter::Bytecodes::GetPrefixBytecodeScale(bytecode_);
+    if (operand_scale_ > 1) {
+      prefix_offset_ = 1;
+      bytecode_ =
+          interpreter::Bytecodes::FromByte(bytecode_array->get(offset + 1));
+    } else {
+      prefix_offset_ = 0;
+    }
+    DCHECK(!interpreter::Bytecodes::IsPrefixScalingBytecode(bytecode_));
+  }
+
+  interpreter::Bytecode bytecode() const { return bytecode_; }
+  int operand_scale() const { return operand_scale_; }
+  int prefix_offset() const { return prefix_offset_; }
+
+ private:
+  interpreter::Bytecode bytecode_;
+  int operand_scale_;
+  int prefix_offset_;
+
+  DISALLOW_COPY_AND_ASSIGN(BytecodePrefixHelper);
+};
+}  // namespace
+
 BreakLocation::DebugBreakType
 BreakLocation::BytecodeArrayIterator::GetDebugBreakType() {
   BytecodeArray* bytecode_array = debug_info_->original_bytecode_array();
-  interpreter::Bytecode bytecode =
-      interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
+  BytecodePrefixHelper bytecode_prefix_helper(bytecode_array, code_offset());
+  interpreter::Bytecode bytecode = bytecode_prefix_helper.bytecode();
 
   if (bytecode == interpreter::Bytecode::kDebugger) {
     return DEBUGGER_STATEMENT;
@@ -404,11 +433,11 @@ void BreakLocation::SetDebugBreak() {
     DebugCodegen::PatchDebugBreakSlot(isolate(), pc, target);
   } else {
     BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
-    interpreter::Bytecode bytecode =
-        interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
-    interpreter::Bytecode debugbreak =
-        interpreter::Bytecodes::GetDebugBreak(bytecode);
-    bytecode_array->set(code_offset(),
+    BytecodePrefixHelper bytecode_prefix_helper(bytecode_array, code_offset());
+    interpreter::Bytecode debugbreak = interpreter::Bytecodes::GetDebugBreak(
+        bytecode_prefix_helper.bytecode(),
+        bytecode_prefix_helper.operand_scale());
+    bytecode_array->set(code_offset() + bytecode_prefix_helper.prefix_offset(),
                         interpreter::Bytecodes::ToByte(debugbreak));
   }
   DCHECK(IsDebugBreak());
@@ -428,7 +457,9 @@ void BreakLocation::ClearDebugBreak() {
   } else {
     BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
     BytecodeArray* original = debug_info_->original_bytecode_array();
-    bytecode_array->set(code_offset(), original->get(code_offset()));
+    BytecodePrefixHelper bytecode_prefix_helper(original, code_offset());
+    int offset = code_offset() + bytecode_prefix_helper.prefix_offset();
+    bytecode_array->set(offset, original->get(offset));
   }
   DCHECK(!IsDebugBreak());
 }
@@ -444,9 +475,8 @@ bool BreakLocation::IsDebugBreak() const {
     return DebugCodegen::DebugBreakSlotIsPatched(pc);
   } else {
     BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();
-    interpreter::Bytecode bytecode =
-        interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
-    return interpreter::Bytecodes::IsDebugBreak(bytecode);
+    BytecodePrefixHelper prefix_helper(bytecode_array, code_offset());
+    return interpreter::Bytecodes::IsDebugBreak(prefix_helper.bytecode());
   }
 }
 
@@ -1577,9 +1607,9 @@ Object* Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
     SharedFunctionInfo* shared = interpreted_frame->function()->shared();
     BytecodeArray* bytecode_array = shared->bytecode_array();
     int bytecode_offset = interpreted_frame->GetBytecodeOffset();
-    interpreter::Bytecode bytecode =
-        interpreter::Bytecodes::FromByte(bytecode_array->get(bytecode_offset));
-    return isolate_->interpreter()->GetBytecodeHandler(bytecode);
+    BytecodePrefixHelper prefix_helper(bytecode_array, bytecode_offset);
+    return isolate_->interpreter()->GetBytecodeHandler(
+        prefix_helper.bytecode(), prefix_helper.operand_scale());

[rmcilroy, 2016/03/16 11:55:54]

As discussed offline, I don't think this would work since the debug break is
after the prefix bytecode so we are returning a non-scaled bytecode handler
here, even when the operation should be scaled. The approach of setting the
breakpoint on the prefix bytecode mentioned above would solve this I think.

[oth, 2016/03/17 13:48:38]

Done.

   } else {
     after_break_target_ = NULL;
     if (!LiveEdit::SetAfterBreakTarget(this)) {