Make return statements single steppable

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 374 matching lines @@
     ASSERT(!code_.is_optimized());
     context_level_ = 0;
     intptr_t pc_desc_idx = PcDescIndex();
     // TODO(hausner): What to do if there is no descriptor entry
     // for the code position of the frame? For now say we are at context
     // level 0.
     if (pc_desc_idx < 0) {
       return context_level_;
     }
     ASSERT(!pc_desc_.IsNull());
-    if (pc_desc_.DescriptorKind(pc_desc_idx) == PcDescriptors::kReturn) {
-      // Special case: the context chain has already been deallocated.
-      // The context level is 0.
-      return context_level_;
-    }
     intptr_t innermost_begin_pos = 0;
     intptr_t activation_token_pos = TokenPos();
     ASSERT(activation_token_pos >= 0);
     GetVarDescriptors();
     intptr_t var_desc_len = var_descriptors_.Length();
     for (intptr_t cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
       RawLocalVarDescriptors::VarInfo var_info;
       var_descriptors_.GetInfo(cur_idx, &var_info);
       if ((var_info.kind == RawLocalVarDescriptors::kContextLevel) &&
           (var_info.begin_pos <= activation_token_pos) &&
@@ skipping 368 matching lines @@
     case PcDescriptors::kUnoptStaticCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       saved_bytes_.target_address_ =
           CodePatcher::GetStaticCallTargetAt(pc_, code);
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      StubCode::BreakpointStaticEntryPoint());
       break;
     }
     case PcDescriptors::kRuntimeCall:
-    case PcDescriptors::kClosureCall: {
+    case PcDescriptors::kClosureCall:
+    case PcDescriptors::kReturn: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       saved_bytes_.target_address_ =
           CodePatcher::GetStaticCallTargetAt(pc_, code);
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      StubCode::BreakpointRuntimeEntryPoint());
       break;
     }
-    case PcDescriptors::kReturn:
-      PatchFunctionReturn();
-      break;
     default:
       UNREACHABLE();
   }
   is_enabled_ = true;
 }
 
 
 void CodeBreakpoint::RestoreCode() {
   ASSERT(is_enabled_);
   switch (breakpoint_kind_) {
     case PcDescriptors::kIcCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchInstanceCallAt(pc_, code,
                                        saved_bytes_.target_address_);
       break;
     }
     case PcDescriptors::kUnoptStaticCall:
     case PcDescriptors::kClosureCall:
-    case PcDescriptors::kRuntimeCall: {
+    case PcDescriptors::kRuntimeCall:
+    case PcDescriptors::kReturn: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      saved_bytes_.target_address_);
       break;
     }
-    case PcDescriptors::kReturn:
-      RestoreFunctionReturn();
-      break;
     default:
       UNREACHABLE();
   }
   is_enabled_ = false;
 }
 
 
 void CodeBreakpoint::Enable() {
   if (!is_enabled_) {
     PatchCode();
@@ skipping 1167 matching lines @@
   }
 
   if (report_bp && (event_handler_ != NULL)) {
     ASSERT(stack_trace_ == NULL);
     stack_trace_ = stack_trace;
     SignalPausedEvent(top_frame, bpt->src_bpt_);
     stack_trace_ = NULL;
   }
 
   Function& func_to_instrument = Function::Handle();
+  if ((resume_action_ == kStepOver) &&
+      (bpt->breakpoint_kind_ == PcDescriptors::kReturn)) {
+    resume_action_ = kStepOut;
+  }
   if (resume_action_ == kStepOver) {
-    if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
-      // Step over return is converted into a single step so we break at
-      // the caller.
-      SetSingleStep();
-    } else {
-      func_to_instrument = bpt->function();
-    }
+    ASSERT(bpt->breakpoint_kind_ != PcDescriptors::kReturn);
+    func_to_instrument = bpt->function();
   } else if (resume_action_ == kStepOut) {
     if (stack_trace->Length() > 1) {
       ActivationFrame* caller_frame = stack_trace->FrameAt(1);
       func_to_instrument = caller_frame->function().raw();
     }
   } else {
     ASSERT((resume_action_ == kContinue) || (resume_action_ == kSingleStep));
     // Nothing to do here. Any potential instrumentation will be removed
     // below. Single stepping is handled by the single step callback.
   }
@@ skipping 247 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart