You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1199 lines
44 KiB
1199 lines
44 KiB
//===-- StopInfo.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <string>
|
|
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Breakpoint/StoppointCallbackContext.h"
|
|
#include "lldb/Breakpoint/Watchpoint.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/ValueObject.h"
|
|
#include "lldb/Expression/UserExpression.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/StopInfo.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/ThreadPlan.h"
|
|
#include "lldb/Target/UnixSignals.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
StopInfo::StopInfo(Thread &thread, uint64_t value)
|
|
: m_thread_wp(thread.shared_from_this()),
|
|
m_stop_id(thread.GetProcess()->GetStopID()),
|
|
m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
|
|
m_description(), m_override_should_notify(eLazyBoolCalculate),
|
|
m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
|
|
|
|
bool StopInfo::IsValid() const {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp)
|
|
return thread_sp->GetProcess()->GetStopID() == m_stop_id;
|
|
return false;
|
|
}
|
|
|
|
void StopInfo::MakeStopInfoValid() {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
m_stop_id = thread_sp->GetProcess()->GetStopID();
|
|
m_resume_id = thread_sp->GetProcess()->GetResumeID();
|
|
}
|
|
}
|
|
|
|
bool StopInfo::HasTargetRunSinceMe() {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
|
lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
|
|
if (ret_type == eStateRunning) {
|
|
return true;
|
|
} else if (ret_type == eStateStopped) {
|
|
// This is a little tricky. We want to count "run and stopped again
|
|
// before you could ask this question as a "TRUE" answer to
|
|
// HasTargetRunSinceMe. But we don't want to include any running of the
|
|
// target done for expressions. So we track both resumes, and resumes
|
|
// caused by expressions, and check if there are any resumes
|
|
// NOT caused
|
|
// by expressions.
|
|
|
|
uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
|
|
uint32_t last_user_expression_id =
|
|
thread_sp->GetProcess()->GetLastUserExpressionResumeID();
|
|
if (curr_resume_id == m_resume_id) {
|
|
return false;
|
|
} else if (curr_resume_id > last_user_expression_id) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// StopInfoBreakpoint
|
|
|
|
namespace lldb_private {
|
|
class StopInfoBreakpoint : public StopInfo {
|
|
public:
|
|
StopInfoBreakpoint(Thread &thread, break_id_t break_id)
|
|
: StopInfo(thread, break_id), m_should_stop(false),
|
|
m_should_stop_is_valid(false), m_should_perform_action(true),
|
|
m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
|
|
m_was_one_shot(false) {
|
|
StoreBPInfo();
|
|
}
|
|
|
|
StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
|
|
: StopInfo(thread, break_id), m_should_stop(should_stop),
|
|
m_should_stop_is_valid(true), m_should_perform_action(true),
|
|
m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
|
|
m_was_one_shot(false) {
|
|
StoreBPInfo();
|
|
}
|
|
|
|
~StopInfoBreakpoint() override = default;
|
|
|
|
void StoreBPInfo() {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
BreakpointSiteSP bp_site_sp(
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
if (bp_site_sp) {
|
|
if (bp_site_sp->GetNumberOfOwners() == 1) {
|
|
BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
|
|
if (bp_loc_sp) {
|
|
m_break_id = bp_loc_sp->GetBreakpoint().GetID();
|
|
m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
|
|
}
|
|
}
|
|
m_address = bp_site_sp->GetLoadAddress();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool IsValidForOperatingSystemThread(Thread &thread) override {
|
|
ProcessSP process_sp(thread.GetProcess());
|
|
if (process_sp) {
|
|
BreakpointSiteSP bp_site_sp(
|
|
process_sp->GetBreakpointSiteList().FindByID(m_value));
|
|
if (bp_site_sp)
|
|
return bp_site_sp->ValidForThisThread(&thread);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
|
|
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
if (!m_should_stop_is_valid) {
|
|
// Only check once if we should stop at a breakpoint
|
|
BreakpointSiteSP bp_site_sp(
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
if (bp_site_sp) {
|
|
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, true);
|
|
bp_site_sp->BumpHitCounts();
|
|
m_should_stop = bp_site_sp->ShouldStop(&context);
|
|
} else {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
LLDB_LOGF(log,
|
|
"Process::%s could not find breakpoint site id: %" PRId64
|
|
"...",
|
|
__FUNCTION__, m_value);
|
|
|
|
m_should_stop = true;
|
|
}
|
|
m_should_stop_is_valid = true;
|
|
}
|
|
return m_should_stop;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DoShouldNotify(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
BreakpointSiteSP bp_site_sp(
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
if (bp_site_sp) {
|
|
bool all_internal = true;
|
|
|
|
for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
|
|
if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
|
|
all_internal = false;
|
|
break;
|
|
}
|
|
}
|
|
return !all_internal;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty()) {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
BreakpointSiteSP bp_site_sp(
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
if (bp_site_sp) {
|
|
StreamString strm;
|
|
// If we have just hit an internal breakpoint, and it has a kind
|
|
// description, print that instead of the full breakpoint printing:
|
|
if (bp_site_sp->IsInternal()) {
|
|
size_t num_owners = bp_site_sp->GetNumberOfOwners();
|
|
for (size_t idx = 0; idx < num_owners; idx++) {
|
|
const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
|
|
->GetBreakpoint()
|
|
.GetBreakpointKind();
|
|
if (kind != nullptr) {
|
|
m_description.assign(kind);
|
|
return kind;
|
|
}
|
|
}
|
|
}
|
|
|
|
strm.Printf("breakpoint ");
|
|
bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
|
|
m_description = std::string(strm.GetString());
|
|
} else {
|
|
StreamString strm;
|
|
if (m_break_id != LLDB_INVALID_BREAK_ID) {
|
|
BreakpointSP break_sp =
|
|
thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
|
|
m_break_id);
|
|
if (break_sp) {
|
|
if (break_sp->IsInternal()) {
|
|
const char *kind = break_sp->GetBreakpointKind();
|
|
if (kind)
|
|
strm.Printf("internal %s breakpoint(%d).", kind, m_break_id);
|
|
else
|
|
strm.Printf("internal breakpoint(%d).", m_break_id);
|
|
} else {
|
|
strm.Printf("breakpoint %d.", m_break_id);
|
|
}
|
|
} else {
|
|
if (m_was_one_shot)
|
|
strm.Printf("one-shot breakpoint %d", m_break_id);
|
|
else
|
|
strm.Printf("breakpoint %d which has been deleted.",
|
|
m_break_id);
|
|
}
|
|
} else if (m_address == LLDB_INVALID_ADDRESS)
|
|
strm.Printf("breakpoint site %" PRIi64
|
|
" which has been deleted - unknown address",
|
|
m_value);
|
|
else
|
|
strm.Printf("breakpoint site %" PRIi64
|
|
" which has been deleted - was at 0x%" PRIx64,
|
|
m_value, m_address);
|
|
|
|
m_description = std::string(strm.GetString());
|
|
}
|
|
}
|
|
}
|
|
return m_description.c_str();
|
|
}
|
|
|
|
protected:
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
// This just reports the work done by PerformAction or the synchronous
|
|
// stop. It should only ever get called after they have had a chance to
|
|
// run.
|
|
assert(m_should_stop_is_valid);
|
|
return m_should_stop;
|
|
}
|
|
|
|
void PerformAction(Event *event_ptr) override {
|
|
if (!m_should_perform_action)
|
|
return;
|
|
m_should_perform_action = false;
|
|
bool internal_breakpoint = true;
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
|
Log *log = lldb_private::GetLogIfAnyCategoriesSet(
|
|
LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
|
|
|
|
if (!thread_sp->IsValid()) {
|
|
// This shouldn't ever happen, but just in case, don't do more harm.
|
|
if (log) {
|
|
LLDB_LOGF(log, "PerformAction got called with an invalid thread.");
|
|
}
|
|
m_should_stop = true;
|
|
m_should_stop_is_valid = true;
|
|
return;
|
|
}
|
|
|
|
BreakpointSiteSP bp_site_sp(
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
std::unordered_set<break_id_t> precondition_breakpoints;
|
|
|
|
if (bp_site_sp) {
|
|
// Let's copy the owners list out of the site and store them in a local
|
|
// list. That way if one of the breakpoint actions changes the site,
|
|
// then we won't be operating on a bad list.
|
|
BreakpointLocationCollection site_locations;
|
|
size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
|
|
|
|
if (num_owners == 0) {
|
|
m_should_stop = true;
|
|
} else {
|
|
// We go through each location, and test first its precondition -
|
|
// this overrides everything. Note, we only do this once per
|
|
// breakpoint - not once per location... Then check the condition.
|
|
// If the condition says to stop, then we run the callback for that
|
|
// location. If that callback says to stop as well, then we set
|
|
// m_should_stop to true; we are going to stop. But we still want to
|
|
// give all the breakpoints whose conditions say we are going to stop
|
|
// a chance to run their callbacks. Of course if any callback
|
|
// restarts the target by putting "continue" in the callback, then
|
|
// we're going to restart, without running the rest of the callbacks.
|
|
// And in this case we will end up not stopping even if another
|
|
// location said we should stop. But that's better than not running
|
|
// all the callbacks.
|
|
|
|
m_should_stop = false;
|
|
|
|
// We don't select threads as we go through them testing breakpoint
|
|
// conditions and running commands. So we need to set the thread for
|
|
// expression evaluation here:
|
|
ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
|
|
|
|
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
if (process->GetModIDRef().IsLastResumeForUserExpression()) {
|
|
// If we are in the middle of evaluating an expression, don't run
|
|
// asynchronous breakpoint commands or expressions. That could
|
|
// lead to infinite recursion if the command or condition re-calls
|
|
// the function with this breakpoint.
|
|
// TODO: We can keep a list of the breakpoints we've seen while
|
|
// running expressions in the nested
|
|
// PerformAction calls that can arise when the action runs a
|
|
// function that hits another breakpoint, and only stop running
|
|
// commands when we see the same breakpoint hit a second time.
|
|
|
|
m_should_stop_is_valid = true;
|
|
|
|
// It is possible that the user has a breakpoint at the same site
|
|
// as the completed plan had (e.g. user has a breakpoint
|
|
// on a module entry point, and `ThreadPlanCallFunction` ends
|
|
// also there). We can't find an internal breakpoint in the loop
|
|
// later because it was already removed on the plan completion.
|
|
// So check if the plan was completed, and stop if so.
|
|
if (thread_sp->CompletedPlanOverridesBreakpoint()) {
|
|
m_should_stop = true;
|
|
thread_sp->ResetStopInfo();
|
|
return;
|
|
}
|
|
|
|
LLDB_LOGF(log, "StopInfoBreakpoint::PerformAction - Hit a "
|
|
"breakpoint while running an expression,"
|
|
" not running commands to avoid recursion.");
|
|
bool ignoring_breakpoints =
|
|
process->GetIgnoreBreakpointsInExpressions();
|
|
if (ignoring_breakpoints) {
|
|
m_should_stop = false;
|
|
// Internal breakpoints will always stop.
|
|
for (size_t j = 0; j < num_owners; j++) {
|
|
lldb::BreakpointLocationSP bp_loc_sp =
|
|
bp_site_sp->GetOwnerAtIndex(j);
|
|
if (bp_loc_sp->GetBreakpoint().IsInternal()) {
|
|
m_should_stop = true;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
m_should_stop = true;
|
|
}
|
|
LLDB_LOGF(log,
|
|
"StopInfoBreakpoint::PerformAction - in expression, "
|
|
"continuing: %s.",
|
|
m_should_stop ? "true" : "false");
|
|
process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
|
|
"Warning: hit breakpoint while running function, skipping "
|
|
"commands and conditions to prevent recursion.\n");
|
|
return;
|
|
}
|
|
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, false);
|
|
|
|
// For safety's sake let's also grab an extra reference to the
|
|
// breakpoint owners of the locations we're going to examine, since
|
|
// the locations are going to have to get back to their breakpoints,
|
|
// and the locations don't keep their owners alive. I'm just
|
|
// sticking the BreakpointSP's in a vector since I'm only using it to
|
|
// locally increment their retain counts.
|
|
|
|
std::vector<lldb::BreakpointSP> location_owners;
|
|
|
|
for (size_t j = 0; j < num_owners; j++) {
|
|
BreakpointLocationSP loc(site_locations.GetByIndex(j));
|
|
location_owners.push_back(loc->GetBreakpoint().shared_from_this());
|
|
}
|
|
|
|
for (size_t j = 0; j < num_owners; j++) {
|
|
lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
|
|
StreamString loc_desc;
|
|
if (log) {
|
|
bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
|
|
}
|
|
// If another action disabled this breakpoint or its location, then
|
|
// don't run the actions.
|
|
if (!bp_loc_sp->IsEnabled() ||
|
|
!bp_loc_sp->GetBreakpoint().IsEnabled())
|
|
continue;
|
|
|
|
// The breakpoint site may have many locations associated with it,
|
|
// not all of them valid for this thread. Skip the ones that
|
|
// aren't:
|
|
if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"Breakpoint %s hit on thread 0x%llx but it was not "
|
|
"for this thread, continuing.",
|
|
loc_desc.GetData(),
|
|
static_cast<unsigned long long>(thread_sp->GetID()));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
|
|
|
|
// First run the precondition, but since the precondition is per
|
|
// breakpoint, only run it once per breakpoint.
|
|
std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
|
|
precondition_breakpoints.insert(
|
|
bp_loc_sp->GetBreakpoint().GetID());
|
|
if (!result.second)
|
|
continue;
|
|
|
|
bool precondition_result =
|
|
bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
|
|
if (!precondition_result)
|
|
continue;
|
|
|
|
// Next run the condition for the breakpoint. If that says we
|
|
// should stop, then we'll run the callback for the breakpoint. If
|
|
// the callback says we shouldn't stop that will win.
|
|
|
|
if (bp_loc_sp->GetConditionText() != nullptr) {
|
|
Status condition_error;
|
|
bool condition_says_stop =
|
|
bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
|
|
|
|
if (!condition_error.Success()) {
|
|
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
|
|
StreamSP error_sp = debugger.GetAsyncErrorStream();
|
|
error_sp->Printf("Stopped due to an error evaluating condition "
|
|
"of breakpoint ");
|
|
bp_loc_sp->GetDescription(error_sp.get(),
|
|
eDescriptionLevelBrief);
|
|
error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
|
|
error_sp->EOL();
|
|
const char *err_str =
|
|
condition_error.AsCString("<Unknown Error>");
|
|
LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
|
|
|
|
error_sp->PutCString(err_str);
|
|
error_sp->EOL();
|
|
error_sp->Flush();
|
|
} else {
|
|
LLDB_LOGF(log,
|
|
"Condition evaluated for breakpoint %s on thread "
|
|
"0x%llx condition_says_stop: %i.",
|
|
loc_desc.GetData(),
|
|
static_cast<unsigned long long>(thread_sp->GetID()),
|
|
condition_says_stop);
|
|
if (!condition_says_stop) {
|
|
// We don't want to increment the hit count of breakpoints if
|
|
// the condition fails. We've already bumped it by the time
|
|
// we get here, so undo the bump:
|
|
bp_loc_sp->UndoBumpHitCount();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check the auto-continue bit on the location, do this before the
|
|
// callback since it may change this, but that would be for the
|
|
// NEXT hit. Note, you might think you could check auto-continue
|
|
// before the condition, and not evaluate the condition if it says
|
|
// to continue. But failing the condition means the breakpoint was
|
|
// effectively NOT HIT. So these two states are different.
|
|
bool auto_continue_says_stop = true;
|
|
if (bp_loc_sp->IsAutoContinue())
|
|
{
|
|
LLDB_LOGF(log,
|
|
"Continuing breakpoint %s as AutoContinue was set.",
|
|
loc_desc.GetData());
|
|
// We want this stop reported, so you will know we auto-continued
|
|
// but only for external breakpoints:
|
|
if (!internal_breakpoint)
|
|
thread_sp->SetShouldReportStop(eVoteYes);
|
|
auto_continue_says_stop = false;
|
|
}
|
|
|
|
bool callback_says_stop = true;
|
|
|
|
// FIXME: For now the callbacks have to run in async mode - the
|
|
// first time we restart we need
|
|
// to get out of there. So set it here.
|
|
// When we figure out how to nest breakpoint hits then this will
|
|
// change.
|
|
|
|
Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
|
|
bool old_async = debugger.GetAsyncExecution();
|
|
debugger.SetAsyncExecution(true);
|
|
|
|
callback_says_stop = bp_loc_sp->InvokeCallback(&context);
|
|
|
|
debugger.SetAsyncExecution(old_async);
|
|
|
|
if (callback_says_stop && auto_continue_says_stop)
|
|
m_should_stop = true;
|
|
|
|
// If we are going to stop for this breakpoint, then remove the
|
|
// breakpoint.
|
|
if (callback_says_stop && bp_loc_sp &&
|
|
bp_loc_sp->GetBreakpoint().IsOneShot()) {
|
|
thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
|
|
bp_loc_sp->GetBreakpoint().GetID());
|
|
}
|
|
// Also make sure that the callback hasn't continued the target. If
|
|
// it did, when we'll set m_should_start to false and get out of
|
|
// here.
|
|
if (HasTargetRunSinceMe()) {
|
|
m_should_stop = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// We've figured out what this stop wants to do, so mark it as valid so
|
|
// we don't compute it again.
|
|
m_should_stop_is_valid = true;
|
|
} else {
|
|
m_should_stop = true;
|
|
m_should_stop_is_valid = true;
|
|
Log *log_process(
|
|
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
LLDB_LOGF(log_process,
|
|
"Process::%s could not find breakpoint site id: %" PRId64
|
|
"...",
|
|
__FUNCTION__, m_value);
|
|
}
|
|
|
|
if ((!m_should_stop || internal_breakpoint) &&
|
|
thread_sp->CompletedPlanOverridesBreakpoint()) {
|
|
|
|
// Override should_stop decision when we have completed step plan
|
|
// additionally to the breakpoint
|
|
m_should_stop = true;
|
|
|
|
// We know we're stopping for a completed plan and we don't want to
|
|
// show the breakpoint stop, so compute the public stop info immediately
|
|
// here.
|
|
thread_sp->CalculatePublicStopInfo();
|
|
}
|
|
|
|
LLDB_LOGF(log,
|
|
"Process::%s returning from action with m_should_stop: %d.",
|
|
__FUNCTION__, m_should_stop);
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_should_stop;
|
|
bool m_should_stop_is_valid;
|
|
bool m_should_perform_action; // Since we are trying to preserve the "state"
|
|
// of the system even if we run functions
|
|
// etc. behind the users backs, we need to make sure we only REALLY perform
|
|
// the action once.
|
|
lldb::addr_t m_address; // We use this to capture the breakpoint site address
|
|
// when we create the StopInfo,
|
|
// in case somebody deletes it between the time the StopInfo is made and the
|
|
// description is asked for.
|
|
lldb::break_id_t m_break_id;
|
|
bool m_was_one_shot;
|
|
};
|
|
|
|
// StopInfoWatchpoint
|
|
|
|
class StopInfoWatchpoint : public StopInfo {
|
|
public:
|
|
// Make sure watchpoint is properly disabled and subsequently enabled while
|
|
// performing watchpoint actions.
|
|
class WatchpointSentry {
|
|
public:
|
|
WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
|
|
watchpoint_sp(w_sp) {
|
|
if (process_sp && watchpoint_sp) {
|
|
const bool notify = false;
|
|
watchpoint_sp->TurnOnEphemeralMode();
|
|
process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
|
|
process_sp->AddPreResumeAction(SentryPreResumeAction, this);
|
|
}
|
|
}
|
|
|
|
void DoReenable() {
|
|
if (process_sp && watchpoint_sp) {
|
|
bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
|
|
watchpoint_sp->TurnOffEphemeralMode();
|
|
const bool notify = false;
|
|
if (was_disabled) {
|
|
process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
|
|
} else {
|
|
process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
|
|
}
|
|
}
|
|
}
|
|
|
|
~WatchpointSentry() {
|
|
DoReenable();
|
|
if (process_sp)
|
|
process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
|
|
}
|
|
|
|
static bool SentryPreResumeAction(void *sentry_void) {
|
|
WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
|
|
sentry->DoReenable();
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
ProcessSP process_sp;
|
|
WatchpointSP watchpoint_sp;
|
|
};
|
|
|
|
StopInfoWatchpoint(Thread &thread, break_id_t watch_id,
|
|
lldb::addr_t watch_hit_addr)
|
|
: StopInfo(thread, watch_id), m_should_stop(false),
|
|
m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
|
|
|
|
~StopInfoWatchpoint() override = default;
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty()) {
|
|
StreamString strm;
|
|
strm.Printf("watchpoint %" PRIi64, m_value);
|
|
m_description = std::string(strm.GetString());
|
|
}
|
|
return m_description.c_str();
|
|
}
|
|
|
|
protected:
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
|
// ShouldStop() method is idempotent and should not affect hit count. See
|
|
// Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
|
|
// -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
|
|
// Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
|
|
// StopInfoWatchpoint::ShouldStop() and
|
|
// Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
|
|
// StopInfoWatchpoint::PerformAction().
|
|
if (m_should_stop_is_valid)
|
|
return m_should_stop;
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
WatchpointSP wp_sp(
|
|
thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
|
|
GetValue()));
|
|
if (wp_sp) {
|
|
// Check if we should stop at a watchpoint.
|
|
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, true);
|
|
m_should_stop = wp_sp->ShouldStop(&context);
|
|
} else {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
LLDB_LOGF(log,
|
|
"Process::%s could not find watchpoint location id: %" PRId64
|
|
"...",
|
|
__FUNCTION__, GetValue());
|
|
|
|
m_should_stop = true;
|
|
}
|
|
}
|
|
m_should_stop_is_valid = true;
|
|
return m_should_stop;
|
|
}
|
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
// This just reports the work done by PerformAction or the synchronous
|
|
// stop. It should only ever get called after they have had a chance to
|
|
// run.
|
|
assert(m_should_stop_is_valid);
|
|
return m_should_stop;
|
|
}
|
|
|
|
void PerformAction(Event *event_ptr) override {
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
|
|
// We're going to calculate if we should stop or not in some way during the
|
|
// course of this code. Also by default we're going to stop, so set that
|
|
// here.
|
|
m_should_stop = true;
|
|
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
|
|
WatchpointSP wp_sp(
|
|
thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
|
|
GetValue()));
|
|
if (wp_sp) {
|
|
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
|
|
ProcessSP process_sp = exe_ctx.GetProcessSP();
|
|
|
|
{
|
|
// check if this process is running on an architecture where
|
|
// watchpoints trigger before the associated instruction runs. if so,
|
|
// disable the WP, single-step and then re-enable the watchpoint
|
|
if (process_sp) {
|
|
uint32_t num;
|
|
bool wp_triggers_after;
|
|
|
|
if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
|
|
.Success()) {
|
|
if (!wp_triggers_after) {
|
|
// We need to preserve the watch_index before watchpoint is
|
|
// disable. Since Watchpoint::SetEnabled will clear the watch
|
|
// index. This will fix TestWatchpointIter failure
|
|
Watchpoint *wp = wp_sp.get();
|
|
uint32_t watch_index = wp->GetHardwareIndex();
|
|
process_sp->DisableWatchpoint(wp, false);
|
|
StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
|
|
assert(stored_stop_info_sp.get() == this);
|
|
|
|
Status new_plan_status;
|
|
ThreadPlanSP new_plan_sp(
|
|
thread_sp->QueueThreadPlanForStepSingleInstruction(
|
|
false, // step-over
|
|
false, // abort_other_plans
|
|
true, // stop_other_threads
|
|
new_plan_status));
|
|
if (new_plan_sp && new_plan_status.Success()) {
|
|
new_plan_sp->SetIsMasterPlan(true);
|
|
new_plan_sp->SetOkayToDiscard(false);
|
|
new_plan_sp->SetPrivate(true);
|
|
}
|
|
process_sp->GetThreadList().SetSelectedThreadByID(
|
|
thread_sp->GetID());
|
|
process_sp->ResumeSynchronous(nullptr);
|
|
process_sp->GetThreadList().SetSelectedThreadByID(
|
|
thread_sp->GetID());
|
|
thread_sp->SetStopInfo(stored_stop_info_sp);
|
|
process_sp->EnableWatchpoint(wp, false);
|
|
wp->SetHardwareIndex(watch_index);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This sentry object makes sure the current watchpoint is disabled
|
|
// while performing watchpoint actions, and it is then enabled after we
|
|
// are finished.
|
|
WatchpointSentry sentry(process_sp, wp_sp);
|
|
|
|
/*
|
|
* MIPS: Last 3bits of the watchpoint address are masked by the kernel.
|
|
* For example:
|
|
* 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is
|
|
* set at 'm', then
|
|
* watch exception is generated even when 'n' is read/written. To handle
|
|
* this case,
|
|
* server emulates the instruction at PC and finds the base address of
|
|
* the load/store
|
|
* instruction and appends it in the description of the stop-info
|
|
* packet. If watchpoint
|
|
* is not set on this address by user then this do not stop.
|
|
*/
|
|
if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) {
|
|
WatchpointSP wp_hit_sp =
|
|
thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
|
|
m_watch_hit_addr);
|
|
if (!wp_hit_sp) {
|
|
m_should_stop = false;
|
|
wp_sp->IncrementFalseAlarmsAndReviseHitCount();
|
|
}
|
|
}
|
|
|
|
// TODO: This condition should be checked in the synchronous part of the
|
|
// watchpoint code
|
|
// (Watchpoint::ShouldStop), so that we avoid pulling an event even if
|
|
// the watchpoint fails the ignore count condition. It is moved here
|
|
// temporarily, because for archs with
|
|
// watchpoint_exceptions_received=before, the code in the previous
|
|
// lines takes care of moving the inferior to next PC. We have to check
|
|
// the ignore count condition after this is done, otherwise we will hit
|
|
// same watchpoint multiple times until we pass ignore condition, but
|
|
// we won't actually be ignoring them.
|
|
if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
|
|
m_should_stop = false;
|
|
|
|
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
|
|
|
|
if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
|
|
// We need to make sure the user sees any parse errors in their
|
|
// condition, so we'll hook the constructor errors up to the
|
|
// debugger's Async I/O.
|
|
ExpressionResults result_code;
|
|
EvaluateExpressionOptions expr_options;
|
|
expr_options.SetUnwindOnError(true);
|
|
expr_options.SetIgnoreBreakpoints(true);
|
|
ValueObjectSP result_value_sp;
|
|
Status error;
|
|
result_code = UserExpression::Evaluate(
|
|
exe_ctx, expr_options, wp_sp->GetConditionText(),
|
|
llvm::StringRef(), result_value_sp, error);
|
|
|
|
if (result_code == eExpressionCompleted) {
|
|
if (result_value_sp) {
|
|
Scalar scalar_value;
|
|
if (result_value_sp->ResolveValue(scalar_value)) {
|
|
if (scalar_value.ULongLong(1) == 0) {
|
|
// We have been vetoed. This takes precedence over querying
|
|
// the watchpoint whether it should stop (aka ignore count
|
|
// and friends). See also StopInfoWatchpoint::ShouldStop()
|
|
// as well as Process::ProcessEventData::DoOnRemoval().
|
|
m_should_stop = false;
|
|
} else
|
|
m_should_stop = true;
|
|
LLDB_LOGF(log,
|
|
"Condition successfully evaluated, result is %s.\n",
|
|
m_should_stop ? "true" : "false");
|
|
} else {
|
|
m_should_stop = true;
|
|
LLDB_LOGF(
|
|
log,
|
|
"Failed to get an integer result from the expression.");
|
|
}
|
|
}
|
|
} else {
|
|
StreamSP error_sp = debugger.GetAsyncErrorStream();
|
|
error_sp->Printf(
|
|
"Stopped due to an error evaluating condition of watchpoint ");
|
|
wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief);
|
|
error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
|
|
error_sp->EOL();
|
|
const char *err_str = error.AsCString("<Unknown Error>");
|
|
LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
|
|
|
|
error_sp->PutCString(err_str);
|
|
error_sp->EOL();
|
|
error_sp->Flush();
|
|
// If the condition fails to be parsed or run, we should stop.
|
|
m_should_stop = true;
|
|
}
|
|
}
|
|
|
|
// If the condition says to stop, we run the callback to further decide
|
|
// whether to stop.
|
|
if (m_should_stop) {
|
|
// FIXME: For now the callbacks have to run in async mode - the
|
|
// first time we restart we need
|
|
// to get out of there. So set it here.
|
|
// When we figure out how to nest watchpoint hits then this will
|
|
// change.
|
|
|
|
bool old_async = debugger.GetAsyncExecution();
|
|
debugger.SetAsyncExecution(true);
|
|
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, false);
|
|
bool stop_requested = wp_sp->InvokeCallback(&context);
|
|
|
|
debugger.SetAsyncExecution(old_async);
|
|
|
|
// Also make sure that the callback hasn't continued the target. If
|
|
// it did, when we'll set m_should_stop to false and get out of here.
|
|
if (HasTargetRunSinceMe())
|
|
m_should_stop = false;
|
|
|
|
if (m_should_stop && !stop_requested) {
|
|
// We have been vetoed by the callback mechanism.
|
|
m_should_stop = false;
|
|
}
|
|
}
|
|
// Finally, if we are going to stop, print out the new & old values:
|
|
if (m_should_stop) {
|
|
wp_sp->CaptureWatchedValue(exe_ctx);
|
|
|
|
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
|
|
StreamSP output_sp = debugger.GetAsyncOutputStream();
|
|
wp_sp->DumpSnapshots(output_sp.get());
|
|
output_sp->EOL();
|
|
output_sp->Flush();
|
|
}
|
|
|
|
} else {
|
|
Log *log_process(
|
|
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
LLDB_LOGF(log_process,
|
|
"Process::%s could not find watchpoint id: %" PRId64 "...",
|
|
__FUNCTION__, m_value);
|
|
}
|
|
LLDB_LOGF(log,
|
|
"Process::%s returning from action with m_should_stop: %d.",
|
|
__FUNCTION__, m_should_stop);
|
|
|
|
m_should_stop_is_valid = true;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_should_stop;
|
|
bool m_should_stop_is_valid;
|
|
lldb::addr_t m_watch_hit_addr;
|
|
};
|
|
|
|
// StopInfoUnixSignal
|
|
|
|
class StopInfoUnixSignal : public StopInfo {
|
|
public:
|
|
StopInfoUnixSignal(Thread &thread, int signo, const char *description)
|
|
: StopInfo(thread, signo) {
|
|
SetDescription(description);
|
|
}
|
|
|
|
~StopInfoUnixSignal() override = default;
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonSignal; }
|
|
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp)
|
|
return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
|
|
return false;
|
|
}
|
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp)
|
|
return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
|
|
return false;
|
|
}
|
|
|
|
// If should stop returns false, check if we should notify of this event
|
|
bool DoShouldNotify(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
bool should_notify =
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
|
|
if (should_notify) {
|
|
StreamString strm;
|
|
strm.Printf(
|
|
"thread %d received signal: %s", thread_sp->GetIndexID(),
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
|
|
m_value));
|
|
Process::ProcessEventData::AddRestartedReason(event_ptr,
|
|
strm.GetData());
|
|
}
|
|
return should_notify;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void WillResume(lldb::StateType resume_state) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
|
|
m_value))
|
|
thread_sp->SetResumeSignal(m_value);
|
|
}
|
|
}
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty()) {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp) {
|
|
StreamString strm;
|
|
const char *signal_name =
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
|
|
m_value);
|
|
if (signal_name)
|
|
strm.Printf("signal %s", signal_name);
|
|
else
|
|
strm.Printf("signal %" PRIi64, m_value);
|
|
m_description = std::string(strm.GetString());
|
|
}
|
|
}
|
|
return m_description.c_str();
|
|
}
|
|
};
|
|
|
|
// StopInfoTrace
|
|
|
|
class StopInfoTrace : public StopInfo {
|
|
public:
|
|
StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
|
|
|
|
~StopInfoTrace() override = default;
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonTrace; }
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty())
|
|
return "trace";
|
|
else
|
|
return m_description.c_str();
|
|
}
|
|
};
|
|
|
|
// StopInfoException
|
|
|
|
class StopInfoException : public StopInfo {
|
|
public:
|
|
StopInfoException(Thread &thread, const char *description)
|
|
: StopInfo(thread, LLDB_INVALID_UID) {
|
|
if (description)
|
|
SetDescription(description);
|
|
}
|
|
|
|
~StopInfoException() override = default;
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonException; }
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty())
|
|
return "exception";
|
|
else
|
|
return m_description.c_str();
|
|
}
|
|
};
|
|
|
|
// StopInfoThreadPlan
|
|
|
|
class StopInfoThreadPlan : public StopInfo {
|
|
public:
|
|
StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
|
|
ExpressionVariableSP &expression_variable_sp)
|
|
: StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
|
|
m_return_valobj_sp(return_valobj_sp),
|
|
m_expression_variable_sp(expression_variable_sp) {}
|
|
|
|
~StopInfoThreadPlan() override = default;
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
|
|
|
|
const char *GetDescription() override {
|
|
if (m_description.empty()) {
|
|
StreamString strm;
|
|
m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
|
|
m_description = std::string(strm.GetString());
|
|
}
|
|
return m_description.c_str();
|
|
}
|
|
|
|
ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
|
|
|
|
ExpressionVariableSP GetExpressionVariable() {
|
|
return m_expression_variable_sp;
|
|
}
|
|
|
|
protected:
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
if (m_plan_sp)
|
|
return m_plan_sp->ShouldStop(event_ptr);
|
|
else
|
|
return StopInfo::ShouldStop(event_ptr);
|
|
}
|
|
|
|
private:
|
|
ThreadPlanSP m_plan_sp;
|
|
ValueObjectSP m_return_valobj_sp;
|
|
ExpressionVariableSP m_expression_variable_sp;
|
|
};
|
|
|
|
// StopInfoExec
|
|
|
|
class StopInfoExec : public StopInfo {
|
|
public:
|
|
StopInfoExec(Thread &thread)
|
|
: StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
|
|
|
|
~StopInfoExec() override = default;
|
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp)
|
|
return thread_sp->GetProcess()->GetStopOnExec();
|
|
return false;
|
|
}
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonExec; }
|
|
|
|
const char *GetDescription() override { return "exec"; }
|
|
|
|
protected:
|
|
void PerformAction(Event *event_ptr) override {
|
|
// Only perform the action once
|
|
if (m_performed_action)
|
|
return;
|
|
m_performed_action = true;
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
if (thread_sp)
|
|
thread_sp->GetProcess()->DidExec();
|
|
}
|
|
|
|
bool m_performed_action;
|
|
};
|
|
|
|
} // namespace lldb_private
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
|
|
break_id_t break_id) {
|
|
return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
|
|
break_id_t break_id,
|
|
bool should_stop) {
|
|
return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
|
|
}
|
|
|
|
StopInfoSP
|
|
StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id,
|
|
lldb::addr_t watch_hit_addr) {
|
|
return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
|
|
const char *description) {
|
|
return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
|
|
return StopInfoSP(new StopInfoTrace(thread));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithPlan(
|
|
ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
|
|
ExpressionVariableSP expression_variable_sp) {
|
|
return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
|
|
expression_variable_sp));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
|
|
const char *description) {
|
|
return StopInfoSP(new StopInfoException(thread, description));
|
|
}
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
|
|
return StopInfoSP(new StopInfoExec(thread));
|
|
}
|
|
|
|
ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
|
|
if (stop_info_sp &&
|
|
stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
|
|
StopInfoThreadPlan *plan_stop_info =
|
|
static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
|
|
return plan_stop_info->GetReturnValueObject();
|
|
} else
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) {
|
|
if (stop_info_sp &&
|
|
stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
|
|
StopInfoThreadPlan *plan_stop_info =
|
|
static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
|
|
return plan_stop_info->GetExpressionVariable();
|
|
} else
|
|
return ExpressionVariableSP();
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp,
|
|
lldb::addr_t *crashing_address) {
|
|
if (!stop_info_sp) {
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
const char *description = stop_info_sp->GetDescription();
|
|
if (!description) {
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
ThreadSP thread_sp = stop_info_sp->GetThread();
|
|
if (!thread_sp) {
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
|
|
|
|
if (!frame_sp) {
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
const char address_string[] = "address=";
|
|
|
|
const char *address_loc = strstr(description, address_string);
|
|
if (!address_loc) {
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
address_loc += (sizeof(address_string) - 1);
|
|
|
|
uint64_t address = strtoull(address_loc, nullptr, 0);
|
|
if (crashing_address) {
|
|
*crashing_address = address;
|
|
}
|
|
|
|
return frame_sp->GuessValueForAddress(address);
|
|
}
|