[Interpreter] Adds support to fetch return value on break at return.

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 456 matching lines @@
 // Threading support.
 void Debug::ThreadInit() {
   thread_local_.break_count_ = 0;
   thread_local_.break_id_ = 0;
   thread_local_.break_frame_id_ = StackFrame::NO_ID;
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
   thread_local_.last_fp_ = 0;
   thread_local_.target_fp_ = 0;
   thread_local_.step_in_enabled_ = false;
+  thread_local_.return_value_ = Handle<Object>();
   // TODO(isolates): frames_are_dropped_?
   base::NoBarrier_Store(&thread_local_.current_debug_scope_,
                         static_cast<base::AtomicWord>(0));
 }
 
 
 char* Debug::ArchiveDebug(char* storage) {
   char* to = storage;
   MemCopy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));
   ThreadInit();
@@ skipping 69 matching lines @@
   if (!is_loaded()) return;
 
   // Clear debugger context global handle.
   GlobalHandles::Destroy(Handle<Object>::cast(debug_context_).location());
   debug_context_ = Handle<Context>();
 }
 
 
 void Debug::Break(Arguments args, JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
-  DCHECK(args.length() == 0);
+  DCHECK(args.length() == 1);
+
+  // args[0] contains the return value (eax/rax/r0/accumulator) if we break
+  // on return.
+  thread_local_.return_value_ = args.at<Object>(0);

[Yang, 2016/03/22 12:22:57]

Please introduce a method to set and retrieve the return value, and use it in
Runtime_DebugBreak.

 
   // Initialize LiveEdit.
   LiveEdit::InitializeThreadLocal(this);
 
   // Just continue if breaks are disabled or debugger cannot be loaded.
   if (break_disabled()) return;
 
   // Enter the debugger.
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
@@ skipping 1002 matching lines @@
     int bytecode_offset = interpreted_frame->GetBytecodeOffset();
     interpreter::Bytecode bytecode =
         interpreter::Bytecodes::FromByte(bytecode_array->get(bytecode_offset));
     return isolate_->interpreter()->GetBytecodeHandler(bytecode);
   } else {
     after_break_target_ = NULL;
     if (!LiveEdit::SetAfterBreakTarget(this)) {
       // Continue just after the slot.
       after_break_target_ = frame->pc();
     }
-    return isolate_->heap()->undefined_value();
+    return *thread_local_.return_value_;

[mythria, 2016/03/21 16:24:29]

Returns the actual return value to avoid pushing and popping rax/eax in the
DebugBreakStub.

[Yang, 2016/03/22 12:22:58]

I forgot about this part. For the interpreter, the return value of this function
is the after-break-target. For FCG, we store it in a memory location.

Let's split Runtime_DebugBreak into two runtime functions. One to cater to FCG.
It would set the return value before calling Debug::Break, and return the return
value. The other caters to Ignition, it sets the return value before calling
Debug::Break, and returns the debug break bytecode handler.

Let's also move the code in SetAfterBreakTarget for the interpreter case into
the runtime function and only call SetAfterBreakTarget for FCG.

[mythria, 2016/03/22 15:11:44]

Done.

   }
 }
 
 
 bool Debug::IsBreakAtReturn(JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
 
   // Get the executing function in which the debug break occurred.
   Handle<JSFunction> function(JSFunction::cast(frame->function()));
   Handle<SharedFunctionInfo> shared(function->shared());
@@ skipping 720 matching lines @@
 DebugScope::DebugScope(Debug* debug)
     : debug_(debug),
       prev_(debug->debugger_entry()),
       save_(debug_->isolate_),
       no_termination_exceptons_(debug_->isolate_,
                                 StackGuard::TERMINATE_EXECUTION) {
   // Link recursive debugger entry.
   base::NoBarrier_Store(&debug_->thread_local_.current_debug_scope_,
                         reinterpret_cast<base::AtomicWord>(this));
 
-  // Store the previous break id and frame id.
+  // Store the previous break id, frame id and return value.
   break_id_ = debug_->break_id();
   break_frame_id_ = debug_->break_frame_id();
+  return_value_ = debug_->get_return_value();
 
   // Create the new break info. If there is no JavaScript frames there is no
   // break frame id.
   JavaScriptFrameIterator it(isolate());
   bool has_js_frames = !it.done();
   debug_->thread_local_.break_frame_id_ = has_js_frames ? it.frame()->id()
                                                         : StackFrame::NO_ID;
   debug_->SetNextBreakId();
 
   debug_->UpdateState();
@@ skipping 17 matching lines @@
     if (debug_->has_commands()) isolate()->stack_guard()->RequestDebugCommand();
   }
 
   // Leaving this debugger entry.
   base::NoBarrier_Store(&debug_->thread_local_.current_debug_scope_,
                         reinterpret_cast<base::AtomicWord>(prev_));
 
   // Restore to the previous break state.
   debug_->thread_local_.break_frame_id_ = break_frame_id_;
   debug_->thread_local_.break_id_ = break_id_;
+  debug_->thread_local_.return_value_ = return_value_;
 
   debug_->UpdateState();
 }
 
 
 MessageImpl MessageImpl::NewEvent(DebugEvent event,
                                   bool running,
                                   Handle<JSObject> exec_state,
                                   Handle<JSObject> event_data) {
   MessageImpl message(true, event, running,
@@ skipping 240 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8