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

src/debug/debug-frames.cc

 // 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.
 
 #include "src/debug/debug-frames.h"
 
 #include "src/frames-inl.h"
 
 namespace v8 {
 namespace internal {
 
 FrameInspector::FrameInspector(JavaScriptFrame* frame,
                                int inlined_jsframe_index, Isolate* isolate)
     : frame_(frame), deoptimized_frame_(NULL), isolate_(isolate) {
   has_adapted_arguments_ = frame_->has_adapted_arguments();
   is_bottommost_ = inlined_jsframe_index == 0;
   is_optimized_ = frame_->is_optimized();
+  is_interpreted_ = frame_->is_interpreted();
   // Calculate the deoptimized frame.
   if (frame->is_optimized()) {
     // TODO(turbofan): Revisit once we support deoptimization.
     if (frame->LookupCode()->is_turbofanned() &&
         frame->function()->shared()->asm_function() &&
         !FLAG_turbo_asm_deoptimization) {
       is_optimized_ = false;
       return;
     }
 
@@ skipping 34 matching lines @@
     return isolate_->factory()->undefined_value();
   }
   return is_optimized_ ? deoptimized_frame_->GetExpression(index)
                        : handle(frame_->GetExpression(index), isolate_);
 }
 
 
 int FrameInspector::GetSourcePosition() {
   if (is_optimized_) {
     return deoptimized_frame_->GetSourcePosition();
+  } else if (is_interpreted_) {
+    InterpretedFrame* frame = reinterpret_cast<InterpretedFrame*>(frame_);
+    // TODO(yangguo): Get the bytecode array from the frame.

[Michael Starzinger, 2016/02/22 09:37:49]

Not sure about this TODO, why do we need to get the bytecode array from the
frame? The source position information should be the same for all versions that
could be active in the frame. That's one reason why I am so keen on preserving
the structure (i.e. same jump offsets, same bytecode offsets) of the bytecode
when we create the patched copy. I think everything we need to reason about the
bytecode should not depend on which version is active in the frame. WDYT? Am I
missing somehting here?

[Yang, 2016/02/22 12:48:43]

Absolutely correct. This is a stale TODO I forgot to remove.

+    BytecodeArray* bytecode_array =
+        frame->function()->shared()->bytecode_array();
+    return bytecode_array->SourcePosition(frame->GetBytecodeOffset());
   } else {
     Code* code = frame_->LookupCode();
     int offset = static_cast<int>(frame_->pc() - code->instruction_start());
     return code->SourcePosition(offset);
   }
 }
 
 
 bool FrameInspector::IsConstructor() {
   return is_optimized_ && !is_bottommost_
              ? deoptimized_frame_->HasConstructStub()
              : frame_->IsConstructor();
 }
 
 Handle<Object> FrameInspector::GetContext() {
   return is_optimized_ ? deoptimized_frame_->GetContext()
                        : handle(frame_->context(), isolate_);
 }
 
 
 // To inspect all the provided arguments the frame might need to be
 // replaced with the arguments frame.
 void FrameInspector::SetArgumentsFrame(JavaScriptFrame* frame) {
   DCHECK(has_adapted_arguments_);
   frame_ = frame;
   is_optimized_ = frame_->is_optimized();
+  is_interpreted_ = frame_->is_interpreted();
   DCHECK(!is_optimized_);
 }
 
 
 // Create a plain JSObject which materializes the local scope for the specified
 // frame.
 void FrameInspector::MaterializeStackLocals(Handle<JSObject> target,
                                             Handle<ScopeInfo> scope_info) {
   HandleScope scope(isolate_);
   // First fill all parameters.
@@ skipping 100 matching lines @@
       if (!frames[i].function()->shared()->IsSubjectToDebugging()) continue;
       if (++count == index) return i;
     }
   }
   return -1;
 }
 
 
 }  // namespace internal
 }  // namespace v8