1 //===-- ThreadPlanStepRange.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/ThreadPlanStepRange.h"
10 #include "lldb/Breakpoint/BreakpointLocation.h"
11 #include "lldb/Breakpoint/BreakpointSite.h"
12 #include "lldb/Core/Disassembler.h"
13 #include "lldb/Symbol/Function.h"
14 #include "lldb/Symbol/Symbol.h"
15 #include "lldb/Target/ExecutionContext.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/RegisterContext.h"
18 #include "lldb/Target/StopInfo.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Target/Thread.h"
21 #include "lldb/Target/ThreadPlanRunToAddress.h"
22 #include "lldb/Utility/Log.h"
23 #include "lldb/Utility/Stream.h"
24
25 using namespace lldb;
26 using namespace lldb_private;
27
28 // ThreadPlanStepRange: Step through a stack range, either stepping over or
29 // into based on the value of \a type.
30
ThreadPlanStepRange(ThreadPlanKind kind,const char * name,Thread & thread,const AddressRange & range,const SymbolContext & addr_context,lldb::RunMode stop_others,bool given_ranges_only)31 ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
32 Thread &thread,
33 const AddressRange &range,
34 const SymbolContext &addr_context,
35 lldb::RunMode stop_others,
36 bool given_ranges_only)
37 : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
38 m_addr_context(addr_context), m_address_ranges(),
39 m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
40 m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
41 m_given_ranges_only(given_ranges_only) {
42 m_use_fast_step = GetTarget().GetUseFastStepping();
43 AddRange(range);
44 m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
45 StackFrameSP parent_stack = m_thread.GetStackFrameAtIndex(1);
46 if (parent_stack)
47 m_parent_stack_id = parent_stack->GetStackID();
48 }
49
~ThreadPlanStepRange()50 ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); }
51
DidPush()52 void ThreadPlanStepRange::DidPush() {
53 // See if we can find a "next range" breakpoint:
54 SetNextBranchBreakpoint();
55 }
56
ValidatePlan(Stream * error)57 bool ThreadPlanStepRange::ValidatePlan(Stream *error) {
58 if (m_could_not_resolve_hw_bp) {
59 if (error)
60 error->PutCString(
61 "Could not create hardware breakpoint for thread plan.");
62 return false;
63 }
64 return true;
65 }
66
ShouldReportStop(Event * event_ptr)67 Vote ThreadPlanStepRange::ShouldReportStop(Event *event_ptr) {
68 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
69
70 const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
71 LLDB_LOGF(log, "ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
72 vote);
73 return vote;
74 }
75
AddRange(const AddressRange & new_range)76 void ThreadPlanStepRange::AddRange(const AddressRange &new_range) {
77 // For now I'm just adding the ranges. At some point we may want to condense
78 // the ranges if they overlap, though I don't think it is likely to be very
79 // important.
80 m_address_ranges.push_back(new_range);
81
82 // Fill the slot for this address range with an empty DisassemblerSP in the
83 // instruction ranges. I want the indices to match, but I don't want to do
84 // the work to disassemble this range if I don't step into it.
85 m_instruction_ranges.push_back(DisassemblerSP());
86 }
87
DumpRanges(Stream * s)88 void ThreadPlanStepRange::DumpRanges(Stream *s) {
89 size_t num_ranges = m_address_ranges.size();
90 if (num_ranges == 1) {
91 m_address_ranges[0].Dump(s, m_thread.CalculateTarget().get(),
92 Address::DumpStyleLoadAddress);
93 } else {
94 for (size_t i = 0; i < num_ranges; i++) {
95 s->Printf(" %" PRIu64 ": ", uint64_t(i));
96 m_address_ranges[i].Dump(s, m_thread.CalculateTarget().get(),
97 Address::DumpStyleLoadAddress);
98 }
99 }
100 }
101
InRange()102 bool ThreadPlanStepRange::InRange() {
103 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
104 bool ret_value = false;
105
106 lldb::addr_t pc_load_addr = m_thread.GetRegisterContext()->GetPC();
107
108 size_t num_ranges = m_address_ranges.size();
109 for (size_t i = 0; i < num_ranges; i++) {
110 ret_value = m_address_ranges[i].ContainsLoadAddress(
111 pc_load_addr, m_thread.CalculateTarget().get());
112 if (ret_value)
113 break;
114 }
115
116 if (!ret_value && !m_given_ranges_only) {
117 // See if we've just stepped to another part of the same line number...
118 StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
119
120 SymbolContext new_context(
121 frame->GetSymbolContext(eSymbolContextEverything));
122 if (m_addr_context.line_entry.IsValid() &&
123 new_context.line_entry.IsValid()) {
124 if (m_addr_context.line_entry.original_file ==
125 new_context.line_entry.original_file) {
126 if (m_addr_context.line_entry.line == new_context.line_entry.line) {
127 m_addr_context = new_context;
128 const bool include_inlined_functions =
129 GetKind() == eKindStepOverRange;
130 AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
131 include_inlined_functions));
132 ret_value = true;
133 if (log) {
134 StreamString s;
135 m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
136 true, Address::DumpStyleLoadAddress,
137 Address::DumpStyleLoadAddress, true);
138
139 LLDB_LOGF(
140 log,
141 "Step range plan stepped to another range of same line: %s",
142 s.GetData());
143 }
144 } else if (new_context.line_entry.line == 0) {
145 new_context.line_entry.line = m_addr_context.line_entry.line;
146 m_addr_context = new_context;
147 const bool include_inlined_functions =
148 GetKind() == eKindStepOverRange;
149 AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
150 include_inlined_functions));
151 ret_value = true;
152 if (log) {
153 StreamString s;
154 m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
155 true, Address::DumpStyleLoadAddress,
156 Address::DumpStyleLoadAddress, true);
157
158 LLDB_LOGF(log,
159 "Step range plan stepped to a range at linenumber 0 "
160 "stepping through that range: %s",
161 s.GetData());
162 }
163 } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
164 m_thread.CalculateTarget().get()) != pc_load_addr) {
165 // Another thing that sometimes happens here is that we step out of
166 // one line into the MIDDLE of another line. So far I mostly see
167 // this due to bugs in the debug information. But we probably don't
168 // want to be in the middle of a line range, so in that case reset
169 // the stepping range to the line we've stepped into the middle of
170 // and continue.
171 m_addr_context = new_context;
172 m_address_ranges.clear();
173 AddRange(m_addr_context.line_entry.range);
174 ret_value = true;
175 if (log) {
176 StreamString s;
177 m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
178 true, Address::DumpStyleLoadAddress,
179 Address::DumpStyleLoadAddress, true);
180
181 LLDB_LOGF(log,
182 "Step range plan stepped to the middle of new "
183 "line(%d): %s, continuing to clear this line.",
184 new_context.line_entry.line, s.GetData());
185 }
186 }
187 }
188 }
189 }
190
191 if (!ret_value && log)
192 LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr);
193
194 return ret_value;
195 }
196
InSymbol()197 bool ThreadPlanStepRange::InSymbol() {
198 lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
199 if (m_addr_context.function != nullptr) {
200 return m_addr_context.function->GetAddressRange().ContainsLoadAddress(
201 cur_pc, m_thread.CalculateTarget().get());
202 } else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) {
203 AddressRange range(m_addr_context.symbol->GetAddressRef(),
204 m_addr_context.symbol->GetByteSize());
205 return range.ContainsLoadAddress(cur_pc, m_thread.CalculateTarget().get());
206 }
207 return false;
208 }
209
210 // FIXME: This should also handle inlining if we aren't going to do inlining in
211 // the
212 // main stack.
213 //
214 // Ideally we should remember the whole stack frame list, and then compare that
215 // to the current list.
216
CompareCurrentFrameToStartFrame()217 lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() {
218 FrameComparison frame_order;
219
220 StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
221
222 if (cur_frame_id == m_stack_id) {
223 frame_order = eFrameCompareEqual;
224 } else if (cur_frame_id < m_stack_id) {
225 frame_order = eFrameCompareYounger;
226 } else {
227 StackFrameSP cur_parent_frame = m_thread.GetStackFrameAtIndex(1);
228 StackID cur_parent_id;
229 if (cur_parent_frame)
230 cur_parent_id = cur_parent_frame->GetStackID();
231 if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
232 m_parent_stack_id == cur_parent_id)
233 frame_order = eFrameCompareSameParent;
234 else
235 frame_order = eFrameCompareOlder;
236 }
237 return frame_order;
238 }
239
StopOthers()240 bool ThreadPlanStepRange::StopOthers() {
241 switch (m_stop_others) {
242 case lldb::eOnlyThisThread:
243 return true;
244 case lldb::eOnlyDuringStepping:
245 // If there is a call in the range of the next branch breakpoint,
246 // then we should always run all threads, since a call can execute
247 // arbitrary code which might for instance take a lock that's held
248 // by another thread.
249 return !m_found_calls;
250 case lldb::eAllThreads:
251 return false;
252 }
253 llvm_unreachable("Unhandled run mode!");
254 }
255
GetInstructionsForAddress(lldb::addr_t addr,size_t & range_index,size_t & insn_offset)256 InstructionList *ThreadPlanStepRange::GetInstructionsForAddress(
257 lldb::addr_t addr, size_t &range_index, size_t &insn_offset) {
258 size_t num_ranges = m_address_ranges.size();
259 for (size_t i = 0; i < num_ranges; i++) {
260 if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
261 // Some joker added a zero size range to the stepping range...
262 if (m_address_ranges[i].GetByteSize() == 0)
263 return nullptr;
264
265 if (!m_instruction_ranges[i]) {
266 // Disassemble the address range given:
267 ExecutionContext exe_ctx(m_thread.GetProcess());
268 const char *plugin_name = nullptr;
269 const char *flavor = nullptr;
270 const bool prefer_file_cache = true;
271 m_instruction_ranges[i] = Disassembler::DisassembleRange(
272 GetTarget().GetArchitecture(), plugin_name, flavor, exe_ctx,
273 m_address_ranges[i], prefer_file_cache);
274 }
275 if (!m_instruction_ranges[i])
276 return nullptr;
277 else {
278 // Find where we are in the instruction list as well. If we aren't at
279 // an instruction, return nullptr. In this case, we're probably lost,
280 // and shouldn't try to do anything fancy.
281
282 insn_offset =
283 m_instruction_ranges[i]
284 ->GetInstructionList()
285 .GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
286 if (insn_offset == UINT32_MAX)
287 return nullptr;
288 else {
289 range_index = i;
290 return &m_instruction_ranges[i]->GetInstructionList();
291 }
292 }
293 }
294 }
295 return nullptr;
296 }
297
ClearNextBranchBreakpoint()298 void ThreadPlanStepRange::ClearNextBranchBreakpoint() {
299 if (m_next_branch_bp_sp) {
300 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
301 LLDB_LOGF(log, "Removing next branch breakpoint: %d.",
302 m_next_branch_bp_sp->GetID());
303 GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID());
304 m_next_branch_bp_sp.reset();
305 m_could_not_resolve_hw_bp = false;
306 m_found_calls = false;
307 }
308 }
309
SetNextBranchBreakpoint()310 bool ThreadPlanStepRange::SetNextBranchBreakpoint() {
311 if (m_next_branch_bp_sp)
312 return true;
313
314 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
315 // Stepping through ranges using breakpoints doesn't work yet, but with this
316 // off we fall back to instruction single stepping.
317 if (!m_use_fast_step)
318 return false;
319
320 // clear the m_found_calls, we'll rediscover it for this range.
321 m_found_calls = false;
322
323 lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
324 // Find the current address in our address ranges, and fetch the disassembly
325 // if we haven't already:
326 size_t pc_index;
327 size_t range_index;
328 InstructionList *instructions =
329 GetInstructionsForAddress(cur_addr, range_index, pc_index);
330 if (instructions == nullptr)
331 return false;
332 else {
333 Target &target = GetThread().GetProcess()->GetTarget();
334 const bool ignore_calls = GetKind() == eKindStepOverRange;
335 uint32_t branch_index =
336 instructions->GetIndexOfNextBranchInstruction(pc_index, target,
337 ignore_calls,
338 &m_found_calls);
339
340 Address run_to_address;
341
342 // If we didn't find a branch, run to the end of the range.
343 if (branch_index == UINT32_MAX) {
344 uint32_t last_index = instructions->GetSize() - 1;
345 if (last_index - pc_index > 1) {
346 InstructionSP last_inst =
347 instructions->GetInstructionAtIndex(last_index);
348 size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
349 run_to_address = last_inst->GetAddress();
350 run_to_address.Slide(last_inst_size);
351 }
352 } else if (branch_index - pc_index > 1) {
353 run_to_address =
354 instructions->GetInstructionAtIndex(branch_index)->GetAddress();
355 }
356
357 if (run_to_address.IsValid()) {
358 const bool is_internal = true;
359 m_next_branch_bp_sp =
360 GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
361 if (m_next_branch_bp_sp) {
362
363 if (m_next_branch_bp_sp->IsHardware() &&
364 !m_next_branch_bp_sp->HasResolvedLocations())
365 m_could_not_resolve_hw_bp = true;
366
367 if (log) {
368 lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID;
369 BreakpointLocationSP bp_loc =
370 m_next_branch_bp_sp->GetLocationAtIndex(0);
371 if (bp_loc) {
372 BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
373 if (bp_site) {
374 bp_site_id = bp_site->GetID();
375 }
376 }
377 LLDB_LOGF(log,
378 "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
379 "breakpoint %d (site %d) to run to address 0x%" PRIx64,
380 m_next_branch_bp_sp->GetID(), bp_site_id,
381 run_to_address.GetLoadAddress(
382 &m_thread.GetProcess()->GetTarget()));
383 }
384
385 m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
386 m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
387
388 return true;
389 } else
390 return false;
391 }
392 }
393 return false;
394 }
395
NextRangeBreakpointExplainsStop(lldb::StopInfoSP stop_info_sp)396 bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop(
397 lldb::StopInfoSP stop_info_sp) {
398 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
399 if (!m_next_branch_bp_sp)
400 return false;
401
402 break_id_t bp_site_id = stop_info_sp->GetValue();
403 BreakpointSiteSP bp_site_sp =
404 m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
405 if (!bp_site_sp)
406 return false;
407 else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
408 return false;
409 else {
410 // If we've hit the next branch breakpoint, then clear it.
411 size_t num_owners = bp_site_sp->GetNumberOfOwners();
412 bool explains_stop = true;
413 // If all the owners are internal, then we are probably just stepping over
414 // this range from multiple threads, or multiple frames, so we want to
415 // continue. If one is not internal, then we should not explain the stop,
416 // and let the user breakpoint handle the stop.
417 for (size_t i = 0; i < num_owners; i++) {
418 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
419 explains_stop = false;
420 break;
421 }
422 }
423 LLDB_LOGF(log,
424 "ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit "
425 "next range breakpoint which has %" PRIu64
426 " owners - explains stop: %u.",
427 (uint64_t)num_owners, explains_stop);
428 ClearNextBranchBreakpoint();
429 return explains_stop;
430 }
431 }
432
WillStop()433 bool ThreadPlanStepRange::WillStop() { return true; }
434
GetPlanRunState()435 StateType ThreadPlanStepRange::GetPlanRunState() {
436 if (m_next_branch_bp_sp)
437 return eStateRunning;
438 else
439 return eStateStepping;
440 }
441
MischiefManaged()442 bool ThreadPlanStepRange::MischiefManaged() {
443 // If we have pushed some plans between ShouldStop & MischiefManaged, then
444 // we're not done...
445 // I do this check first because we might have stepped somewhere that will
446 // fool InRange into
447 // thinking it needs to step past the end of that line. This happens, for
448 // instance, when stepping over inlined code that is in the middle of the
449 // current line.
450
451 if (!m_no_more_plans)
452 return false;
453
454 bool done = true;
455 if (!IsPlanComplete()) {
456 if (InRange()) {
457 done = false;
458 } else {
459 FrameComparison frame_order = CompareCurrentFrameToStartFrame();
460 done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true;
461 }
462 }
463
464 if (done) {
465 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
466 LLDB_LOGF(log, "Completed step through range plan.");
467 ClearNextBranchBreakpoint();
468 ThreadPlan::MischiefManaged();
469 return true;
470 } else {
471 return false;
472 }
473 }
474
IsPlanStale()475 bool ThreadPlanStepRange::IsPlanStale() {
476 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
477 FrameComparison frame_order = CompareCurrentFrameToStartFrame();
478
479 if (frame_order == eFrameCompareOlder) {
480 if (log) {
481 LLDB_LOGF(log, "ThreadPlanStepRange::IsPlanStale returning true, we've "
482 "stepped out.");
483 }
484 return true;
485 } else if (frame_order == eFrameCompareEqual && InSymbol()) {
486 // If we are not in a place we should step through, we've gotten stale. One
487 // tricky bit here is that some stubs don't push a frame, so we should.
488 // check that we are in the same symbol.
489 if (!InRange()) {
490 // Set plan Complete when we reach next instruction just after the range
491 lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
492 size_t num_ranges = m_address_ranges.size();
493 for (size_t i = 0; i < num_ranges; i++) {
494 bool in_range = m_address_ranges[i].ContainsLoadAddress(
495 addr, m_thread.CalculateTarget().get());
496 if (in_range) {
497 SetPlanComplete();
498 }
499 }
500 return true;
501 }
502 }
503 return false;
504 }
505