[interpreter] Add support for scalable operands.

src/debug/debug.cc

 // Copyright 2012 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/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 199 matching lines @@
     DCHECK_EQ(CALLS_AND_RETURNS, break_locator_type_);
     if (type == DEBUG_BREAK_SLOT_AT_CALL) break;
     if (type == DEBUG_BREAK_SLOT_AT_RETURN) {
       DCHECK_EQ(ReturnPosition(), position_);
       DCHECK_EQ(ReturnPosition(), statement_position_);
       break;
     }
   }
 }
 
+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;
   } else if (bytecode == interpreter::Bytecode::kReturn) {
     return DEBUG_BREAK_SLOT_AT_RETURN;
   } else if (interpreter::Bytecodes::IsCallOrNew(bytecode)) {
     return DEBUG_BREAK_SLOT_AT_CALL;
   } else if (source_position_iterator_.is_statement()) {
     return DEBUG_BREAK_SLOT;
   } else {
@@ skipping 162 matching lines @@
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
     DCHECK(code->kind() == Code::FUNCTION);
     Builtins* builtins = isolate()->builtins();
     Handle<Code> target = IsReturn() ? builtins->Return_DebugBreak()
                                      : builtins->Slot_DebugBreak();
     Address pc = code->instruction_start() + code_offset();
     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());
 }
 
 
 void BreakLocation::ClearDebugBreak() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
   DCHECK(IsDebugBreakSlot());
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
     DCHECK(code->kind() == Code::FUNCTION);
     Address pc = code->instruction_start() + code_offset();
     DebugCodegen::ClearDebugBreakSlot(isolate(), pc);
   } 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());
 }
 
 
 bool BreakLocation::IsDebugBreak() const {
   if (IsDebuggerStatement()) return false;
   DCHECK(IsDebugBreakSlot());
   if (abstract_code()->IsCode()) {
     Code* code = abstract_code()->GetCode();
     DCHECK(code->kind() == Code::FUNCTION);
     Address pc = code->instruction_start() + code_offset();
     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());
   }
 }
 
 
 Handle<Object> BreakLocation::BreakPointObjects() const {
   return debug_info_->GetBreakPointObjects(code_offset_);
 }
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
   uint32_t mask = 1 << feature;
@@ skipping 1110 matching lines @@
 }
 
 Object* Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
   if (frame->is_interpreted()) {
     // Find the handler from the original bytecode array.
     InterpretedFrame* interpreted_frame =
         reinterpret_cast<InterpretedFrame*>(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)) {
       // Continue just after the slot.
       after_break_target_ = frame->pc();
     }
     return isolate_->heap()->undefined_value();
   }
 }
 
@@ skipping 1027 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8