1 //===-- ThreadPlanStepOut.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/ThreadPlanStepOut.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Breakpoint/Breakpoint.h"
17 #include "lldb/lldb-private-log.h"
18 #include "lldb/Core/Log.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Core/ValueObjectConstResult.h"
21 #include "lldb/Target/Process.h"
22 #include "lldb/Target/RegisterContext.h"
23 #include "lldb/Target/StopInfo.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Target/ThreadPlanStepOverRange.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 //----------------------------------------------------------------------
31 // ThreadPlanStepOut: Step out of the current frame
32 //----------------------------------------------------------------------
33 
34 ThreadPlanStepOut::ThreadPlanStepOut
35 (
36     Thread &thread,
37     SymbolContext *context,
38     bool first_insn,
39     bool stop_others,
40     Vote stop_vote,
41     Vote run_vote,
42     uint32_t frame_idx
43 ) :
44     ThreadPlan (ThreadPlan::eKindStepOut, "Step out", thread, stop_vote, run_vote),
45     m_step_from_context (context),
46     m_step_from_insn (LLDB_INVALID_ADDRESS),
47     m_return_bp_id (LLDB_INVALID_BREAK_ID),
48     m_return_addr (LLDB_INVALID_ADDRESS),
49     m_first_insn (first_insn),
50     m_stop_others (stop_others),
51     m_step_through_inline_plan_sp(),
52     m_step_out_plan_sp (),
53     m_immediate_step_from_function(NULL)
54 
55 {
56     m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
57 
58     StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
59     StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
60 
61     m_stack_depth = m_thread.GetStackFrameCount() - frame_idx;
62 
63     // If the frame directly below the one we are returning to is inlined, we have to be
64     // a little more careful.  It is non-trivial to determine the real "return code address" for
65     // an inlined frame, so we have to work our way to that frame and then step out.
66     if (immediate_return_from_sp && immediate_return_from_sp->IsInlined())
67     {
68         if (frame_idx > 0)
69         {
70             // First queue a plan that gets us to this inlined frame, and when we get there we'll queue a second
71             // plan that walks us out of this frame.
72             m_step_out_plan_sp.reset (new ThreadPlanStepOut(m_thread, NULL, false, stop_others, eVoteNoOpinion, eVoteNoOpinion, frame_idx - 1));
73             m_step_out_plan_sp->SetOkayToDiscard(true);
74         }
75         else
76         {
77             // If we're already at the inlined frame we're stepping through, then just do that now.
78             QueueInlinedStepPlan(false);
79         }
80 
81     }
82     else if (return_frame_sp)
83     {
84         // Find the return address and set a breakpoint there:
85         // FIXME - can we do this more securely if we know first_insn?
86 
87         m_return_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(&m_thread.GetProcess().GetTarget());
88         Breakpoint *return_bp = m_thread.GetProcess().GetTarget().CreateBreakpoint (m_return_addr, true).get();
89         if (return_bp != NULL)
90         {
91             return_bp->SetThreadID(m_thread.GetID());
92             m_return_bp_id = return_bp->GetID();
93         }
94 
95         if (immediate_return_from_sp)
96         {
97             const SymbolContext &sc = immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
98             if (sc.function)
99             {
100                 m_immediate_step_from_function = sc.function;
101             }
102         }
103     }
104 
105 }
106 
107 void
108 ThreadPlanStepOut::DidPush()
109 {
110     if (m_step_out_plan_sp)
111         m_thread.QueueThreadPlan(m_step_out_plan_sp, false);
112     else if (m_step_through_inline_plan_sp)
113         m_thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
114 }
115 
116 ThreadPlanStepOut::~ThreadPlanStepOut ()
117 {
118     if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
119         m_thread.GetProcess().GetTarget().RemoveBreakpointByID(m_return_bp_id);
120 }
121 
122 void
123 ThreadPlanStepOut::GetDescription (Stream *s, lldb::DescriptionLevel level)
124 {
125     if (level == lldb::eDescriptionLevelBrief)
126         s->Printf ("step out");
127     else
128     {
129         if (m_step_out_plan_sp)
130             s->Printf ("Stepping out to inlined frame at depth: %d so we can walk through it.", m_stack_depth);
131         else if (m_step_through_inline_plan_sp)
132             s->Printf ("Stepping out by stepping through inlined function.");
133         else
134             s->Printf ("Stepping out from address 0x%llx to return address 0x%llx at depth: %d using breakpoint site %d",
135                        (uint64_t)m_step_from_insn,
136                        (uint64_t)m_return_addr,
137                        m_stack_depth,
138                        m_return_bp_id);
139     }
140 }
141 
142 bool
143 ThreadPlanStepOut::ValidatePlan (Stream *error)
144 {
145     if (m_step_out_plan_sp)
146         return m_step_out_plan_sp->ValidatePlan (error);
147     else if (m_step_through_inline_plan_sp)
148         return m_step_through_inline_plan_sp->ValidatePlan (error);
149     else if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
150     {
151         error->PutCString("Could not create return address breakpoint.");
152         return false;
153     }
154     else
155         return true;
156 }
157 
158 bool
159 ThreadPlanStepOut::PlanExplainsStop ()
160 {
161     // If one of our child plans just finished, then we do explain the stop.
162     if (m_step_out_plan_sp)
163     {
164         if (m_step_out_plan_sp->MischiefManaged())
165         {
166             // If this one is done, then we are all done.
167             CalculateReturnValue();
168             SetPlanComplete();
169             return true;
170         }
171         else
172             return false;
173     }
174     else if (m_step_through_inline_plan_sp)
175     {
176         if (m_step_through_inline_plan_sp->MischiefManaged())
177             return true;
178         else
179             return false;
180     }
181 
182     // We don't explain signals or breakpoints (breakpoints that handle stepping in or
183     // out will be handled by a child plan.
184 
185     StopInfoSP stop_info_sp = GetPrivateStopReason();
186     if (stop_info_sp)
187     {
188         StopReason reason = stop_info_sp->GetStopReason();
189         switch (reason)
190         {
191         case eStopReasonBreakpoint:
192         {
193             // If this is OUR breakpoint, we're fine, otherwise we don't know why this happened...
194             BreakpointSiteSP site_sp (m_thread.GetProcess().GetBreakpointSiteList().FindByID (stop_info_sp->GetValue()));
195             if (site_sp && site_sp->IsBreakpointAtThisSite (m_return_bp_id))
196             {
197                 const uint32_t num_frames = m_thread.GetStackFrameCount();
198                 if (m_stack_depth > num_frames)
199                 {
200                     CalculateReturnValue();
201                     SetPlanComplete();
202                 }
203 
204                 // If there was only one owner, then we're done.  But if we also hit some
205                 // user breakpoint on our way out, we should mark ourselves as done, but
206                 // also not claim to explain the stop, since it is more important to report
207                 // the user breakpoint than the step out completion.
208 
209                 if (site_sp->GetNumberOfOwners() == 1)
210                     return true;
211 
212             }
213             return false;
214         }
215         case eStopReasonWatchpoint:
216         case eStopReasonSignal:
217         case eStopReasonException:
218             return false;
219 
220         default:
221             return true;
222         }
223     }
224     return true;
225 }
226 
227 bool
228 ThreadPlanStepOut::ShouldStop (Event *event_ptr)
229 {
230         if (IsPlanComplete())
231         {
232             return true;
233         }
234         else if (m_stack_depth > m_thread.GetStackFrameCount())
235         {
236             CalculateReturnValue();
237             SetPlanComplete();
238             return true;
239         }
240         else
241         {
242             if (m_step_out_plan_sp)
243             {
244                 if (m_step_out_plan_sp->MischiefManaged())
245                 {
246                     // Now step through the inlined stack we are in:
247                     if (QueueInlinedStepPlan(true))
248                     {
249                         return false;
250                     }
251                     else
252                     {
253                         CalculateReturnValue();
254                         SetPlanComplete ();
255                         return true;
256                     }
257                 }
258                 else
259                     return m_step_out_plan_sp->ShouldStop(event_ptr);
260             }
261             else if (m_step_through_inline_plan_sp)
262             {
263                 if (m_step_through_inline_plan_sp->MischiefManaged())
264                 {
265                     // We don't calculate the return value here because we don't know how to.
266                     // But in case we had a return value sitting around from our process in
267                     // getting here, let's clear it out.
268                     m_return_valobj_sp.reset();
269                     SetPlanComplete();
270                     return true;
271                 }
272                 else
273                     return m_step_through_inline_plan_sp->ShouldStop(event_ptr);
274             }
275             else
276                 return false;
277         }
278 }
279 
280 bool
281 ThreadPlanStepOut::StopOthers ()
282 {
283     return m_stop_others;
284 }
285 
286 StateType
287 ThreadPlanStepOut::GetPlanRunState ()
288 {
289     return eStateRunning;
290 }
291 
292 bool
293 ThreadPlanStepOut::WillResume (StateType resume_state, bool current_plan)
294 {
295     ThreadPlan::WillResume (resume_state, current_plan);
296     if (m_step_out_plan_sp || m_step_through_inline_plan_sp)
297         return true;
298 
299     if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
300         return false;
301 
302     if (current_plan)
303     {
304         Breakpoint *return_bp = m_thread.GetProcess().GetTarget().GetBreakpointByID(m_return_bp_id).get();
305         if (return_bp != NULL)
306             return_bp->SetEnabled (true);
307     }
308     return true;
309 }
310 
311 bool
312 ThreadPlanStepOut::WillStop ()
313 {
314     if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
315     {
316         Breakpoint *return_bp = m_thread.GetProcess().GetTarget().GetBreakpointByID(m_return_bp_id).get();
317         if (return_bp != NULL)
318             return_bp->SetEnabled (false);
319     }
320 
321     return true;
322 }
323 
324 bool
325 ThreadPlanStepOut::MischiefManaged ()
326 {
327     if (IsPlanComplete())
328     {
329         // Did I reach my breakpoint?  If so I'm done.
330         //
331         // I also check the stack depth, since if we've blown past the breakpoint for some
332         // reason and we're now stopping for some other reason altogether, then we're done
333         // with this step out operation.
334 
335         LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
336         if (log)
337             log->Printf("Completed step out plan.");
338         if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
339         {
340             m_thread.GetProcess().GetTarget().RemoveBreakpointByID (m_return_bp_id);
341             m_return_bp_id = LLDB_INVALID_BREAK_ID;
342         }
343 
344         ThreadPlan::MischiefManaged ();
345         return true;
346     }
347     else
348     {
349         return false;
350     }
351 }
352 
353 bool
354 ThreadPlanStepOut::QueueInlinedStepPlan (bool queue_now)
355 {
356     // Now figure out the range of this inlined block, and set up a "step through range"
357     // plan for that.  If we've been provided with a context, then use the block in that
358     // context.
359     StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
360     if (!immediate_return_from_sp)
361         return false;
362 
363     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
364     if (log)
365     {
366         StreamString s;
367         immediate_return_from_sp->Dump(&s, true, false);
368         log->Printf("Queuing inlined frame to step past: %s.", s.GetData());
369     }
370 
371     Block *from_block = immediate_return_from_sp->GetFrameBlock();
372     if (from_block)
373     {
374         Block *inlined_block = from_block->GetContainingInlinedBlock();
375         if (inlined_block)
376         {
377             size_t num_ranges = inlined_block->GetNumRanges();
378             AddressRange inline_range;
379             if (inlined_block->GetRangeAtIndex(0, inline_range))
380             {
381                 SymbolContext inlined_sc;
382                 inlined_block->CalculateSymbolContext(&inlined_sc);
383                 RunMode run_mode = m_stop_others ? lldb::eOnlyThisThread : lldb::eAllThreads;
384                 ThreadPlanStepOverRange *step_through_inline_plan_ptr = new ThreadPlanStepOverRange(m_thread,
385                                                                                                     inline_range,
386                                                                                                     inlined_sc,
387                                                                                                     run_mode);
388                 step_through_inline_plan_ptr->SetOkayToDiscard(true);
389                 StreamString errors;
390                 if (!step_through_inline_plan_ptr->ValidatePlan(&errors))
391                 {
392                     //FIXME: Log this failure.
393                     delete step_through_inline_plan_ptr;
394                     return false;
395                 }
396 
397                 for (size_t i = 1; i < num_ranges; i++)
398                 {
399                     if (inlined_block->GetRangeAtIndex (i, inline_range))
400                         step_through_inline_plan_ptr->AddRange (inline_range);
401                 }
402                 m_step_through_inline_plan_sp.reset (step_through_inline_plan_ptr);
403                 if (queue_now)
404                     m_thread.QueueThreadPlan (m_step_through_inline_plan_sp, false);
405                 return true;
406             }
407         }
408     }
409 
410     return false;
411 }
412 
413 void
414 ThreadPlanStepOut::CalculateReturnValue ()
415 {
416     if (m_return_valobj_sp)
417         return;
418 
419     if (m_immediate_step_from_function != NULL)
420     {
421         Type *return_type = m_immediate_step_from_function->GetType();
422         lldb::clang_type_t return_clang_type = m_immediate_step_from_function->GetReturnClangType();
423         if (return_type && return_clang_type)
424         {
425             ClangASTType ast_type (return_type->GetClangAST(), return_clang_type);
426 
427             lldb::ABISP abi_sp = m_thread.GetProcess().GetABI();
428             if (abi_sp)
429             {
430                 m_return_valobj_sp = abi_sp->GetReturnValueObject(m_thread, ast_type);
431             }
432         }
433     }
434 }
435