LLDB mainline
ThreadPlanStepRange.cpp
Go to the documentation of this file.
1//===-- ThreadPlanStepRange.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
14#include "lldb/Symbol/Symbol.h"
16#include "lldb/Target/Process.h"
19#include "lldb/Target/Target.h"
20#include "lldb/Target/Thread.h"
23#include "lldb/Utility/Log.h"
24#include "lldb/Utility/Stream.h"
25
26using namespace lldb;
27using namespace lldb_private;
28
29// ThreadPlanStepRange: Step through a stack range, either stepping over or
30// into based on the value of \a type.
31
33 Thread &thread,
34 const AddressRange &range,
35 const SymbolContext &addr_context,
36 lldb::RunMode stop_others,
37 bool given_ranges_only)
38 : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
39 m_addr_context(addr_context), m_address_ranges(),
40 m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
41 m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
42 m_given_ranges_only(given_ranges_only) {
44 AddRange(range);
45 m_stack_id = thread.GetStackFrameAtIndex(0)->GetStackID();
46 StackFrameSP parent_stack = thread.GetStackFrameAtIndex(1);
47 if (parent_stack)
48 m_parent_stack_id = parent_stack->GetStackID();
49}
50
52
54 // See if we can find a "next range" breakpoint:
56}
57
60 if (error)
61 error->PutCString(
62 "Could not create hardware breakpoint for thread plan.");
63 return false;
64 }
65 return true;
66}
67
69 Log *log = GetLog(LLDBLog::Step);
70
71 const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
72 LLDB_LOGF(log, "ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
73 vote);
74 return vote;
75}
76
78 // For now I'm just adding the ranges. At some point we may want to condense
79 // the ranges if they overlap, though I don't think it is likely to be very
80 // important.
81 m_address_ranges.push_back(new_range);
82
83 // Fill the slot for this address range with an empty DisassemblerSP in the
84 // instruction ranges. I want the indices to match, but I don't want to do
85 // the work to disassemble this range if I don't step into it.
87}
88
90 size_t num_ranges = m_address_ranges.size();
91 if (num_ranges == 1) {
93 } else {
94 for (size_t i = 0; i < num_ranges; i++) {
95 s->Printf(" %" PRIu64 ": ", uint64_t(i));
97 }
98 }
99}
100
102 Log *log = GetLog(LLDBLog::Step);
103 bool ret_value = false;
104 Thread &thread = GetThread();
105 lldb::addr_t pc_load_addr = thread.GetRegisterContext()->GetPC();
106
107 size_t num_ranges = m_address_ranges.size();
108 for (size_t i = 0; i < num_ranges; i++) {
109 ret_value =
110 m_address_ranges[i].ContainsLoadAddress(pc_load_addr, &GetTarget());
111 if (ret_value)
112 break;
113 }
114
115 if (!ret_value && !m_given_ranges_only) {
116 // See if we've just stepped to another part of the same line number...
117 StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
118
119 SymbolContext new_context(
120 frame->GetSymbolContext(eSymbolContextEverything));
122 new_context.line_entry.IsValid()) {
124 *new_context.line_entry.original_file_sp) {
125 if (m_addr_context.line_entry.line == new_context.line_entry.line) {
126 m_addr_context = new_context;
127 const bool include_inlined_functions =
130 include_inlined_functions));
131 ret_value = true;
132 if (log) {
133 StreamString s;
137
138 LLDB_LOGF(
139 log,
140 "Step range plan stepped to another range of same line: %s",
141 s.GetData());
142 }
143 } else if (new_context.line_entry.line == 0) {
145 m_addr_context = new_context;
146 const bool include_inlined_functions =
149 include_inlined_functions));
150 ret_value = true;
151 if (log) {
152 StreamString s;
156
157 LLDB_LOGF(log,
158 "Step range plan stepped to a range at linenumber 0 "
159 "stepping through that range: %s",
160 s.GetData());
161 }
162 } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
163 &GetTarget()) != pc_load_addr) {
164 // Another thing that sometimes happens here is that we step out of
165 // one line into the MIDDLE of another line. So far I mostly see
166 // this due to bugs in the debug information. But we probably don't
167 // want to be in the middle of a line range, so in that case reset
168 // the stepping range to the line we've stepped into the middle of
169 // and continue.
170 m_addr_context = new_context;
171 m_address_ranges.clear();
173 ret_value = true;
174 if (log) {
175 StreamString s;
179
180 LLDB_LOGF(log,
181 "Step range plan stepped to the middle of new "
182 "line(%d): %s, continuing to clear this line.",
183 new_context.line_entry.line, s.GetData());
184 }
185 }
186 }
187 }
188 }
189
190 if (!ret_value && log)
191 LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr);
192
193 return ret_value;
194}
195
197 lldb::addr_t cur_pc = GetThread().GetRegisterContext()->GetPC();
198 if (m_addr_context.function != nullptr) {
200 cur_pc, &GetTarget());
204 return range.ContainsLoadAddress(cur_pc, &GetTarget());
205 }
206 return false;
207}
208
209// FIXME: This should also handle inlining if we aren't going to do inlining in
210// the
211// main stack.
212//
213// Ideally we should remember the whole stack frame list, and then compare that
214// to the current list.
215
217 FrameComparison frame_order;
218 Thread &thread = GetThread();
219 StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
220
221 if (cur_frame_id == m_stack_id) {
222 frame_order = eFrameCompareEqual;
223 } else if (cur_frame_id < m_stack_id) {
224 frame_order = eFrameCompareYounger;
225 } else {
226 StackFrameSP cur_parent_frame = thread.GetStackFrameAtIndex(1);
227 StackID cur_parent_id;
228 if (cur_parent_frame)
229 cur_parent_id = cur_parent_frame->GetStackID();
230 if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
231 m_parent_stack_id == cur_parent_id)
232 frame_order = eFrameCompareSameParent;
233 else
234 frame_order = eFrameCompareOlder;
235 }
236 return frame_order;
237}
238
240 switch (m_stop_others) {
242 return true;
244 // If there is a call in the range of the next branch breakpoint,
245 // then we should always run all threads, since a call can execute
246 // arbitrary code which might for instance take a lock that's held
247 // by another thread.
248 return !m_found_calls;
250 return false;
251 }
252 llvm_unreachable("Unhandled run mode!");
253}
254
256 lldb::addr_t addr, size_t &range_index, size_t &insn_offset) {
257 size_t num_ranges = m_address_ranges.size();
258 for (size_t i = 0; i < num_ranges; i++) {
259 if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
260 // Some joker added a zero size range to the stepping range...
261 if (m_address_ranges[i].GetByteSize() == 0)
262 return nullptr;
263
264 if (!m_instruction_ranges[i]) {
265 // Disassemble the address range given:
266 const char *plugin_name = nullptr;
267 const char *flavor = nullptr;
269 GetTarget().GetArchitecture(), plugin_name, flavor, GetTarget(),
271 }
272 if (!m_instruction_ranges[i])
273 return nullptr;
274 else {
275 // Find where we are in the instruction list as well. If we aren't at
276 // an instruction, return nullptr. In this case, we're probably lost,
277 // and shouldn't try to do anything fancy.
278
279 insn_offset =
281 ->GetInstructionList()
282 .GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
283 if (insn_offset == UINT32_MAX)
284 return nullptr;
285 else {
286 range_index = i;
287 return &m_instruction_ranges[i]->GetInstructionList();
288 }
289 }
290 }
291 }
292 return nullptr;
293}
294
297 Log *log = GetLog(LLDBLog::Step);
298 LLDB_LOGF(log, "Removing next branch breakpoint: %d.",
299 m_next_branch_bp_sp->GetID());
301 m_next_branch_bp_sp.reset();
303 m_found_calls = false;
304 }
305}
306
309 return true;
310
311 Log *log = GetLog(LLDBLog::Step);
312 // Stepping through ranges using breakpoints doesn't work yet, but with this
313 // off we fall back to instruction single stepping.
314 if (!m_use_fast_step)
315 return false;
316
317 // clear the m_found_calls, we'll rediscover it for this range.
318 m_found_calls = false;
319
320 lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
321 // Find the current address in our address ranges, and fetch the disassembly
322 // if we haven't already:
323 size_t pc_index;
324 size_t range_index;
325 InstructionList *instructions =
326 GetInstructionsForAddress(cur_addr, range_index, pc_index);
327 if (instructions == nullptr)
328 return false;
329 else {
330 const bool ignore_calls = GetKind() == eKindStepOverRange;
331 uint32_t branch_index = instructions->GetIndexOfNextBranchInstruction(
332 pc_index, ignore_calls, &m_found_calls);
333 Address run_to_address;
334
335 // If we didn't find a branch, run to the end of the range.
336 if (branch_index == UINT32_MAX) {
337 uint32_t last_index = instructions->GetSize() - 1;
338 if (last_index - pc_index > 1) {
339 InstructionSP last_inst =
340 instructions->GetInstructionAtIndex(last_index);
341 size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
342 run_to_address = last_inst->GetAddress();
343 run_to_address.Slide(last_inst_size);
344 }
345 } else if (branch_index - pc_index > 1) {
346 run_to_address =
347 instructions->GetInstructionAtIndex(branch_index)->GetAddress();
348 }
349
350 if (run_to_address.IsValid()) {
351 const bool is_internal = true;
353 GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
355
356 if (m_next_branch_bp_sp->IsHardware() &&
357 !m_next_branch_bp_sp->HasResolvedLocations())
359
360 if (log) {
362 BreakpointLocationSP bp_loc =
363 m_next_branch_bp_sp->GetLocationAtIndex(0);
364 if (bp_loc) {
365 BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
366 if (bp_site) {
367 bp_site_id = bp_site->GetID();
368 }
369 }
370 LLDB_LOGF(log,
371 "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
372 "breakpoint %d (site %d) to run to address 0x%" PRIx64,
373 m_next_branch_bp_sp->GetID(), bp_site_id,
374 run_to_address.GetLoadAddress(&m_process.GetTarget()));
375 }
376
377 m_next_branch_bp_sp->SetThreadID(m_tid);
378 m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
379
380 return true;
381 } else
382 return false;
383 }
384 }
385 return false;
386}
387
389 lldb::StopInfoSP stop_info_sp) {
390 Log *log = GetLog(LLDBLog::Step);
392 return false;
393
394 break_id_t bp_site_id = stop_info_sp->GetValue();
395 BreakpointSiteSP bp_site_sp =
397 if (!bp_site_sp)
398 return false;
399 else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
400 return false;
401 else {
402 // If we've hit the next branch breakpoint, then clear it.
403 size_t num_constituents = bp_site_sp->GetNumberOfConstituents();
404 bool explains_stop = true;
405 // If all the constituents are internal, then we are probably just stepping
406 // over this range from multiple threads, or multiple frames, so we want to
407 // continue. If one is not internal, then we should not explain the stop,
408 // and let the user breakpoint handle the stop.
409 for (size_t i = 0; i < num_constituents; i++) {
410 if (!bp_site_sp->GetConstituentAtIndex(i)->GetBreakpoint().IsInternal()) {
411 explains_stop = false;
412 break;
413 }
414 }
415 LLDB_LOGF(log,
416 "ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit "
417 "next range breakpoint which has %" PRIu64
418 " constituents - explains stop: %u.",
419 (uint64_t)num_constituents, explains_stop);
421 return explains_stop;
422 }
423}
424
425bool ThreadPlanStepRange::WillStop() { return true; }
426
429 return eStateRunning;
430 else
431 return eStateStepping;
432}
433
435 // If we have pushed some plans between ShouldStop & MischiefManaged, then
436 // we're not done...
437 // I do this check first because we might have stepped somewhere that will
438 // fool InRange into
439 // thinking it needs to step past the end of that line. This happens, for
440 // instance, when stepping over inlined code that is in the middle of the
441 // current line.
442
443 if (!m_no_more_plans)
444 return false;
445
446 bool done = true;
447 if (!IsPlanComplete()) {
448 if (InRange()) {
449 done = false;
450 } else {
452 done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true;
453 }
454 }
455
456 if (done) {
457 Log *log = GetLog(LLDBLog::Step);
458 LLDB_LOGF(log, "Completed step through range plan.");
461 return true;
462 } else {
463 return false;
464 }
465}
466
468 Log *log = GetLog(LLDBLog::Step);
470
471 if (frame_order == eFrameCompareOlder) {
472 if (log) {
473 LLDB_LOGF(log, "ThreadPlanStepRange::IsPlanStale returning true, we've "
474 "stepped out.");
475 }
476 return true;
477 } else if (frame_order == eFrameCompareEqual && InSymbol()) {
478 // If we are not in a place we should step through, we've gotten stale. One
479 // tricky bit here is that some stubs don't push a frame, so we should.
480 // check that we are in the same symbol.
481 if (!InRange()) {
482 // Set plan Complete when we reach next instruction just after the range
483 lldb::addr_t addr = GetThread().GetRegisterContext()->GetPC() - 1;
484 size_t num_ranges = m_address_ranges.size();
485 for (size_t i = 0; i < num_ranges; i++) {
486 bool in_range =
487 m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget());
488 if (in_range) {
490 }
491 }
492 return true;
493 }
494 }
495 return false;
496}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:366
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:211
bool ContainsLoadAddress(const Address &so_addr, Target *target) const
Check if a section offset so_addr when represented as a load address is contained within this object'...
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:99
bool Slide(int64_t offset)
Definition: Address.h:459
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
const AddressRange & GetAddressRange()
Definition: Function.h:447
lldb::InstructionSP GetInstructionAtIndex(size_t idx) const
uint32_t GetIndexOfNextBranchInstruction(uint32_t start, bool ignore_calls, bool *found_calls) const
Get the index of the next branch instruction.
StopPointSiteList< lldb_private::BreakpointSite > & GetBreakpointSiteList()
Definition: Process.cpp:1576
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1277
This base class provides an interface to stack frames.
Definition: StackFrame.h:43
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
bool IsValid() const
Definition: StackID.h:47
StopPointSiteSP FindByID(typename StopPointSite::SiteID site_id)
Returns a shared pointer to the site with id site_id.
const char * GetData() const
Definition: StreamString.h:43
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
Function * function
The Function for a given query.
Symbol * symbol
The Symbol for a given query.
LineEntry line_entry
The LineEntry for a given query.
bool ValueIsAddress() const
Definition: Symbol.cpp:165
Address & GetAddressRef()
Definition: Symbol.h:72
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:468
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:1004
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:395
bool NextRangeBreakpointExplainsStop(lldb::StopInfoSP stop_info_sp)
Vote ShouldReportStop(Event *event_ptr) override
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
lldb::FrameComparison CompareCurrentFrameToStartFrame()
ThreadPlanStepRange(ThreadPlanKind kind, const char *name, Thread &thread, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_others, bool given_ranges_only=false)
InstructionList * GetInstructionsForAddress(lldb::addr_t addr, size_t &range_index, size_t &insn_offset)
std::vector< lldb::DisassemblerSP > m_instruction_ranges
lldb::StateType GetPlanRunState() override
std::vector< AddressRange > m_address_ranges
void AddRange(const AddressRange &new_range)
ThreadPlanKind GetKind() const
Definition: ThreadPlan.h:425
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:72
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:405
virtual lldb::RegisterContextSP GetRegisterContext()=0
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:415
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
Definition: lldb-forward.h:318
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
Definition: lldb-forward.h:319
FrameComparison
This is the return value for frame comparisons.
@ eFrameCompareSameParent
@ eFrameCompareEqual
@ eFrameCompareOlder
@ eFrameCompareYounger
StateType
Process and Thread States.
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
std::shared_ptr< lldb_private::Instruction > InstructionSP
Definition: lldb-forward.h:353
int32_t break_id_t
Definition: lldb-types.h:86
std::shared_ptr< lldb_private::Disassembler > DisassemblerSP
Definition: lldb-forward.h:336
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:422
uint64_t addr_t
Definition: lldb-types.h:80
RunMode
Thread Run Modes.
@ eOnlyDuringStepping
bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_range) const
Dump a description of this object to a Stream.
Definition: LineEntry.cpp:60
lldb::SupportFileSP original_file_sp
The original source file, from debug info.
Definition: LineEntry.h:143
AddressRange GetSameLineContiguousAddressRange(bool include_inlined_functions) const
Give the range for this LineEntry + any additional LineEntries for this same source line that are con...
Definition: LineEntry.cpp:182
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:35
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:137
uint32_t line
The source line number, or LLDB_INVALID_LINE_NUMBER if there is no line number information.
Definition: LineEntry.h:147