1 //===-- ThreadPlanShouldStopHere.cpp ----------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Target/ThreadPlanShouldStopHere.h"
11 #include "lldb/Symbol/Symbol.h"
12 #include "lldb/Target/RegisterContext.h"
13 #include "lldb/Target/Thread.h"
14 #include "lldb/Utility/Log.h"
15 
16 using namespace lldb;
17 using namespace lldb_private;
18 
19 //----------------------------------------------------------------------
20 // ThreadPlanShouldStopHere constructor
21 //----------------------------------------------------------------------
22 ThreadPlanShouldStopHere::ThreadPlanShouldStopHere(ThreadPlan *owner)
23     : m_callbacks(), m_baton(nullptr), m_owner(owner),
24       m_flags(ThreadPlanShouldStopHere::eNone) {
25   m_callbacks.should_stop_here_callback =
26       ThreadPlanShouldStopHere::DefaultShouldStopHereCallback;
27   m_callbacks.step_from_here_callback =
28       ThreadPlanShouldStopHere::DefaultStepFromHereCallback;
29 }
30 
31 ThreadPlanShouldStopHere::ThreadPlanShouldStopHere(
32     ThreadPlan *owner, const ThreadPlanShouldStopHereCallbacks *callbacks,
33     void *baton)
34     : m_callbacks(), m_baton(), m_owner(owner),
35       m_flags(ThreadPlanShouldStopHere::eNone) {
36   SetShouldStopHereCallbacks(callbacks, baton);
37 }
38 
39 ThreadPlanShouldStopHere::~ThreadPlanShouldStopHere() = default;
40 
41 bool ThreadPlanShouldStopHere::InvokeShouldStopHereCallback(
42     FrameComparison operation) {
43   bool should_stop_here = true;
44   if (m_callbacks.should_stop_here_callback) {
45     should_stop_here = m_callbacks.should_stop_here_callback(
46         m_owner, m_flags, operation, m_baton);
47     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
48     if (log) {
49       lldb::addr_t current_addr =
50           m_owner->GetThread().GetRegisterContext()->GetPC(0);
51 
52       log->Printf("ShouldStopHere callback returned %u from 0x%" PRIx64 ".",
53                   should_stop_here, current_addr);
54     }
55   }
56 
57   return should_stop_here;
58 }
59 
60 bool ThreadPlanShouldStopHere::DefaultShouldStopHereCallback(
61     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
62     void *baton) {
63   bool should_stop_here = true;
64   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
65   if (!frame)
66     return true;
67 
68   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
69 
70   if ((operation == eFrameCompareOlder && flags.Test(eStepOutAvoidNoDebug)) ||
71       (operation == eFrameCompareYounger && flags.Test(eStepInAvoidNoDebug)) ||
72       (operation == eFrameCompareSameParent &&
73        flags.Test(eStepInAvoidNoDebug))) {
74     if (!frame->HasDebugInformation()) {
75       if (log)
76         log->Printf("Stepping out of frame with no debug info");
77 
78       should_stop_here = false;
79     }
80   }
81 
82   // Always avoid code with line number 0.
83   // FIXME: At present the ShouldStop and the StepFromHere calculate this
84   // independently.  If this ever
85   // becomes expensive (this one isn't) we can try to have this set a state
86   // that the StepFromHere can use.
87   if (frame) {
88     SymbolContext sc;
89     sc = frame->GetSymbolContext(eSymbolContextLineEntry);
90     if (sc.line_entry.line == 0)
91       should_stop_here = false;
92   }
93 
94   return should_stop_here;
95 }
96 
97 ThreadPlanSP ThreadPlanShouldStopHere::DefaultStepFromHereCallback(
98     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
99     void *baton) {
100   const bool stop_others = false;
101   const size_t frame_index = 0;
102   ThreadPlanSP return_plan_sp;
103   // If we are stepping through code at line number 0, then we need to step
104   // over this range.  Otherwise we will step out.
105   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
106 
107   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
108   if (!frame)
109     return return_plan_sp;
110   SymbolContext sc;
111   sc = frame->GetSymbolContext(eSymbolContextLineEntry | eSymbolContextSymbol);
112 
113   if (sc.line_entry.line == 0) {
114     AddressRange range = sc.line_entry.range;
115 
116     // If the whole function is marked line 0 just step out, that's easier &
117     // faster than continuing to step through it.
118     bool just_step_out = false;
119     if (sc.symbol && sc.symbol->ValueIsAddress()) {
120       Address symbol_end = sc.symbol->GetAddress();
121       symbol_end.Slide(sc.symbol->GetByteSize() - 1);
122       if (range.ContainsFileAddress(sc.symbol->GetAddress()) &&
123           range.ContainsFileAddress(symbol_end)) {
124         if (log)
125           log->Printf("Stopped in a function with only line 0 lines, just "
126                       "stepping out.");
127         just_step_out = true;
128       }
129     }
130     if (!just_step_out) {
131       if (log)
132         log->Printf("ThreadPlanShouldStopHere::DefaultStepFromHereCallback "
133                     "Queueing StepInRange plan to step through line 0 code.");
134 
135       return_plan_sp = current_plan->GetThread().QueueThreadPlanForStepInRange(
136           false, range, sc, NULL, eOnlyDuringStepping, eLazyBoolCalculate,
137           eLazyBoolNo);
138     }
139   }
140 
141   if (!return_plan_sp)
142     return_plan_sp =
143         current_plan->GetThread().QueueThreadPlanForStepOutNoShouldStop(
144             false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion,
145             frame_index, true);
146   return return_plan_sp;
147 }
148 
149 ThreadPlanSP ThreadPlanShouldStopHere::QueueStepOutFromHerePlan(
150     lldb_private::Flags &flags, lldb::FrameComparison operation) {
151   ThreadPlanSP return_plan_sp;
152   if (m_callbacks.step_from_here_callback) {
153     return_plan_sp =
154         m_callbacks.step_from_here_callback(m_owner, flags, operation, m_baton);
155   }
156   return return_plan_sp;
157 }
158 
159 lldb::ThreadPlanSP ThreadPlanShouldStopHere::CheckShouldStopHereAndQueueStepOut(
160     lldb::FrameComparison operation) {
161   if (!InvokeShouldStopHereCallback(operation))
162     return QueueStepOutFromHerePlan(m_flags, operation);
163   else
164     return ThreadPlanSP();
165 }
166