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