OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Target/ThreadPlanStepRange.cpp

479 lines
18 KiB
C++
Raw Blame History

//===-- ThreadPlanStepRange.cpp ---------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// ThreadPlanStepRange: Step through a stack range, either stepping over or into
// based on the value of \a type.
//----------------------------------------------------------------------
ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
Thread &thread,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_others,
bool given_ranges_only)
: ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
m_addr_context(addr_context), m_address_ranges(),
m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
m_given_ranges_only(given_ranges_only) {
m_use_fast_step = GetTarget().GetUseFastStepping();
AddRange(range);
m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
StackFrameSP parent_stack = m_thread.GetStackFrameAtIndex(1);
if (parent_stack)
m_parent_stack_id = parent_stack->GetStackID();
}
ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); }
void ThreadPlanStepRange::DidPush() {
// See if we can find a "next range" breakpoint:
SetNextBranchBreakpoint();
}
bool ThreadPlanStepRange::ValidatePlan(Stream *error) { return true; }
Vote ThreadPlanStepRange::ShouldReportStop(Event *event_ptr) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
if (log)
log->Printf("ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
vote);
return vote;
}
void ThreadPlanStepRange::AddRange(const AddressRange &new_range) {
// For now I'm just adding the ranges. At some point we may want to
// condense the ranges if they overlap, though I don't think it is likely
// to be very important.
m_address_ranges.push_back(new_range);
// Fill the slot for this address range with an empty DisassemblerSP in the
// instruction ranges. I want the
// indices to match, but I don't want to do the work to disassemble this range
// if I don't step into it.
m_instruction_ranges.push_back(DisassemblerSP());
}
void ThreadPlanStepRange::DumpRanges(Stream *s) {
size_t num_ranges = m_address_ranges.size();
if (num_ranges == 1) {
m_address_ranges[0].Dump(s, m_thread.CalculateTarget().get(),
Address::DumpStyleLoadAddress);
} else {
for (size_t i = 0; i < num_ranges; i++) {
s->Printf(" %" PRIu64 ": ", uint64_t(i));
m_address_ranges[i].Dump(s, m_thread.CalculateTarget().get(),
Address::DumpStyleLoadAddress);
}
}
}
bool ThreadPlanStepRange::InRange() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
bool ret_value = false;
lldb::addr_t pc_load_addr = m_thread.GetRegisterContext()->GetPC();
size_t num_ranges = m_address_ranges.size();
for (size_t i = 0; i < num_ranges; i++) {
ret_value = m_address_ranges[i].ContainsLoadAddress(
pc_load_addr, m_thread.CalculateTarget().get());
if (ret_value)
break;
}
if (!ret_value && !m_given_ranges_only) {
// See if we've just stepped to another part of the same line number...
StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
SymbolContext new_context(
frame->GetSymbolContext(eSymbolContextEverything));
if (m_addr_context.line_entry.IsValid() &&
new_context.line_entry.IsValid()) {
if (m_addr_context.line_entry.original_file ==
new_context.line_entry.original_file) {
if (m_addr_context.line_entry.line == new_context.line_entry.line) {
m_addr_context = new_context;
AddRange(
m_addr_context.line_entry.GetSameLineContiguousAddressRange());
ret_value = true;
if (log) {
StreamString s;
m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
true, Address::DumpStyleLoadAddress,
Address::DumpStyleLoadAddress, true);
log->Printf(
"Step range plan stepped to another range of same line: %s",
s.GetData());
}
} else if (new_context.line_entry.line == 0) {
new_context.line_entry.line = m_addr_context.line_entry.line;
m_addr_context = new_context;
AddRange(
m_addr_context.line_entry.GetSameLineContiguousAddressRange());
ret_value = true;
if (log) {
StreamString s;
m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
true, Address::DumpStyleLoadAddress,
Address::DumpStyleLoadAddress, true);
log->Printf("Step range plan stepped to a range at linenumber 0 "
"stepping through that range: %s",
s.GetData());
}
} else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
m_thread.CalculateTarget().get()) != pc_load_addr) {
// Another thing that sometimes happens here is that we step out of
// one line into the MIDDLE of another
// line. So far I mostly see this due to bugs in the debug
// information.
// But we probably don't want to be in the middle of a line range, so
// in that case reset the stepping
// range to the line we've stepped into the middle of and continue.
m_addr_context = new_context;
m_address_ranges.clear();
AddRange(m_addr_context.line_entry.range);
ret_value = true;
if (log) {
StreamString s;
m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
true, Address::DumpStyleLoadAddress,
Address::DumpStyleLoadAddress, true);
log->Printf("Step range plan stepped to the middle of new "
"line(%d): %s, continuing to clear this line.",
new_context.line_entry.line, s.GetData());
}
}
}
}
}
if (!ret_value && log)
log->Printf("Step range plan out of range to 0x%" PRIx64, pc_load_addr);
return ret_value;
}
bool ThreadPlanStepRange::InSymbol() {
lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
if (m_addr_context.function != nullptr) {
return m_addr_context.function->GetAddressRange().ContainsLoadAddress(
cur_pc, m_thread.CalculateTarget().get());
} else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) {
AddressRange range(m_addr_context.symbol->GetAddressRef(),
m_addr_context.symbol->GetByteSize());
return range.ContainsLoadAddress(cur_pc, m_thread.CalculateTarget().get());
}
return false;
}
// FIXME: This should also handle inlining if we aren't going to do inlining in
// the
// main stack.
//
// Ideally we should remember the whole stack frame list, and then compare that
// to the current list.
lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() {
FrameComparison frame_order;
StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
if (cur_frame_id == m_stack_id) {
frame_order = eFrameCompareEqual;
} else if (cur_frame_id < m_stack_id) {
frame_order = eFrameCompareYounger;
} else {
StackFrameSP cur_parent_frame = m_thread.GetStackFrameAtIndex(1);
StackID cur_parent_id;
if (cur_parent_frame)
cur_parent_id = cur_parent_frame->GetStackID();
if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
m_parent_stack_id == cur_parent_id)
frame_order = eFrameCompareSameParent;
else
frame_order = eFrameCompareOlder;
}
return frame_order;
}
bool ThreadPlanStepRange::StopOthers() {
return (m_stop_others == lldb::eOnlyThisThread ||
m_stop_others == lldb::eOnlyDuringStepping);
}
InstructionList *ThreadPlanStepRange::GetInstructionsForAddress(
lldb::addr_t addr, size_t &range_index, size_t &insn_offset) {
size_t num_ranges = m_address_ranges.size();
for (size_t i = 0; i < num_ranges; i++) {
if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
// Some joker added a zero size range to the stepping range...
if (m_address_ranges[i].GetByteSize() == 0)
return nullptr;
if (!m_instruction_ranges[i]) {
// Disassemble the address range given:
ExecutionContext exe_ctx(m_thread.GetProcess());
const char *plugin_name = nullptr;
const char *flavor = nullptr;
const bool prefer_file_cache = true;
m_instruction_ranges[i] = Disassembler::DisassembleRange(
GetTarget().GetArchitecture(), plugin_name, flavor, exe_ctx,
m_address_ranges[i], prefer_file_cache);
}
if (!m_instruction_ranges[i])
return nullptr;
else {
// Find where we are in the instruction list as well. If we aren't at
// an instruction,
// return nullptr. In this case, we're probably lost, and shouldn't try
// to do anything fancy.
insn_offset =
m_instruction_ranges[i]
->GetInstructionList()
.GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
if (insn_offset == UINT32_MAX)
return nullptr;
else {
range_index = i;
return &m_instruction_ranges[i]->GetInstructionList();
}
}
}
}
return nullptr;
}
void ThreadPlanStepRange::ClearNextBranchBreakpoint() {
if (m_next_branch_bp_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (log)
log->Printf("Removing next branch breakpoint: %d.",
m_next_branch_bp_sp->GetID());
GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID());
m_next_branch_bp_sp.reset();
}
}
bool ThreadPlanStepRange::SetNextBranchBreakpoint() {
if (m_next_branch_bp_sp)
return true;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
// Stepping through ranges using breakpoints doesn't work yet, but with this
// off we fall back to instruction
// single stepping.
if (!m_use_fast_step)
return false;
lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
// Find the current address in our address ranges, and fetch the disassembly
// if we haven't already:
size_t pc_index;
size_t range_index;
InstructionList *instructions =
GetInstructionsForAddress(cur_addr, range_index, pc_index);
if (instructions == nullptr)
return false;
else {
Target &target = GetThread().GetProcess()->GetTarget();
uint32_t branch_index;
branch_index =
instructions->GetIndexOfNextBranchInstruction(pc_index, target);
Address run_to_address;
// If we didn't find a branch, run to the end of the range.
if (branch_index == UINT32_MAX) {
uint32_t last_index = instructions->GetSize() - 1;
if (last_index - pc_index > 1) {
InstructionSP last_inst =
instructions->GetInstructionAtIndex(last_index);
size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
run_to_address = last_inst->GetAddress();
run_to_address.Slide(last_inst_size);
}
} else if (branch_index - pc_index > 1) {
run_to_address =
instructions->GetInstructionAtIndex(branch_index)->GetAddress();
}
if (run_to_address.IsValid()) {
const bool is_internal = true;
m_next_branch_bp_sp =
GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
if (m_next_branch_bp_sp) {
if (log) {
lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID;
BreakpointLocationSP bp_loc =
m_next_branch_bp_sp->GetLocationAtIndex(0);
if (bp_loc) {
BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
if (bp_site) {
bp_site_id = bp_site->GetID();
}
}
log->Printf("ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
"breakpoint %d (site %d) to run to address 0x%" PRIx64,
m_next_branch_bp_sp->GetID(), bp_site_id,
run_to_address.GetLoadAddress(
&m_thread.GetProcess()->GetTarget()));
}
m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
return true;
} else
return false;
}
}
return false;
}
bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop(
lldb::StopInfoSP stop_info_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (!m_next_branch_bp_sp)
return false;
break_id_t bp_site_id = stop_info_sp->GetValue();
BreakpointSiteSP bp_site_sp =
m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
if (!bp_site_sp)
return false;
else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
return false;
else {
// If we've hit the next branch breakpoint, then clear it.
size_t num_owners = bp_site_sp->GetNumberOfOwners();
bool explains_stop = true;
// If all the owners are internal, then we are probably just stepping over
// this range from multiple threads,
// or multiple frames, so we want to continue. If one is not internal, then
// we should not explain the stop,
// and let the user breakpoint handle the stop.
for (size_t i = 0; i < num_owners; i++) {
if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
explains_stop = false;
break;
}
}
if (log)
log->Printf("ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit "
"next range breakpoint which has %" PRIu64
" owners - explains stop: %u.",
(uint64_t)num_owners, explains_stop);
ClearNextBranchBreakpoint();
return explains_stop;
}
}
bool ThreadPlanStepRange::WillStop() { return true; }
StateType ThreadPlanStepRange::GetPlanRunState() {
if (m_next_branch_bp_sp)
return eStateRunning;
else
return eStateStepping;
}
bool ThreadPlanStepRange::MischiefManaged() {
// If we have pushed some plans between ShouldStop & MischiefManaged, then
// we're not done...
// I do this check first because we might have stepped somewhere that will
// fool InRange into
// thinking it needs to step past the end of that line. This happens, for
// instance, when stepping
// over inlined code that is in the middle of the current line.
if (!m_no_more_plans)
return false;
bool done = true;
if (!IsPlanComplete()) {
if (InRange()) {
done = false;
} else {
FrameComparison frame_order = CompareCurrentFrameToStartFrame();
done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true;
}
}
if (done) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (log)
log->Printf("Completed step through range plan.");
ClearNextBranchBreakpoint();
ThreadPlan::MischiefManaged();
return true;
} else {
return false;
}
}
bool ThreadPlanStepRange::IsPlanStale() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
FrameComparison frame_order = CompareCurrentFrameToStartFrame();
if (frame_order == eFrameCompareOlder) {
if (log) {
log->Printf("ThreadPlanStepRange::IsPlanStale returning true, we've "
"stepped out.");
}
return true;
} else if (frame_order == eFrameCompareEqual && InSymbol()) {
// If we are not in a place we should step through, we've gotten stale.
// One tricky bit here is that some stubs don't push a frame, so we should.
// check that we are in the same symbol.
if (!InRange()) {
// Set plan Complete when we reach next instruction just after the range
lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
size_t num_ranges = m_address_ranges.size();
for (size_t i = 0; i < num_ranges; i++) {
bool in_range = m_address_ranges[i].ContainsLoadAddress(
addr, m_thread.CalculateTarget().get());
if (in_range) {
SetPlanComplete();
}
}
return true;
}
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink