Debugger: use debug break slots to break at function exit.

src/runtime/runtime-debug.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/arguments.h"
 #include "src/compiler.h"
 #include "src/debug.h"
@@ skipping 1372 matching lines @@
     // Catch the case when the debugger stops in an internal function.
     Handle<SharedFunctionInfo> shared_info(function_->shared());
     Handle<ScopeInfo> scope_info(shared_info->scope_info());
     if (shared_info->script() == isolate->heap()->undefined_value()) {
       while (context_->closure() == *function_) {
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
       return;
     }
 
-    // Get the debug info (create it if it does not exist).
-    if (!isolate->debug()->EnsureDebugInfo(shared_info, function_)) {
-      // Return if ensuring debug info failed.
-      return;
-    }
-
     // Currently it takes too much time to find nested scopes due to script
     // parsing. Sometimes we want to run the ScopeIterator as fast as possible
     // (for example, while collecting async call stacks on every
     // addEventListener call), even if we drop some nested scopes.
     // Later we may optimize getting the nested scopes (cache the result?)
     // and include nested scopes into the "fast" iteration case as well.
-    if (!ignore_nested_scopes) {
+    if (!ignore_nested_scopes && !shared_info->debug_info()->IsUndefined()) {

[ulan, 2015/07/14 09:12:45]

What happens if there is no debug info?

[Yang, 2015/07/14 12:00:57]

We can only ever end up here from a return statement if we set a break point at
the return statement, which requires a debug info to exist. I updated the
comment to better reflect this.

       Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared_info);
 
       // PC points to the instruction after the current one, possibly a break
       // location as well. So the "- 1" to exclude it from the search.
       Address call_pc = frame->pc() - 1;
 
       // Find the break point where execution has stopped.
       BreakLocation location =
           BreakLocation::FromAddress(debug_info, ALL_BREAK_LOCATIONS, call_pc);
 
-      // Within the return sequence at the moment it is not possible to
-      // get a source position which is consistent with the current scope chain.
-      // Thus all nested with, catch and block contexts are skipped and we only
-      // provide the function scope.
-      ignore_nested_scopes = location.IsExit();
+      // With break points we can end up breaking at a return sequence, where
+      // at the moment it is not possible to get a source position which is
+      // consistent with the current scope chain. Thus all nested with, catch
+      // and block contexts are skipped and we only provide the function scope.
+      ignore_nested_scopes = location.IsReturn();
     }
 
     if (ignore_nested_scopes) {
       if (scope_info->HasContext()) {
         context_ = Handle<Context>(context_->declaration_context(), isolate_);
       } else {
         while (context_->closure() == *function_) {
           context_ = Handle<Context>(context_->previous(), isolate_);
         }
       }
@@ skipping 1790 matching lines @@
   return *isolate->factory()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8