1 //===-- ThreadPlanStepInstruction.cpp -------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Target/ThreadPlanStepInstruction.h"
10 #include "lldb/Target/Process.h"
11 #include "lldb/Target/RegisterContext.h"
12 #include "lldb/Target/RegisterContext.h"
13 #include "lldb/Target/StopInfo.h"
14 #include "lldb/Target/Target.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/Stream.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 // ThreadPlanStepInstruction: Step over the current instruction
22 
23 ThreadPlanStepInstruction::ThreadPlanStepInstruction(Thread &thread,
24                                                      bool step_over,
25                                                      bool stop_other_threads,
26                                                      Vote stop_vote,
27                                                      Vote run_vote)
28     : ThreadPlan(ThreadPlan::eKindStepInstruction,
29                  "Step over single instruction", thread, stop_vote, run_vote),
30       m_instruction_addr(0), m_stop_other_threads(stop_other_threads),
31       m_step_over(step_over) {
32   m_takes_iteration_count = true;
33   SetUpState();
34 }
35 
36 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
37 
38 void ThreadPlanStepInstruction::SetUpState() {
39   Thread &thread = GetThread();
40   m_instruction_addr = thread.GetRegisterContext()->GetPC(0);
41   StackFrameSP start_frame_sp(thread.GetStackFrameAtIndex(0));
42   m_stack_id = start_frame_sp->GetStackID();
43 
44   m_start_has_symbol =
45       start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
46 
47   StackFrameSP parent_frame_sp = thread.GetStackFrameAtIndex(1);
48   if (parent_frame_sp)
49     m_parent_frame_id = parent_frame_sp->GetStackID();
50 }
51 
52 void ThreadPlanStepInstruction::GetDescription(Stream *s,
53                                                lldb::DescriptionLevel level) {
54   auto PrintFailureIfAny = [&]() {
55     if (m_status.Success())
56       return;
57     s->Printf(" failed (%s)", m_status.AsCString());
58   };
59 
60   if (level == lldb::eDescriptionLevelBrief) {
61     if (m_step_over)
62       s->Printf("instruction step over");
63     else
64       s->Printf("instruction step into");
65 
66     PrintFailureIfAny();
67   } else {
68     s->Printf("Stepping one instruction past ");
69     DumpAddress(s->AsRawOstream(), m_instruction_addr, sizeof(addr_t));
70     if (!m_start_has_symbol)
71       s->Printf(" which has no symbol");
72 
73     if (m_step_over)
74       s->Printf(" stepping over calls");
75     else
76       s->Printf(" stepping into calls");
77 
78     PrintFailureIfAny();
79   }
80 }
81 
82 bool ThreadPlanStepInstruction::ValidatePlan(Stream *error) {
83   // Since we read the instruction we're stepping over from the thread, this
84   // plan will always work.
85   return true;
86 }
87 
88 bool ThreadPlanStepInstruction::DoPlanExplainsStop(Event *event_ptr) {
89   StopInfoSP stop_info_sp = GetPrivateStopInfo();
90   if (stop_info_sp) {
91     StopReason reason = stop_info_sp->GetStopReason();
92     return (reason == eStopReasonTrace || reason == eStopReasonNone);
93   }
94   return false;
95 }
96 
97 bool ThreadPlanStepInstruction::IsPlanStale() {
98   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
99   Thread &thread = GetThread();
100   StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
101   if (cur_frame_id == m_stack_id) {
102     // Set plan Complete when we reach next instruction
103     uint64_t pc = thread.GetRegisterContext()->GetPC(0);
104     uint32_t max_opcode_size =
105         GetTarget().GetArchitecture().GetMaximumOpcodeByteSize();
106     bool next_instruction_reached = (pc > m_instruction_addr) &&
107         (pc <= m_instruction_addr + max_opcode_size);
108     if (next_instruction_reached) {
109       SetPlanComplete();
110     }
111     return (thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
112   } else if (cur_frame_id < m_stack_id) {
113     // If the current frame is younger than the start frame and we are stepping
114     // over, then we need to continue, but if we are doing just one step, we're
115     // done.
116     return !m_step_over;
117   } else {
118     if (log) {
119       LLDB_LOGF(log,
120                 "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   Thread &thread = GetThread();
129   if (m_step_over) {
130     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
131     StackFrameSP cur_frame_sp = thread.GetStackFrameAtIndex(0);
132     if (!cur_frame_sp) {
133       LLDB_LOGF(
134           log,
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 (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 = 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                 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                 LLDB_LOGF(log,
175                           "Frame we stepped into is inlined into the frame "
176                           "we were stepping from, stopping.");
177               }
178               return true;
179             }
180           }
181 
182           if (log) {
183             StreamString s;
184             s.PutCString("Stepped in to: ");
185             addr_t stop_addr =
186                 thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
187             DumpAddress(s.AsRawOstream(), stop_addr,
188                         GetTarget().GetArchitecture().GetAddressByteSize());
189             s.PutCString(" stepping out to: ");
190             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
191             DumpAddress(s.AsRawOstream(), return_addr,
192                         GetTarget().GetArchitecture().GetAddressByteSize());
193             LLDB_LOGF(log, "%s.", s.GetData());
194           }
195 
196           // StepInstruction should probably have the tri-state RunMode, but
197           // for now it is safer to run others.
198           const bool stop_others = false;
199           thread.QueueThreadPlanForStepOutNoShouldStop(
200               false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
201               m_status);
202           return false;
203         } else {
204           if (log) {
205             log->PutCString(
206                 "The stack id we are stepping in changed, but our parent frame "
207                 "did not when stepping from code with no symbols.  "
208                 "We are probably just confused about where we are, stopping.");
209           }
210           SetPlanComplete();
211           return true;
212         }
213       } else {
214         LLDB_LOGF(log, "Could not find previous frame, stopping.");
215         SetPlanComplete();
216         return true;
217       }
218     }
219   } else {
220     lldb::addr_t pc_addr = thread.GetRegisterContext()->GetPC(0);
221     if (pc_addr != m_instruction_addr) {
222       if (--m_iteration_count <= 0) {
223         SetPlanComplete();
224         return true;
225       } else {
226         // We are still stepping, reset the start pc, and in case we've stepped
227         // in or out, reset the current stack id.
228         SetUpState();
229         return false;
230       }
231     } else
232       return false;
233   }
234 }
235 
236 bool ThreadPlanStepInstruction::StopOthers() { return m_stop_other_threads; }
237 
238 StateType ThreadPlanStepInstruction::GetPlanRunState() {
239   return eStateStepping;
240 }
241 
242 bool ThreadPlanStepInstruction::WillStop() { return true; }
243 
244 bool ThreadPlanStepInstruction::MischiefManaged() {
245   if (IsPlanComplete()) {
246     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
247     LLDB_LOGF(log, "Completed single instruction step plan.");
248     ThreadPlan::MischiefManaged();
249     return true;
250   } else {
251     return false;
252   }
253 }
254