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 report_stop_vote,
27                                                      Vote report_run_vote)
28     : ThreadPlan(ThreadPlan::eKindStepInstruction,
29                  "Step over single instruction", thread, report_stop_vote,
30                  report_run_vote),
31       m_instruction_addr(0), m_stop_other_threads(stop_other_threads),
32       m_step_over(step_over) {
33   m_takes_iteration_count = true;
34   SetUpState();
35 }
36 
37 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
38 
39 void ThreadPlanStepInstruction::SetUpState() {
40   Thread &thread = GetThread();
41   m_instruction_addr = thread.GetRegisterContext()->GetPC(0);
42   StackFrameSP start_frame_sp(thread.GetStackFrameAtIndex(0));
43   m_stack_id = start_frame_sp->GetStackID();
44 
45   m_start_has_symbol =
46       start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
47 
48   StackFrameSP parent_frame_sp = thread.GetStackFrameAtIndex(1);
49   if (parent_frame_sp)
50     m_parent_frame_id = parent_frame_sp->GetStackID();
51 }
52 
53 void ThreadPlanStepInstruction::GetDescription(Stream *s,
54                                                lldb::DescriptionLevel level) {
55   auto PrintFailureIfAny = [&]() {
56     if (m_status.Success())
57       return;
58     s->Printf(" failed (%s)", m_status.AsCString());
59   };
60 
61   if (level == lldb::eDescriptionLevelBrief) {
62     if (m_step_over)
63       s->Printf("instruction step over");
64     else
65       s->Printf("instruction step into");
66 
67     PrintFailureIfAny();
68   } else {
69     s->Printf("Stepping one instruction past ");
70     DumpAddress(s->AsRawOstream(), m_instruction_addr, sizeof(addr_t));
71     if (!m_start_has_symbol)
72       s->Printf(" which has no symbol");
73 
74     if (m_step_over)
75       s->Printf(" stepping over calls");
76     else
77       s->Printf(" stepping into calls");
78 
79     PrintFailureIfAny();
80   }
81 }
82 
83 bool ThreadPlanStepInstruction::ValidatePlan(Stream *error) {
84   // Since we read the instruction we're stepping over from the thread, this
85   // plan will always work.
86   return true;
87 }
88 
89 bool ThreadPlanStepInstruction::DoPlanExplainsStop(Event *event_ptr) {
90   StopInfoSP stop_info_sp = GetPrivateStopInfo();
91   if (stop_info_sp) {
92     StopReason reason = stop_info_sp->GetStopReason();
93     return (reason == eStopReasonTrace || reason == eStopReasonNone);
94   }
95   return false;
96 }
97 
98 bool ThreadPlanStepInstruction::IsPlanStale() {
99   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
100   Thread &thread = GetThread();
101   StackID cur_frame_id = 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 = thread.GetRegisterContext()->GetPC(0);
105     uint32_t max_opcode_size =
106         GetTarget().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 (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       LLDB_LOGF(log,
121                 "ThreadPlanStepInstruction::IsPlanStale - Current frame is "
122                 "older than start frame, plan is stale.");
123     }
124     return true;
125   }
126 }
127 
128 bool ThreadPlanStepInstruction::ShouldStop(Event *event_ptr) {
129   Thread &thread = GetThread();
130   if (m_step_over) {
131     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
132     StackFrameSP cur_frame_sp = thread.GetStackFrameAtIndex(0);
133     if (!cur_frame_sp) {
134       LLDB_LOGF(
135           log,
136           "ThreadPlanStepInstruction couldn't get the 0th frame, stopping.");
137       SetPlanComplete();
138       return true;
139     }
140 
141     StackID cur_frame_zero_id = cur_frame_sp->GetStackID();
142 
143     if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
144       if (thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
145         if (--m_iteration_count <= 0) {
146           SetPlanComplete();
147           return true;
148         } else {
149           // We are still stepping, reset the start pc, and in case we've
150           // stepped out, reset the current stack id.
151           SetUpState();
152           return false;
153         }
154       } else
155         return false;
156     } else {
157       // We've stepped in, step back out again:
158       StackFrame *return_frame = thread.GetStackFrameAtIndex(1).get();
159       if (return_frame) {
160         if (return_frame->GetStackID() != m_parent_frame_id ||
161             m_start_has_symbol) {
162           // next-instruction shouldn't step out of inlined functions.  But we
163           // may have stepped into a real function that starts with an inlined
164           // function, and we do want to step out of that...
165 
166           if (cur_frame_sp->IsInlined()) {
167             StackFrameSP parent_frame_sp =
168                 thread.GetFrameWithStackID(m_stack_id);
169 
170             if (parent_frame_sp &&
171                 parent_frame_sp->GetConcreteFrameIndex() ==
172                     cur_frame_sp->GetConcreteFrameIndex()) {
173               SetPlanComplete();
174               if (log) {
175                 LLDB_LOGF(log,
176                           "Frame we stepped into is inlined into the frame "
177                           "we were stepping from, stopping.");
178               }
179               return true;
180             }
181           }
182 
183           if (log) {
184             StreamString s;
185             s.PutCString("Stepped in to: ");
186             addr_t stop_addr =
187                 thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
188             DumpAddress(s.AsRawOstream(), stop_addr,
189                         GetTarget().GetArchitecture().GetAddressByteSize());
190             s.PutCString(" stepping out to: ");
191             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
192             DumpAddress(s.AsRawOstream(), return_addr,
193                         GetTarget().GetArchitecture().GetAddressByteSize());
194             LLDB_LOGF(log, "%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           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         LLDB_LOGF(log, "Could not find previous frame, stopping.");
216         SetPlanComplete();
217         return true;
218       }
219     }
220   } else {
221     lldb::addr_t pc_addr = thread.GetRegisterContext()->GetPC(0);
222     if (pc_addr != m_instruction_addr) {
223       if (--m_iteration_count <= 0) {
224         SetPlanComplete();
225         return true;
226       } else {
227         // We are still stepping, reset the start pc, and in case we've stepped
228         // in or out, reset the current stack id.
229         SetUpState();
230         return false;
231       }
232     } else
233       return false;
234   }
235 }
236 
237 bool ThreadPlanStepInstruction::StopOthers() { return m_stop_other_threads; }
238 
239 StateType ThreadPlanStepInstruction::GetPlanRunState() {
240   return eStateStepping;
241 }
242 
243 bool ThreadPlanStepInstruction::WillStop() { return true; }
244 
245 bool ThreadPlanStepInstruction::MischiefManaged() {
246   if (IsPlanComplete()) {
247     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
248     LLDB_LOGF(log, "Completed single instruction step plan.");
249     ThreadPlan::MischiefManaged();
250     return true;
251   } else {
252     return false;
253   }
254 }
255