[Lldb-commits] [lldb] r290197 - Rollback my commit r290168 to fix linux tests failure. I'll be back!

Boris Ulasevich via lldb-commits lldb-commits at lists.llvm.org
Tue Dec 20 12:08:14 PST 2016


Author: bulasevich
Date: Tue Dec 20 14:00:58 2016
New Revision: 290197

URL: http://llvm.org/viewvc/llvm-project?rev=290197&view=rev
Log:
Rollback my commit r290168 to fix linux tests failure. I'll be back!

Removed:
    lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/
Modified:
    lldb/trunk/include/lldb/Target/Thread.h
    lldb/trunk/include/lldb/Target/ThreadPlan.h
    lldb/trunk/source/Target/StopInfo.cpp
    lldb/trunk/source/Target/Thread.cpp
    lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp
    lldb/trunk/source/Target/ThreadPlanStepRange.cpp

Modified: lldb/trunk/include/lldb/Target/Thread.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Thread.h?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Thread.h (original)
+++ lldb/trunk/include/lldb/Target/Thread.h Tue Dec 20 14:00:58 2016
@@ -1029,15 +1029,6 @@ public:
   bool WasThreadPlanDiscarded(ThreadPlan *plan);
 
   //------------------------------------------------------------------
-  /// Check if we have completed plan to override breakpoint stop reason
-  ///
-  /// @return
-  ///     Returns true if completed plan stack is not empty
-  ///     false otherwise.
-  //------------------------------------------------------------------
-  bool CompletedPlanOverridesBreakpoint();
-                   
-  //------------------------------------------------------------------
   /// Queues a generic thread plan.
   ///
   /// @param[in] plan_sp
@@ -1222,8 +1213,6 @@ public:
 
   void SetStopInfo(const lldb::StopInfoSP &stop_info_sp);
 
-  void ResetStopInfo();
-
   void SetShouldReportStop(Vote vote);
 
   //----------------------------------------------------------------------

Modified: lldb/trunk/include/lldb/Target/ThreadPlan.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlan.h?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlan.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlan.h Tue Dec 20 14:00:58 2016
@@ -170,7 +170,7 @@ namespace lldb_private {
 //  event it didn't directly handle
 //  it can designate itself a "Master" plan by responding true to IsMasterPlan,
 //  and then if it wants not to be
-//  discarded, it can return false to OkayToDiscard, and it and all its dependent
+//  discarded, it can return true to OkayToDiscard, and it and all its dependent
 //  plans will be preserved when
 //  we resume execution.
 //
@@ -207,7 +207,7 @@ namespace lldb_private {
 //
 //  If a plan says responds "true" to ShouldStop, then it is asked if it's job
 //  is complete by calling
-//  MischiefManaged.  If that returns true, the plan is popped from the plan
+//  MischiefManaged.  If that returns true, the thread is popped from the plan
 //  stack and added to the
 //  Completed Plan Stack.  Then the next plan in the stack is asked if it
 //  ShouldStop, and  it returns "true",

Modified: lldb/trunk/source/Target/StopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/StopInfo.cpp?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/source/Target/StopInfo.cpp (original)
+++ lldb/trunk/source/Target/StopInfo.cpp Tue Dec 20 14:00:58 2016
@@ -269,7 +269,6 @@ protected:
     if (!m_should_perform_action)
       return;
     m_should_perform_action = false;
-    bool internal_breakpoint = true;
 
     ThreadSP thread_sp(m_thread_wp.lock());
 
@@ -496,9 +495,6 @@ protected:
             if (callback_says_stop)
               m_should_stop = true;
 
-            if (m_should_stop && !bp_loc_sp->GetBreakpoint().IsInternal())
-              internal_breakpoint = false;
-                  
             // If we are going to stop for this breakpoint, then remove the
             // breakpoint.
             if (callback_says_stop && bp_loc_sp &&
@@ -530,20 +526,6 @@ protected:
               "Process::%s could not find breakpoint site id: %" PRId64 "...",
               __FUNCTION__, m_value);
       }
-
-      if ((m_should_stop == false || internal_breakpoint)
-          && thread_sp->CompletedPlanOverridesBreakpoint()) {
-        
-        // Override should_stop decision when we have
-        // completed step plan additionally to the breakpoint
-        m_should_stop = true;
-        
-        // Here we clean the preset stop info so the next
-        // GetStopInfo call will find the appropriate stop info,
-        // which should be the stop info related to the completed plan
-        thread_sp->ResetStopInfo();
-      }
-
       if (log)
         log->Printf("Process::%s returning from action with m_should_stop: %d.",
                     __FUNCTION__, m_should_stop);

Modified: lldb/trunk/source/Target/Thread.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Thread.cpp?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/source/Target/Thread.cpp (original)
+++ lldb/trunk/source/Target/Thread.cpp Tue Dec 20 14:00:58 2016
@@ -380,32 +380,24 @@ lldb::StopInfoSP Thread::GetStopInfo() {
   if (m_destroy_called)
     return m_stop_info_sp;
 
-  ThreadPlanSP completed_plan_sp(GetCompletedPlan());
+  ThreadPlanSP plan_sp(GetCompletedPlan());
   ProcessSP process_sp(GetProcess());
   const uint32_t stop_id = process_sp ? process_sp->GetStopID() : UINT32_MAX;
-
-  // Here we select the stop info according to priorirty:
-  // - m_stop_info_sp (if not trace) - preset value
-  // - completed plan stop info - new value with plan from completed plan stack
-  // - m_stop_info_sp (trace stop reason is OK now)
-  // - ask GetPrivateStopInfo to set stop info
-
-  bool have_valid_stop_info = m_stop_info_sp &&
-      m_stop_info_sp ->IsValid() &&
-      m_stop_info_stop_id == stop_id;
-  bool have_valid_completed_plan = completed_plan_sp && completed_plan_sp->PlanSucceeded();
-  bool plan_overrides_trace =
-    have_valid_stop_info && have_valid_completed_plan
-    && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
-    
-  if (have_valid_stop_info && !plan_overrides_trace) {
-    return m_stop_info_sp;
-  } else if (have_valid_completed_plan) {
-    return StopInfo::CreateStopReasonWithPlan(
-        completed_plan_sp, GetReturnValueObject(), GetExpressionVariable());
+  if (plan_sp && plan_sp->PlanSucceeded()) {
+    return StopInfo::CreateStopReasonWithPlan(plan_sp, GetReturnValueObject(),
+                                              GetExpressionVariable());
   } else {
-    GetPrivateStopInfo();
-    return m_stop_info_sp;
+    if ((m_stop_info_stop_id == stop_id) || // Stop info is valid, just return
+                                            // what we have (even if empty)
+        (m_stop_info_sp &&
+         m_stop_info_sp
+             ->IsValid())) // Stop info is valid, just return what we have
+    {
+      return m_stop_info_sp;
+    } else {
+      GetPrivateStopInfo();
+      return m_stop_info_sp;
+    }
   }
 }
 
@@ -467,12 +459,6 @@ bool Thread::StopInfoIsUpToDate() const
                  // date...
 }
 
-void Thread::ResetStopInfo() {
-  if (m_stop_info_sp) {
-    m_stop_info_sp.reset();
-  }
-}
-
 void Thread::SetStopInfo(const lldb::StopInfoSP &stop_info_sp) {
   m_stop_info_sp = stop_info_sp;
   if (m_stop_info_sp) {
@@ -909,9 +895,6 @@ bool Thread::ShouldStop(Event *event_ptr
 
   if (should_stop) {
     ThreadPlan *plan_ptr = GetCurrentPlan();
-
-    // Discard the stale plans and all plans below them in the stack,
-    // plus move the completed plans to the completed plan stack
     while (!PlanIsBasePlan(plan_ptr)) {
       bool stale = plan_ptr->IsPlanStale();
       ThreadPlan *examined_plan = plan_ptr;
@@ -922,15 +905,7 @@ bool Thread::ShouldStop(Event *event_ptr
           log->Printf(
               "Plan %s being discarded in cleanup, it says it is already done.",
               examined_plan->GetName());
-        while (GetCurrentPlan() != examined_plan) {
-          DiscardPlan();
-        }
-        if (examined_plan->IsPlanComplete()) {
-          // plan is complete but does not explain the stop (example: step to a line
-          // with breakpoint), let us move the plan to completed_plan_stack anyway
-          PopPlan();
-        } else
-          DiscardPlan();
+        DiscardThreadPlansUpToPlan(examined_plan);
       }
     }
   }
@@ -1158,10 +1133,6 @@ bool Thread::WasThreadPlanDiscarded(Thre
   return false;
 }
 
-bool Thread::CompletedPlanOverridesBreakpoint() {
-  return (!m_completed_plan_stack.empty()) ;
-}
-
 ThreadPlan *Thread::GetPreviousPlan(ThreadPlan *current_plan) {
   if (current_plan == nullptr)
     return nullptr;

Modified: lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp Tue Dec 20 14:00:58 2016
@@ -94,15 +94,6 @@ bool ThreadPlanStepInstruction::IsPlanSt
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
   if (cur_frame_id == m_stack_id) {
-    // Set plan Complete when we reach next instruction
-    uint64_t pc = m_thread.GetRegisterContext()->GetPC(0);
-    uint32_t max_opcode_size = m_thread.CalculateTarget()
-        ->GetArchitecture().GetMaximumOpcodeByteSize();
-    bool next_instruction_reached = (pc > m_instruction_addr) &&
-        (pc <= m_instruction_addr + max_opcode_size);
-    if (next_instruction_reached) {
-      SetPlanComplete();
-    }
     return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
   } else if (cur_frame_id < m_stack_id) {
     // If the current frame is younger than the start frame and we are stepping

Modified: lldb/trunk/source/Target/ThreadPlanStepRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepRange.cpp?rev=290197&r1=290196&r2=290197&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepRange.cpp Tue Dec 20 14:00:58 2016
@@ -461,16 +461,6 @@ bool ThreadPlanStepRange::IsPlanStale()
     // One tricky bit here is that some stubs don't push a frame, so we should.
     // check that we are in the same symbol.
     if (!InRange()) {
-      // Set plan Complete when we reach next instruction just after the range
-      lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
-      size_t num_ranges = m_address_ranges.size();
-      for (size_t i = 0; i < num_ranges; i++) {
-        bool in_range = m_address_ranges[i].ContainsLoadAddress(
-            addr, m_thread.CalculateTarget().get());
-        if (in_range) {
-          SetPlanComplete();
-        }
-      }
       return true;
     }
   }




More information about the lldb-commits mailing list