1 //===-- ThreadPlanStepRange.cpp ---------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Target/ThreadPlanStepRange.h"
14 // Other libraries and framework includes
17 #include "lldb/lldb-private-log.h"
18 #include "lldb/Breakpoint/BreakpointLocation.h"
19 #include "lldb/Breakpoint/BreakpointSite.h"
20 #include "lldb/Core/Disassembler.h"
21 #include "lldb/Core/Log.h"
22 #include "lldb/Core/Stream.h"
23 #include "lldb/Symbol/Function.h"
24 #include "lldb/Symbol/Symbol.h"
25 #include "lldb/Target/ExecutionContext.h"
26 #include "lldb/Target/Process.h"
27 #include "lldb/Target/RegisterContext.h"
28 #include "lldb/Target/StopInfo.h"
29 #include "lldb/Target/Target.h"
30 #include "lldb/Target/Thread.h"
31 #include "lldb/Target/ThreadPlanRunToAddress.h"
34 using namespace lldb_private;
37 //----------------------------------------------------------------------
38 // ThreadPlanStepRange: Step through a stack range, either stepping over or into
39 // based on the value of \a type.
40 //----------------------------------------------------------------------
42 ThreadPlanStepRange::ThreadPlanStepRange (ThreadPlanKind kind,
45 const AddressRange &range,
46 const SymbolContext &addr_context,
47 lldb::RunMode stop_others) :
48 ThreadPlan (kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
49 m_addr_context (addr_context),
51 m_stop_others (stop_others),
53 m_no_more_plans (false),
54 m_first_run_event (true),
55 m_use_fast_step(false)
57 m_use_fast_step = GetTarget().GetUseFastStepping();
59 m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
62 ThreadPlanStepRange::~ThreadPlanStepRange ()
64 ClearNextBranchBreakpoint();
66 size_t num_instruction_ranges = m_instruction_ranges.size();
68 // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions.
69 // I'll fix that but for now, just clear the list and it will go away nicely.
70 for (size_t i = 0; i < num_instruction_ranges; i++)
72 if (m_instruction_ranges[i])
73 m_instruction_ranges[i]->GetInstructionList().Clear();
78 ThreadPlanStepRange::DidPush ()
80 // See if we can find a "next range" breakpoint:
81 SetNextBranchBreakpoint();
85 ThreadPlanStepRange::ValidatePlan (Stream *error)
91 ThreadPlanStepRange::ShouldReportStop (Event *event_ptr)
93 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
95 const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
97 log->Printf ("ThreadPlanStepRange::ShouldReportStop() returning vote %i\n", vote);
102 ThreadPlanStepRange::AddRange(const AddressRange &new_range)
104 // For now I'm just adding the ranges. At some point we may want to
105 // condense the ranges if they overlap, though I don't think it is likely
106 // to be very important.
107 m_address_ranges.push_back (new_range);
109 // Fill the slot for this address range with an empty DisassemblerSP in the instruction ranges. I want the
110 // indices to match, but I don't want to do the work to disassemble this range if I don't step into it.
111 m_instruction_ranges.push_back (DisassemblerSP());
115 ThreadPlanStepRange::DumpRanges(Stream *s)
117 size_t num_ranges = m_address_ranges.size();
120 m_address_ranges[0].Dump (s, m_thread.CalculateTarget().get(), Address::DumpStyleLoadAddress);
124 for (size_t i = 0; i < num_ranges; i++)
126 s->PutCString("%d: ");
127 m_address_ranges[i].Dump (s, m_thread.CalculateTarget().get(), Address::DumpStyleLoadAddress);
133 ThreadPlanStepRange::InRange ()
135 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
136 bool ret_value = false;
138 lldb::addr_t pc_load_addr = m_thread.GetRegisterContext()->GetPC();
140 size_t num_ranges = m_address_ranges.size();
141 for (size_t i = 0; i < num_ranges; i++)
143 ret_value = m_address_ranges[i].ContainsLoadAddress(pc_load_addr, m_thread.CalculateTarget().get());
150 // See if we've just stepped to another part of the same line number...
151 StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
153 SymbolContext new_context(frame->GetSymbolContext(eSymbolContextEverything));
154 if (m_addr_context.line_entry.IsValid() && new_context.line_entry.IsValid())
156 if (m_addr_context.line_entry.file == new_context.line_entry.file)
158 if (m_addr_context.line_entry.line == new_context.line_entry.line)
160 m_addr_context = new_context;
161 AddRange(m_addr_context.line_entry.range);
166 m_addr_context.line_entry.Dump (&s,
167 m_thread.CalculateTarget().get(),
169 Address::DumpStyleLoadAddress,
170 Address::DumpStyleLoadAddress,
173 log->Printf ("Step range plan stepped to another range of same line: %s", s.GetData());
176 else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(m_thread.CalculateTarget().get())
179 // Another thing that sometimes happens here is that we step out of one line into the MIDDLE of another
180 // line. So far I mostly see this due to bugs in the debug information.
181 // But we probably don't want to be in the middle of a line range, so in that case reset the stepping
182 // range to the line we've stepped into the middle of and continue.
183 m_addr_context = new_context;
184 m_address_ranges.clear();
185 AddRange(m_addr_context.line_entry.range);
190 m_addr_context.line_entry.Dump (&s,
191 m_thread.CalculateTarget().get(),
193 Address::DumpStyleLoadAddress,
194 Address::DumpStyleLoadAddress,
197 log->Printf ("Step range plan stepped to the middle of new line(%d): %s, continuing to clear this line.",
198 new_context.line_entry.line,
209 if (!ret_value && log)
210 log->Printf ("Step range plan out of range to 0x%" PRIx64, pc_load_addr);
216 ThreadPlanStepRange::InSymbol()
218 lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
219 if (m_addr_context.function != NULL)
221 return m_addr_context.function->GetAddressRange().ContainsLoadAddress (cur_pc, m_thread.CalculateTarget().get());
223 else if (m_addr_context.symbol)
225 AddressRange range(m_addr_context.symbol->GetAddress(), m_addr_context.symbol->GetByteSize());
226 return range.ContainsLoadAddress (cur_pc, m_thread.CalculateTarget().get());
231 // FIXME: This should also handle inlining if we aren't going to do inlining in the
234 // Ideally we should remember the whole stack frame list, and then compare that
235 // to the current list.
237 lldb::FrameComparison
238 ThreadPlanStepRange::CompareCurrentFrameToStartFrame()
240 FrameComparison frame_order;
242 StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
244 if (cur_frame_id == m_stack_id)
246 frame_order = eFrameCompareEqual;
248 else if (cur_frame_id < m_stack_id)
250 frame_order = eFrameCompareYounger;
254 frame_order = eFrameCompareOlder;
260 ThreadPlanStepRange::StopOthers ()
262 if (m_stop_others == lldb::eOnlyThisThread
263 || m_stop_others == lldb::eOnlyDuringStepping)
270 ThreadPlanStepRange::GetInstructionsForAddress(lldb::addr_t addr, size_t &range_index, size_t &insn_offset)
272 size_t num_ranges = m_address_ranges.size();
273 for (size_t i = 0; i < num_ranges; i++)
275 if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget()))
277 // Some joker added a zero size range to the stepping range...
278 if (m_address_ranges[i].GetByteSize() == 0)
281 if (!m_instruction_ranges[i])
283 //Disassemble the address range given:
284 ExecutionContext exe_ctx (m_thread.GetProcess());
285 const char *plugin_name = NULL;
286 const char *flavor = NULL;
287 m_instruction_ranges[i] = Disassembler::DisassembleRange(GetTarget().GetArchitecture(),
291 m_address_ranges[i]);
294 if (!m_instruction_ranges[i])
298 // Find where we are in the instruction list as well. If we aren't at an instruction,
299 // return NULL. In this case, we're probably lost, and shouldn't try to do anything fancy.
301 insn_offset = m_instruction_ranges[i]->GetInstructionList().GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
302 if (insn_offset == UINT32_MAX)
307 return &m_instruction_ranges[i]->GetInstructionList();
316 ThreadPlanStepRange::ClearNextBranchBreakpoint()
318 if (m_next_branch_bp_sp)
320 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
322 log->Printf ("Removing next branch breakpoint: %d.", m_next_branch_bp_sp->GetID());
323 GetTarget().RemoveBreakpointByID (m_next_branch_bp_sp->GetID());
324 m_next_branch_bp_sp.reset();
329 ThreadPlanStepRange::SetNextBranchBreakpoint ()
331 if (m_next_branch_bp_sp)
334 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
335 // Stepping through ranges using breakpoints doesn't work yet, but with this off we fall back to instruction
337 if (!m_use_fast_step)
340 lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
341 // Find the current address in our address ranges, and fetch the disassembly if we haven't already:
344 InstructionList *instructions = GetInstructionsForAddress (cur_addr, range_index, pc_index);
345 if (instructions == NULL)
349 uint32_t branch_index;
350 branch_index = instructions->GetIndexOfNextBranchInstruction (pc_index);
352 Address run_to_address;
354 // If we didn't find a branch, run to the end of the range.
355 if (branch_index == UINT32_MAX)
357 branch_index = instructions->GetSize() - 1;
360 if (branch_index - pc_index > 1)
362 const bool is_internal = true;
363 run_to_address = instructions->GetInstructionAtIndex(branch_index)->GetAddress();
364 m_next_branch_bp_sp = GetTarget().CreateBreakpoint(run_to_address, is_internal);
365 if (m_next_branch_bp_sp)
369 lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID;
370 BreakpointLocationSP bp_loc = m_next_branch_bp_sp->GetLocationAtIndex(0);
373 BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
376 bp_site_id = bp_site->GetID();
379 log->Printf ("ThreadPlanStepRange::SetNextBranchBreakpoint - Setting breakpoint %d (site %d) to run to address 0x%" PRIx64,
380 m_next_branch_bp_sp->GetID(),
382 run_to_address.GetLoadAddress(&m_thread.GetProcess()->GetTarget()));
384 m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
385 m_next_branch_bp_sp->SetBreakpointKind ("next-branch-location");
396 ThreadPlanStepRange::NextRangeBreakpointExplainsStop (lldb::StopInfoSP stop_info_sp)
398 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
399 if (!m_next_branch_bp_sp)
402 break_id_t bp_site_id = stop_info_sp->GetValue();
403 BreakpointSiteSP bp_site_sp = m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
406 else if (!bp_site_sp->IsBreakpointAtThisSite (m_next_branch_bp_sp->GetID()))
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 this range from multiple threads,
414 // or multiple frames, so we want to continue. If one is not internal, then we should not explain the stop,
415 // and let the user breakpoint handle the stop.
416 for (size_t i = 0; i < num_owners; i++)
418 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal())
420 explains_stop = false;
425 log->Printf ("ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit next range breakpoint which has %zu owners - explains stop: %u.",
428 ClearNextBranchBreakpoint();
429 return explains_stop;
434 ThreadPlanStepRange::WillStop ()
440 ThreadPlanStepRange::GetPlanRunState ()
442 if (m_next_branch_bp_sp)
443 return eStateRunning;
445 return eStateStepping;
449 ThreadPlanStepRange::MischiefManaged ()
451 // If we have pushed some plans between ShouldStop & MischiefManaged, then we're not done...
452 // I do this check first because we might have stepped somewhere that will fool InRange into
453 // thinking it needs to step past the end of that line. This happens, for instance, when stepping
454 // over inlined code that is in the middle of the current line.
456 if (!m_no_more_plans)
460 if (!IsPlanComplete())
468 FrameComparison frame_order = CompareCurrentFrameToStartFrame();
469 if (frame_order != eFrameCompareOlder)
483 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
485 log->Printf("Completed step through range plan.");
486 ClearNextBranchBreakpoint();
487 ThreadPlan::MischiefManaged ();
498 ThreadPlanStepRange::IsPlanStale ()
500 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
501 FrameComparison frame_order = CompareCurrentFrameToStartFrame();
503 if (frame_order == eFrameCompareOlder)
507 log->Printf("ThreadPlanStepRange::IsPlanStale returning true, we've stepped out.");
511 else if (frame_order == eFrameCompareEqual && InSymbol())
513 // If we are not in a place we should step through, we've gotten stale.
514 // One tricky bit here is that some stubs don't push a frame, so we should.
515 // check that we are in the same symbol.