[debugger] simplify debug stepping.

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 459 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>();
   clear_suspended_generator();
   // TODO(isolates): frames_are_dropped_?
   base::NoBarrier_Store(&thread_local_.current_debug_scope_,
                         static_cast<base::AtomicWord>(0));
 }
 
 
 char* Debug::ArchiveDebug(char* storage) {
   // Simply reset state. Don't archive anything.
@@ skipping 437 matching lines @@
   } else {
     return break_on_exception_;
   }
 }
 
 
 void Debug::PrepareStepIn(Handle<JSFunction> function) {
   if (!is_active()) return;
   if (last_step_action() < StepIn) return;
   if (in_debug_scope()) return;
-  if (thread_local_.step_in_enabled_) {
-    FloodWithOneShot(function);
-  }
+  FloodWithOneShot(function);
 }
 
 void Debug::PrepareStepInSuspendedGenerator() {
   if (!is_active()) return;
   if (in_debug_scope()) return;
   DCHECK(has_suspended_generator());
   thread_local_.last_step_action_ = StepIn;
-  thread_local_.step_in_enabled_ = true;
   Handle<JSFunction> function(
       JSGeneratorObject::cast(thread_local_.suspended_generator_)->function());
   FloodWithOneShot(function);
   clear_suspended_generator();
 }
 
 void Debug::PrepareStepOnThrow() {
   if (!is_active()) return;
   if (last_step_action() == StepNone) return;
   if (in_debug_scope()) return;
@@ skipping 39 matching lines @@
   // debug frame is not present.
   StackFrame::Id frame_id = break_frame_id();
   // If there is no JavaScript stack don't do anything.
   if (frame_id == StackFrame::NO_ID) return;
 
   JavaScriptFrameIterator frames_it(isolate_, frame_id);
   JavaScriptFrame* frame = frames_it.frame();
 
   feature_tracker()->Track(DebugFeatureTracker::kStepping);
 
-  // Remember this step action and count.
   thread_local_.last_step_action_ = step_action;
-  STATIC_ASSERT(StepFrame > StepIn);
-  thread_local_.step_in_enabled_ = (step_action >= StepIn);
 
   // If the function on the top frame is unresolved perform step out. This will
   // be the case when calling unknown function and having the debugger stopped
   // in an unhandled exception.
   if (!frame->function()->IsJSFunction()) {
     // Step out: Find the calling JavaScript frame and flood it with
     // breakpoints.
     frames_it.Advance();
     // Fill the function to return to with one-shot break points.
     JSFunction* function = frames_it.frame()->function();
@@ skipping 14 matching lines @@
   // Refresh frame summary if the code has been recompiled for debugging.
   if (AbstractCode::cast(shared->code()) != *summary.abstract_code()) {
     summary = FrameSummary::GetFirst(frame);
   }
 
   int call_offset =
       CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
   BreakLocation location =
       BreakLocation::FromCodeOffset(debug_info, call_offset);
 
-  // Any step at a return is a step-out.
-  if (location.IsReturn()) step_action = StepOut;
-  // A step-next at a tail call is a step-out.
-  if (location.IsTailCall() && step_action == StepNext) step_action = StepOut;
+  // Any step at a return or a step-next at a tail call is a step-out.
+  if (location.IsReturn() ||
+      (location.IsTailCall() && thread_local_.last_step_action_ == StepNext)) {
+    thread_local_.last_step_action_ = StepOut;
+  }
 
   thread_local_.last_statement_position_ =
       debug_info->abstract_code()->SourceStatementPosition(
           summary.code_offset());
   thread_local_.last_fp_ = frame->UnpaddedFP();
   // No longer perform the current async step.
   clear_suspended_generator();
 
-  switch (step_action) {
+  switch (thread_local_.last_step_action_) {
     case StepNone:
       UNREACHABLE();
       break;
     case StepOut:
       // Advance to caller frame.
       frames_it.Advance();
       // Skip native and extension functions on the stack.
       while (!frames_it.done() &&
              !frames_it.frame()->function()->shared()->IsSubjectToDebugging()) {
         // Builtin functions are not subject to stepping, but need to be
         // deoptimized to include checks for step-in at call sites.
         Deoptimizer::DeoptimizeFunction(frames_it.frame()->function());
         frames_it.Advance();
       }
-      if (frames_it.done()) {
-        // Stepping out to the embedder. Disable step-in to avoid stepping into
-        // the next (unrelated) call that the embedder makes.
-        thread_local_.step_in_enabled_ = false;
-      } else {
+      if (!frames_it.done()) {
         // Fill the caller function to return to with one-shot break points.
         Handle<JSFunction> caller_function(frames_it.frame()->function());
         FloodWithOneShot(caller_function);
         thread_local_.target_fp_ = frames_it.frame()->UnpaddedFP();
       }
       // Clear last position info. For stepping out it does not matter.
       thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
       thread_local_.last_fp_ = 0;
       break;
     case StepNext:
@@ skipping 47 matching lines @@
   }
   return locations;
 }
 
 
 void Debug::ClearStepping() {
   // Clear the various stepping setup.
   ClearOneShot();
 
   thread_local_.last_step_action_ = StepNone;
-  thread_local_.step_in_enabled_ = false;
   thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
   thread_local_.last_fp_ = 0;
   thread_local_.target_fp_ = 0;
 }
 
 
 // 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() {
   // The current implementation just runs through all the breakpoints. When the
   // last break point for a function is removed that function is automatically
   // removed from the list.
   for (DebugInfoListNode* node = debug_info_list_; node != NULL;
        node = node->next()) {
     for (base::SmartPointer<BreakLocation::Iterator> it(
              BreakLocation::GetIterator(node->debug_info()));
          !it->Done(); it->Next()) {
       it->GetBreakLocation().ClearOneShot();
     }
   }
 }
 
 
-void Debug::EnableStepIn() {
-  STATIC_ASSERT(StepFrame > StepIn);
-  thread_local_.step_in_enabled_ = (last_step_action() >= StepIn);
-}
-
-
 bool MatchingCodeTargets(Code* target1, Code* target2) {
   if (target1 == target2) return true;
   if (target1->kind() != target2->kind()) return false;
   return target1->is_handler() || target1->is_inline_cache_stub();
 }
 
 
 // Count the number of calls before the current frame PC to find the
 // corresponding PC in the newly recompiled code.
 static Address ComputeNewPcForRedirect(Code* new_code, Code* old_code,
@@ skipping 1424 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8