1 //===-- ThreadPlanStepInRange.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/ThreadPlanStepInRange.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 
17 #include "lldb/lldb-private-log.h"
18 #include "lldb/Core/Log.h"
19 #include "lldb/Core/Stream.h"
20 #include "lldb/Symbol/Symbol.h"
21 #include "lldb/Symbol/Function.h"
22 #include "lldb/Target/Process.h"
23 #include "lldb/Target/RegisterContext.h"
24 #include "lldb/Target/Thread.h"
25 #include "lldb/Target/ThreadPlanStepOut.h"
26 #include "lldb/Target/ThreadPlanStepThrough.h"
27 #include "lldb/Core/RegularExpression.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 uint32_t ThreadPlanStepInRange::s_default_flag_values = ThreadPlanShouldStopHere::eAvoidNoDebug;
33 
34 //----------------------------------------------------------------------
35 // ThreadPlanStepInRange: Step through a stack range, either stepping over or into
36 // based on the value of \a type.
37 //----------------------------------------------------------------------
38 
39 ThreadPlanStepInRange::ThreadPlanStepInRange
40 (
41     Thread &thread,
42     const AddressRange &range,
43     const SymbolContext &addr_context,
44     lldb::RunMode stop_others
45 ) :
46     ThreadPlanStepRange (ThreadPlan::eKindStepInRange, "Step Range stepping in", thread, range, addr_context, stop_others),
47     ThreadPlanShouldStopHere (this, ThreadPlanStepInRange::DefaultShouldStopHereCallback, NULL),
48     m_step_past_prologue (true)
49 {
50     SetFlagsToDefault ();
51 }
52 
53 ThreadPlanStepInRange::~ThreadPlanStepInRange ()
54 {
55 }
56 
57 void
58 ThreadPlanStepInRange::GetDescription (Stream *s, lldb::DescriptionLevel level)
59 {
60     if (level == lldb::eDescriptionLevelBrief)
61         s->Printf("step in");
62     else
63     {
64         s->Printf ("Stepping through range (stepping into functions): ");
65         m_address_range.Dump (s, &m_thread.GetProcess().GetTarget(), Address::DumpStyleLoadAddress);
66     }
67 }
68 
69 bool
70 ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
71 {
72     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP);
73     m_no_more_plans = false;
74 
75     if (log)
76     {
77         StreamString s;
78         s.Address (m_thread.GetRegisterContext()->GetPC(), m_thread.GetProcess().GetAddressByteSize());
79         log->Printf("ThreadPlanStepInRange reached %s.", s.GetData());
80     }
81 
82     // If we're still in the range, keep going.
83     if (InRange())
84         return false;
85 
86     // If we're in an older frame then we should stop.
87     if (FrameIsOlder())
88         return true;
89 
90     // See if we are in a place we should step through (i.e. a trampoline of some sort):
91     // One tricky bit here is that some stubs don't push a frame, so we have to check
92     // both the case of a frame that is younger, or the same as this frame.
93     // However, if the frame is the same, and we are still in the symbol we started
94     // in, the we don't need to do this.  This first check isn't strictly necessary,
95     // but it is more efficient.
96 
97     if (!FrameIsYounger() && InSymbol())
98     {
99         SetPlanComplete();
100         return true;
101     }
102 
103     ThreadPlan* new_plan = NULL;
104 
105     // Stepping through should be done stopping other threads in general, since we're setting a breakpoint and
106     // continuing...
107 
108     bool stop_others;
109     if (m_stop_others != lldb::eAllThreads)
110         stop_others = true;
111     else
112         stop_others = false;
113 
114     new_plan = m_thread.QueueThreadPlanForStepThrough (false, stop_others);
115 
116     if (log)
117     {
118         if (new_plan != NULL)
119             log->Printf ("Found a step through plan: %s", new_plan->GetName());
120         else
121             log->Printf ("No step through plan found.");
122     }
123 
124     // If not, give the "should_stop" callback a chance to push a plan to get us out of here.
125     // But only do that if we actually have stepped in.
126     if (!new_plan && FrameIsYounger())
127         new_plan = InvokeShouldStopHereCallback();
128 
129     // If we've stepped in and we are going to stop here, check to see if we were asked to
130     // run past the prologue, and if so do that.
131 
132     if (new_plan == NULL && FrameIsYounger() && m_step_past_prologue)
133     {
134         lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
135         if (curr_frame)
136         {
137             size_t bytes_to_skip = 0;
138             lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC();
139             Address func_start_address;
140 
141             SymbolContext sc = curr_frame->GetSymbolContext (eSymbolContextFunction | eSymbolContextSymbol);
142 
143             if (sc.function)
144             {
145                 func_start_address = sc.function->GetAddressRange().GetBaseAddress();
146                 if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget()))
147                     bytes_to_skip = sc.function->GetPrologueByteSize();
148             }
149             else if (sc.symbol)
150             {
151                 func_start_address = sc.symbol->GetValue();
152                 if (curr_addr == func_start_address.GetLoadAddress(m_thread.CalculateTarget()))
153                     bytes_to_skip = sc.symbol->GetPrologueByteSize();
154             }
155 
156             if (bytes_to_skip != 0)
157             {
158                 func_start_address.Slide (bytes_to_skip);
159                 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP);
160                 if (log)
161                     log->Printf ("Pushing past prologue ");
162 
163                 new_plan = m_thread.QueueThreadPlanForRunToAddress(false, func_start_address,true);
164             }
165         }
166     }
167 
168      if (new_plan == NULL)
169      {
170         m_no_more_plans = true;
171         SetPlanComplete();
172         return true;
173     }
174     else
175     {
176         m_no_more_plans = false;
177         return false;
178     }
179 }
180 
181 void
182 ThreadPlanStepInRange::SetFlagsToDefault ()
183 {
184     GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
185 }
186 
187 void
188 ThreadPlanStepInRange::SetAvoidRegexp(const char *name)
189 {
190     if (m_avoid_regexp_ap.get() == NULL)
191         m_avoid_regexp_ap.reset (new RegularExpression(name));
192 
193     m_avoid_regexp_ap->Compile (name);
194 }
195 
196 void
197 ThreadPlanStepInRange::SetDefaultFlagValue (uint32_t new_value)
198 {
199     // TODO: Should we test this for sanity?
200     ThreadPlanStepInRange::s_default_flag_values = new_value;
201 }
202 
203 bool
204 ThreadPlanStepInRange::FrameMatchesAvoidRegexp ()
205 {
206     StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get();
207 
208     RegularExpression *avoid_regexp_to_use;
209 
210     avoid_regexp_to_use = m_avoid_regexp_ap.get();
211     if (avoid_regexp_to_use == NULL)
212         avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp();
213 
214     if (avoid_regexp_to_use != NULL)
215     {
216         SymbolContext sc = frame->GetSymbolContext(eSymbolContextSymbol);
217         if (sc.symbol != NULL)
218         {
219             const char *unnamed_symbol = "<UNKNOWN>";
220             const char *sym_name = sc.symbol->GetMangled().GetName().AsCString(unnamed_symbol);
221             if (strcmp (sym_name, unnamed_symbol) != 0)
222                return avoid_regexp_to_use->Execute(sym_name);
223         }
224     }
225     return false;
226 }
227 
228 ThreadPlan *
229 ThreadPlanStepInRange::DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton)
230 {
231     bool should_step_out = false;
232     StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
233     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP);
234 
235     if (flags.Test(eAvoidNoDebug))
236     {
237         if (!frame->HasDebugInformation())
238         {
239             if (log)
240                 log->Printf ("Stepping out of frame with no debug info");
241 
242             should_step_out = true;
243         }
244     }
245 
246     if (!should_step_out)
247     {
248         if (current_plan->GetKind() == eKindStepInRange)
249         {
250             ThreadPlanStepInRange *step_in_range_plan = static_cast<ThreadPlanStepInRange *> (current_plan);
251             should_step_out = step_in_range_plan->FrameMatchesAvoidRegexp ();
252         }
253     }
254 
255     if (should_step_out)
256     {
257         // FIXME: Make sure the ThreadPlanForStepOut does the right thing with inlined functions.
258         return current_plan->GetThread().QueueThreadPlanForStepOut (false, NULL, true,
259                                                                     current_plan->StopOthers(),
260                                                                     eVoteNo, eVoteNoOpinion);
261     }
262 
263     return NULL;
264 }
265