1 //===-- ThreadPlanStepInstruction.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/ThreadPlanStepInstruction.h"
11 #include "lldb/Target/Process.h"
12 #include "lldb/Target/RegisterContext.h"
13 #include "lldb/Target/RegisterContext.h"
14 #include "lldb/Target/StopInfo.h"
15 #include "lldb/Target/Target.h"
16 #include "lldb/Utility/Log.h"
17 #include "lldb/Utility/Stream.h"
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 //----------------------------------------------------------------------
23 // ThreadPlanStepInstruction: Step over the current instruction
24 //----------------------------------------------------------------------
25 
26 ThreadPlanStepInstruction::ThreadPlanStepInstruction(Thread &thread,
27                                                      bool step_over,
28                                                      bool stop_other_threads,
29                                                      Vote stop_vote,
30                                                      Vote run_vote)
31     : ThreadPlan(ThreadPlan::eKindStepInstruction,
32                  "Step over single instruction", thread, stop_vote, run_vote),
33       m_instruction_addr(0), m_stop_other_threads(stop_other_threads),
34       m_step_over(step_over) {
35   m_takes_iteration_count = true;
36   SetUpState();
37 }
38 
39 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
40 
41 void ThreadPlanStepInstruction::SetUpState() {
42   m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
43   StackFrameSP start_frame_sp(m_thread.GetStackFrameAtIndex(0));
44   m_stack_id = start_frame_sp->GetStackID();
45 
46   m_start_has_symbol =
47       start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
48 
49   StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
50   if (parent_frame_sp)
51     m_parent_frame_id = parent_frame_sp->GetStackID();
52 }
53 
54 void ThreadPlanStepInstruction::GetDescription(Stream *s,
55                                                lldb::DescriptionLevel level) {
56   auto PrintFailureIfAny = [&]() {
57     if (m_status.Success())
58       return;
59     s->Printf(" failed (%s)", m_status.AsCString());
60   };
61 
62   if (level == lldb::eDescriptionLevelBrief) {
63     if (m_step_over)
64       s->Printf("instruction step over");
65     else
66       s->Printf("instruction step into");
67 
68     PrintFailureIfAny();
69   } else {
70     s->Printf("Stepping one instruction past ");
71     s->Address(m_instruction_addr, sizeof(addr_t));
72     if (!m_start_has_symbol)
73       s->Printf(" which has no symbol");
74 
75     if (m_step_over)
76       s->Printf(" stepping over calls");
77     else
78       s->Printf(" stepping into calls");
79 
80     PrintFailureIfAny();
81   }
82 }
83 
84 bool ThreadPlanStepInstruction::ValidatePlan(Stream *error) {
85   // Since we read the instruction we're stepping over from the thread, this
86   // plan will always work.
87   return true;
88 }
89 
90 bool ThreadPlanStepInstruction::DoPlanExplainsStop(Event *event_ptr) {
91   StopInfoSP stop_info_sp = GetPrivateStopInfo();
92   if (stop_info_sp) {
93     StopReason reason = stop_info_sp->GetStopReason();
94     return (reason == eStopReasonTrace || reason == eStopReasonNone);
95   }
96   return false;
97 }
98 
99 bool ThreadPlanStepInstruction::IsPlanStale() {
100   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
101   StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
102   if (cur_frame_id == m_stack_id) {
103     // Set plan Complete when we reach next instruction
104     uint64_t pc = m_thread.GetRegisterContext()->GetPC(0);
105     uint32_t max_opcode_size = m_thread.CalculateTarget()
106         ->GetArchitecture().GetMaximumOpcodeByteSize();
107     bool next_instruction_reached = (pc > m_instruction_addr) &&
108         (pc <= m_instruction_addr + max_opcode_size);
109     if (next_instruction_reached) {
110       SetPlanComplete();
111     }
112     return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
113   } else if (cur_frame_id < m_stack_id) {
114     // If the current frame is younger than the start frame and we are stepping
115     // over, then we need to continue, but if we are doing just one step, we're
116     // done.
117     return !m_step_over;
118   } else {
119     if (log) {
120       log->Printf("ThreadPlanStepInstruction::IsPlanStale - Current frame is "
121                   "older than start frame, plan is stale.");
122     }
123     return true;
124   }
125 }
126 
127 bool ThreadPlanStepInstruction::ShouldStop(Event *event_ptr) {
128   if (m_step_over) {
129     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
130 
131     StackFrameSP cur_frame_sp = m_thread.GetStackFrameAtIndex(0);
132     if (!cur_frame_sp) {
133       if (log)
134         log->Printf(
135             "ThreadPlanStepInstruction couldn't get the 0th frame, stopping.");
136       SetPlanComplete();
137       return true;
138     }
139 
140     StackID cur_frame_zero_id = cur_frame_sp->GetStackID();
141 
142     if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
143       if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
144         if (--m_iteration_count <= 0) {
145           SetPlanComplete();
146           return true;
147         } else {
148           // We are still stepping, reset the start pc, and in case we've
149           // stepped out, reset the current stack id.
150           SetUpState();
151           return false;
152         }
153       } else
154         return false;
155     } else {
156       // We've stepped in, step back out again:
157       StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
158       if (return_frame) {
159         if (return_frame->GetStackID() != m_parent_frame_id ||
160             m_start_has_symbol) {
161           // next-instruction shouldn't step out of inlined functions.  But we
162           // may have stepped into a real function that starts with an inlined
163           // function, and we do want to step out of that...
164 
165           if (cur_frame_sp->IsInlined()) {
166             StackFrameSP parent_frame_sp =
167                 m_thread.GetFrameWithStackID(m_stack_id);
168 
169             if (parent_frame_sp &&
170                 parent_frame_sp->GetConcreteFrameIndex() ==
171                     cur_frame_sp->GetConcreteFrameIndex()) {
172               SetPlanComplete();
173               if (log) {
174                 log->Printf("Frame we stepped into is inlined into the frame "
175                             "we were stepping from, stopping.");
176               }
177               return true;
178             }
179           }
180 
181           if (log) {
182             StreamString s;
183             s.PutCString("Stepped in to: ");
184             addr_t stop_addr =
185                 m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
186             s.Address(stop_addr, m_thread.CalculateTarget()
187                                      ->GetArchitecture()
188                                      .GetAddressByteSize());
189             s.PutCString(" stepping out to: ");
190             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
191             s.Address(return_addr, m_thread.CalculateTarget()
192                                        ->GetArchitecture()
193                                        .GetAddressByteSize());
194             log->Printf("%s.", s.GetData());
195           }
196 
197           // StepInstruction should probably have the tri-state RunMode, but
198           // for now it is safer to run others.
199           const bool stop_others = false;
200           m_thread.QueueThreadPlanForStepOutNoShouldStop(
201               false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
202               m_status);
203           return false;
204         } else {
205           if (log) {
206             log->PutCString(
207                 "The stack id we are stepping in changed, but our parent frame "
208                 "did not when stepping from code with no symbols.  "
209                 "We are probably just confused about where we are, stopping.");
210           }
211           SetPlanComplete();
212           return true;
213         }
214       } else {
215         if (log)
216           log->Printf("Could not find previous frame, stopping.");
217         SetPlanComplete();
218         return true;
219       }
220     }
221   } else {
222     lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC(0);
223     if (pc_addr != m_instruction_addr) {
224       if (--m_iteration_count <= 0) {
225         SetPlanComplete();
226         return true;
227       } else {
228         // We are still stepping, reset the start pc, and in case we've stepped
229         // in or out, reset the current stack id.
230         SetUpState();
231         return false;
232       }
233     } else
234       return false;
235   }
236 }
237 
238 bool ThreadPlanStepInstruction::StopOthers() { return m_stop_other_threads; }
239 
240 StateType ThreadPlanStepInstruction::GetPlanRunState() {
241   return eStateStepping;
242 }
243 
244 bool ThreadPlanStepInstruction::WillStop() { return true; }
245 
246 bool ThreadPlanStepInstruction::MischiefManaged() {
247   if (IsPlanComplete()) {
248     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
249     if (log)
250       log->Printf("Completed single instruction step plan.");
251     ThreadPlan::MischiefManaged();
252     return true;
253   } else {
254     return false;
255   }
256 }
257