[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 1561 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);
+    return isolate_->interpreter()->GetBytecodeHandler(
+        bytecode, interpreter::OperandScale::kSingle);

[Yang, 2016/03/21 09:36:13]

Is the operand scale guaranteed to be single here?

What we do here is to load the original bytecode from the original bytecode
array to continue execution as if the original bytecode was there. If the
original bytecode had a different operand scale, this would be wrong?

[oth, 2016/03/21 09:52:14]

If the bytecode has a scaling prefix, then the scaling prefix has the debug
break on it. There are special debug versions of the prefix bytecodes
(DEBUG_BREAK_PREFIX_BYTECODE_LIST). Otherwise, it's the usual mechanism.

   } 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