[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 204 matching lines @@
       break;
     }
   }
 }
 
 BreakLocation::DebugBreakType
 BreakLocation::BytecodeArrayIterator::GetDebugBreakType() {
   BytecodeArray* bytecode_array = debug_info_->original_bytecode_array();
   interpreter::Bytecode bytecode =
       interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));
+  if (interpreter::Bytecodes::GetPrefixBytecodeScale(bytecode) > 1) {
+    bytecode = interpreter::Bytecodes::FromByte(
+        bytecode_array->get(code_offset() + 1));
+  }
 
   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 179 matching lines @@
     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()));
+    int prefix_offset = 0;
+    int operand_scale =
+        interpreter::Bytecodes::GetPrefixBytecodeScale(bytecode);
+    if (operand_scale > 1) {
+      prefix_offset = 1;
+      bytecode = interpreter::Bytecodes::FromByte(
+          bytecode_array->get(code_offset() + prefix_offset));
+    }
     interpreter::Bytecode debugbreak =
-        interpreter::Bytecodes::GetDebugBreak(bytecode);
-    bytecode_array->set(code_offset(),
+        interpreter::Bytecodes::GetDebugBreak(bytecode, operand_scale);
+    bytecode_array->set(code_offset() + 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()));
+    int operand_scale = interpreter::Bytecodes::GetPrefixBytecodeScale(
+        interpreter::Bytecodes::FromByte(original->get(code_offset())));
+    int prefix_offset = operand_scale > 1 ? 1 : 0;
+    bytecode_array->set(code_offset() + prefix_offset,
+                        original->get(code_offset() + prefix_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()));
+    if (interpreter::Bytecodes::GetPrefixBytecodeScale(bytecode) > 1) {
+      bytecode = interpreter::Bytecodes::FromByte(
+          bytecode_array->get(code_offset() + 1));
+    }
     return interpreter::Bytecodes::IsDebugBreak(bytecode);
   }
 }
 
 
 Handle<Object> BreakLocation::BreakPointObjects() const {
   return debug_info_->GetBreakPointObjects(code_offset_);
 }
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
@@ skipping 1112 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);
+    int operand_scale =
+        interpreter::Bytecodes::GetPrefixBytecodeScale(bytecode);
+    if (operand_scale > 1) {
+      interpreter::Bytecodes::FromByte(
+          bytecode_array->get(bytecode_offset + 1));
+    }
+    return isolate_->interpreter()->GetBytecodeHandler(bytecode, operand_scale);
   } 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 1066 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8