[debugger] tuned StepNext and StepOut at return position

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 <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 368 matching lines @@
   isolate_->counters()->debug_feature_usage()->AddSample(feature);
   bitfield_ |= mask;
 }
 
 
 // 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_frame_id_ = StackFrame::NO_ID;
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = kNoSourcePosition;
   thread_local_.last_frame_count_ = -1;
   thread_local_.target_frame_count_ = -1;
   thread_local_.return_value_ = Smi::kZero;
   thread_local_.async_task_count_ = 0;
   clear_suspended_generator();
   thread_local_.restart_fp_ = nullptr;
   base::NoBarrier_Store(&thread_local_.current_debug_scope_,
                         static_cast<base::AtomicWord>(0));
@@ skipping 470 matching lines @@
     if (CheckBreakPoint(break_point_object)) {
       break_points_hit->set(break_points_hit_count++, *break_point_object);
     }
   }
   if (break_points_hit_count == 0) return {};
   break_points_hit->Shrink(break_points_hit_count);
   return break_points_hit;
 }
 
 void Debug::PrepareStepIn(Handle<JSFunction> function) {
-  CHECK(last_step_action() >= StepIn);
+  CHECK(last_step_action() != StepNone);
   if (ignore_events()) return;
   if (in_debug_scope()) return;
   if (break_disabled()) return;
+  if (last_step_action() == StepIn) {
+    FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared(), isolate_));
+  }
+  if (thread_local_.last_step_frame_id_ == StackFrame::NO_ID) return;
+  if (last_step_action() == StepOut || last_step_action() == StepNext) {
+    int count = 0;
+    for (StackTraceFrameIterator it(isolate_); !it.done(); it.Advance()) {
+      if (it.frame()->id() == thread_local_.last_step_frame_id_) return;
+      ++count;
+    }
+    thread_local_.target_frame_count_ = count + 1;
+  }
   FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared(), isolate_));
 }
 
 void Debug::PrepareStepInSuspendedGenerator() {
   CHECK(has_suspended_generator());
   if (ignore_events()) return;
   if (in_debug_scope()) return;
   if (break_disabled()) return;
   thread_local_.last_step_action_ = StepIn;
   UpdateHookOnFunctionCall();
@@ skipping 90 matching lines @@
   if (frame_id == StackFrame::NO_ID) return;
 
   feature_tracker()->Track(DebugFeatureTracker::kStepping);
 
   thread_local_.last_step_action_ = step_action;
   UpdateHookOnFunctionCall();
 
   StackTraceFrameIterator frames_it(isolate_, frame_id);
   StandardFrame* frame = frames_it.frame();
 
+  if (step_action == StepOut || step_action == StepNext) {
+    thread_local_.last_step_frame_id_ = frame->id();
+  }
+
   // Handle stepping in wasm functions via the wasm interpreter.
   if (frame->is_wasm()) {
     // If the top frame is compiled, we cannot step.
     if (frame->is_wasm_compiled()) return;
     WasmInterpreterEntryFrame* wasm_frame =
         WasmInterpreterEntryFrame::cast(frame);
     wasm_frame->wasm_instance()->debug_info()->PrepareStep(step_action);
     return;
   }
 
@@ skipping 114 matching lines @@
   }
   return locations;
 }
 
 void Debug::ClearStepping() {
   // Clear the various stepping setup.
   ClearOneShot();
 
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = kNoSourcePosition;
+  thread_local_.last_step_frame_id_ = StackFrame::NO_ID;
   thread_local_.last_frame_count_ = -1;
   thread_local_.target_frame_count_ = -1;
   UpdateHookOnFunctionCall();
 }
 
 
 // Clears all the one-shot break points that are currently set. Normally this
 // function is called each time a break point is hit as one shot break points
 // are used to support stepping.
 void Debug::ClearOneShot() {
@@ skipping 965 matching lines @@
   } else if (is_loaded()) {
     isolate_->compilation_cache()->Enable();
     Unload();
   }
   is_active_ = is_active;
   isolate_->DebugStateUpdated();
 }
 
 void Debug::UpdateHookOnFunctionCall() {
   STATIC_ASSERT(LastStepAction == StepIn);
-  hook_on_function_call_ = thread_local_.last_step_action_ == StepIn ||
+  hook_on_function_call_ = thread_local_.last_step_action_ != StepNone ||
                            isolate_->needs_side_effect_check();
 }
 
 MaybeHandle<Object> Debug::Call(Handle<Object> fun, Handle<Object> data) {
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return isolate_->factory()->undefined_value();
 
   // Create the execution state.
   Handle<Object> exec_state;
   if (!MakeExecutionState().ToHandle(&exec_state)) {
@@ skipping 334 matching lines @@
     isolate_->Throw(*isolate_->factory()->NewEvalError(
         MessageTemplate::kNoSideEffectDebugEvaluate));
   }
   isolate_->set_needs_side_effect_check(old_needs_side_effect_check_);
   isolate_->debug()->UpdateHookOnFunctionCall();
   isolate_->debug()->side_effect_check_failed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8