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