2015-10-24 02:39:37 +08:00
|
|
|
//===-- StopInfo.cpp --------------------------------------------*- C++ -*-===//
|
2010-08-04 09:40:35 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2010-08-04 09:40:35 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
2010-11-19 02:52:36 +08:00
|
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
2010-08-04 09:40:35 +08:00
|
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
|
|
#include "lldb/Breakpoint/StoppointCallbackContext.h"
|
2011-10-14 08:42:25 +08:00
|
|
|
#include "lldb/Breakpoint/Watchpoint.h"
|
2011-08-09 10:12:22 +08:00
|
|
|
#include "lldb/Core/Debugger.h"
|
2015-03-04 07:11:11 +08:00
|
|
|
#include "lldb/Core/ValueObject.h"
|
2015-09-16 05:13:50 +08:00
|
|
|
#include "lldb/Expression/UserExpression.h"
|
2010-08-04 09:40:35 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
2015-10-24 02:39:37 +08:00
|
|
|
#include "lldb/Target/StopInfo.h"
|
2011-08-09 10:12:22 +08:00
|
|
|
#include "lldb/Target/Target.h"
|
2010-08-04 09:40:35 +08:00
|
|
|
#include "lldb/Target/Thread.h"
|
|
|
|
#include "lldb/Target/ThreadPlan.h"
|
|
|
|
#include "lldb/Target/UnixSignals.h"
|
2017-03-04 04:56:28 +08:00
|
|
|
#include "lldb/Utility/Log.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/StreamString.h"
|
2010-08-04 09:40:35 +08:00
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
StopInfo::StopInfo(Thread &thread, uint64_t value)
|
2013-04-30 07:30:46 +08:00
|
|
|
: m_thread_wp(thread.shared_from_this()),
|
2012-02-21 08:09:25 +08:00
|
|
|
m_stop_id(thread.GetProcess()->GetStopID()),
|
|
|
|
m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
|
Figure out the reply to "PlanExplainsStop" once when we stop and then use the cached
value. This fixes problems, for instance, with the StepRange plans, where they know that
they explained the stop because they were at their "run to here" breakpoint, then deleted
that breakpoint, so when they got asked again, doh! I had done this for a couple of plans
in an ad hoc fashion, this just formalizes it.
Also add a "ResumeRequested" in Process so that the code in the completion handlers can
tell the ShouldStop logic they want to resume rather than just directly resuming. That allows
us to handle resuming in a more controlled fashion.
Also, SetPublicState can take a "restarted" flag, so that it doesn't drop the run lock when
the target was immediately restarted.
--This line, and those below , will be ignored--
M test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
M include/lldb/Target/ThreadList.h
M include/lldb/Target/ThreadPlanStepOut.h
M include/lldb/Target/Thread.h
M include/lldb/Target/ThreadPlanBase.h
M include/lldb/Target/ThreadPlanStepThrough.h
M include/lldb/Target/ThreadPlanStepInstruction.h
M include/lldb/Target/ThreadPlanStepInRange.h
M include/lldb/Target/ThreadPlanStepOverBreakpoint.h
M include/lldb/Target/ThreadPlanStepUntil.h
M include/lldb/Target/StopInfo.h
M include/lldb/Target/Process.h
M include/lldb/Target/ThreadPlanRunToAddress.h
M include/lldb/Target/ThreadPlan.h
M include/lldb/Target/ThreadPlanCallFunction.h
M include/lldb/Target/ThreadPlanStepOverRange.h
M source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
M source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
M source/Target/StopInfo.cpp
M source/Target/Process.cpp
M source/Target/ThreadPlanRunToAddress.cpp
M source/Target/ThreadPlan.cpp
M source/Target/ThreadPlanCallFunction.cpp
M source/Target/ThreadPlanStepOverRange.cpp
M source/Target/ThreadList.cpp
M source/Target/ThreadPlanStepOut.cpp
M source/Target/Thread.cpp
M source/Target/ThreadPlanBase.cpp
M source/Target/ThreadPlanStepThrough.cpp
M source/Target/ThreadPlanStepInstruction.cpp
M source/Target/ThreadPlanStepInRange.cpp
M source/Target/ThreadPlanStepOverBreakpoint.cpp
M source/Target/ThreadPlanStepUntil.cpp
M lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme
llvm-svn: 181381
2013-05-08 08:35:16 +08:00
|
|
|
m_description(), m_override_should_notify(eLazyBoolCalculate),
|
LLDB AddressSanitizer instrumentation runtime plugin, breakpint on error and report data extraction
Reviewed at http://reviews.llvm.org/D5592
This patch gives LLDB some ability to interact with AddressSanitizer runtime library, on top of what we already have (historical memory stack traces provided by ASan). Namely, that's the ability to stop on an error caught by ASan, and access the report information that are associated with it. The report information is also exposed into SB API.
More precisely this patch...
adds a new plugin type, InstrumentationRuntime, which should serve as a generic superclass for other instrumentation runtime libraries, these plugins get notified when modules are loaded, so they get a chance to "activate" when a specific dynamic library is loaded
an instance of this plugin type, AddressSanitizerRuntime, which activates itself when it sees the ASan dynamic library or founds ASan statically linked in the executable
adds a collection of these plugins into the Process class
AddressSanitizerRuntime sets an internal breakpoint on __asan::AsanDie(), and when this breakpoint gets hit, it retrieves the report information from ASan
this breakpoint is then exposed as a new StopReason, eStopReasonInstrumentation, with a new StopInfo subclass, InstrumentationRuntimeStopInfo
the StopInfo superclass is extended with a m_extended_info field (it's a StructuredData::ObjectSP), that can hold arbitrary JSON-like data, which is the way the new plugin provides the report data
the "thread info" command now accepts a "-s" flag that prints out the JSON data of a stop reason (same way the "-j" flag works now)
SBThread has a new API, GetStopReasonExtendedInfoAsJSON, which dumps the JSON string into a SBStream
adds a test case for all of this
I plan to also get rid of the original ASan plugin (memory history stack traces) and use an instance of AddressSanitizerRuntime for that purpose.
Kuba
llvm-svn: 219546
2014-10-11 07:43:03 +08:00
|
|
|
m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
LLDB AddressSanitizer instrumentation runtime plugin, breakpint on error and report data extraction
Reviewed at http://reviews.llvm.org/D5592
This patch gives LLDB some ability to interact with AddressSanitizer runtime library, on top of what we already have (historical memory stack traces provided by ASan). Namely, that's the ability to stop on an error caught by ASan, and access the report information that are associated with it. The report information is also exposed into SB API.
More precisely this patch...
adds a new plugin type, InstrumentationRuntime, which should serve as a generic superclass for other instrumentation runtime libraries, these plugins get notified when modules are loaded, so they get a chance to "activate" when a specific dynamic library is loaded
an instance of this plugin type, AddressSanitizerRuntime, which activates itself when it sees the ASan dynamic library or founds ASan statically linked in the executable
adds a collection of these plugins into the Process class
AddressSanitizerRuntime sets an internal breakpoint on __asan::AsanDie(), and when this breakpoint gets hit, it retrieves the report information from ASan
this breakpoint is then exposed as a new StopReason, eStopReasonInstrumentation, with a new StopInfo subclass, InstrumentationRuntimeStopInfo
the StopInfo superclass is extended with a m_extended_info field (it's a StructuredData::ObjectSP), that can hold arbitrary JSON-like data, which is the way the new plugin provides the report data
the "thread info" command now accepts a "-s" flag that prints out the JSON data of a stop reason (same way the "-j" flag works now)
SBThread has a new API, GetStopReasonExtendedInfoAsJSON, which dumps the JSON string into a SBStream
adds a test case for all of this
I plan to also get rid of the original ASan plugin (memory history stack traces) and use an instance of AddressSanitizerRuntime for that purpose.
Kuba
llvm-svn: 219546
2014-10-11 07:43:03 +08:00
|
|
|
bool StopInfo::IsValid() const {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp)
|
LLDB AddressSanitizer instrumentation runtime plugin, breakpint on error and report data extraction
Reviewed at http://reviews.llvm.org/D5592
This patch gives LLDB some ability to interact with AddressSanitizer runtime library, on top of what we already have (historical memory stack traces provided by ASan). Namely, that's the ability to stop on an error caught by ASan, and access the report information that are associated with it. The report information is also exposed into SB API.
More precisely this patch...
adds a new plugin type, InstrumentationRuntime, which should serve as a generic superclass for other instrumentation runtime libraries, these plugins get notified when modules are loaded, so they get a chance to "activate" when a specific dynamic library is loaded
an instance of this plugin type, AddressSanitizerRuntime, which activates itself when it sees the ASan dynamic library or founds ASan statically linked in the executable
adds a collection of these plugins into the Process class
AddressSanitizerRuntime sets an internal breakpoint on __asan::AsanDie(), and when this breakpoint gets hit, it retrieves the report information from ASan
this breakpoint is then exposed as a new StopReason, eStopReasonInstrumentation, with a new StopInfo subclass, InstrumentationRuntimeStopInfo
the StopInfo superclass is extended with a m_extended_info field (it's a StructuredData::ObjectSP), that can hold arbitrary JSON-like data, which is the way the new plugin provides the report data
the "thread info" command now accepts a "-s" flag that prints out the JSON data of a stop reason (same way the "-j" flag works now)
SBThread has a new API, GetStopReasonExtendedInfoAsJSON, which dumps the JSON string into a SBStream
adds a test case for all of this
I plan to also get rid of the original ASan plugin (memory history stack traces) and use an instance of AddressSanitizerRuntime for that purpose.
Kuba
llvm-svn: 219546
2014-10-11 07:43:03 +08:00
|
|
|
return thread_sp->GetProcess()->GetStopID() == m_stop_id;
|
2013-04-30 07:30:46 +08:00
|
|
|
return false;
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
|
2011-01-20 10:03:18 +08:00
|
|
|
void StopInfo::MakeStopInfoValid() {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
|
|
|
m_stop_id = thread_sp->GetProcess()->GetStopID();
|
|
|
|
m_resume_id = thread_sp->GetProcess()->GetResumeID();
|
|
|
|
}
|
2011-01-20 10:03:18 +08:00
|
|
|
}
|
|
|
|
|
2011-11-08 11:00:11 +08:00
|
|
|
bool StopInfo::HasTargetRunSinceMe() {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
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
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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
|
2013-04-30 07:30:46 +08:00
|
|
|
// NOT caused
|
|
|
|
// by expressions.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
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;
|
2011-11-08 11:00:11 +08:00
|
|
|
}
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-11-08 11:00:11 +08:00
|
|
|
return false;
|
2011-08-09 10:12:22 +08:00
|
|
|
}
|
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
// StopInfoBreakpoint
|
|
|
|
|
2011-08-09 10:12:22 +08:00
|
|
|
namespace lldb_private {
|
2010-08-04 09:40:35 +08:00
|
|
|
class StopInfoBreakpoint : public StopInfo {
|
|
|
|
public:
|
|
|
|
StopInfoBreakpoint(Thread &thread, break_id_t break_id)
|
|
|
|
: StopInfo(thread, break_id), m_should_stop(false),
|
2011-02-08 13:20:59 +08:00
|
|
|
m_should_stop_is_valid(false), m_should_perform_action(true),
|
2012-10-06 03:16:31 +08:00
|
|
|
m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
|
|
|
|
m_was_one_shot(false) {
|
|
|
|
StoreBPInfo();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2010-10-15 07:45:03 +08:00
|
|
|
StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
|
|
|
|
: StopInfo(thread, break_id), m_should_stop(should_stop),
|
2011-10-28 09:12:19 +08:00
|
|
|
m_should_stop_is_valid(true), m_should_perform_action(true),
|
2012-10-06 03:16:31 +08:00
|
|
|
m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
|
|
|
|
m_was_one_shot(false) {
|
|
|
|
StoreBPInfo();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
~StopInfoBreakpoint() override = default;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-10-06 03:16:31 +08:00
|
|
|
void StoreBPInfo() {
|
2013-04-30 07:30:46 +08:00
|
|
|
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();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
m_address = bp_site_sp->GetLoadAddress();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2010-10-15 07:45:03 +08:00
|
|
|
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);
|
2012-10-06 03:16:31 +08:00
|
|
|
}
|
2015-10-24 02:39:37 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
2011-10-28 09:12:19 +08:00
|
|
|
if (!m_should_stop_is_valid) {
|
2013-04-30 07:30:46 +08:00
|
|
|
// 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);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Process::%s could not find breakpoint site id: %" PRId64
|
|
|
|
"...",
|
|
|
|
__FUNCTION__, m_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2011-10-28 09:12:19 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop_is_valid = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
return m_should_stop;
|
2010-10-15 07:45:03 +08:00
|
|
|
}
|
2015-10-24 02:39:37 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
bool DoShouldNotify(Event *event_ptr) override {
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
2015-04-08 06:17:41 +08:00
|
|
|
if (thread_sp) {
|
|
|
|
BreakpointSiteSP bp_site_sp(
|
|
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
|
|
|
if (bp_site_sp) {
|
|
|
|
bool all_internal = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-04-08 06:17:41 +08:00
|
|
|
for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
|
|
|
|
if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
|
2013-04-30 07:30:46 +08:00
|
|
|
all_internal = false;
|
2015-04-08 06:17:41 +08:00
|
|
|
break;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2015-04-08 06:17:41 +08:00
|
|
|
}
|
|
|
|
return !all_internal;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2015-04-08 06:17:41 +08:00
|
|
|
}
|
2015-10-24 02:39:37 +08:00
|
|
|
return true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
|
|
|
if (m_description.empty()) {
|
2013-04-30 07:30:46 +08:00
|
|
|
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
|
2018-05-01 00:49:04 +08:00
|
|
|
// description, print that instead of the full breakpoint printing:
|
2013-04-30 07:30:46 +08:00
|
|
|
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;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
strm.Printf("breakpoint ");
|
|
|
|
bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
|
2016-11-17 05:15:24 +08:00
|
|
|
m_description = strm.GetString();
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
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);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
strm.Printf("breakpoint %d.", m_break_id);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
} else {
|
|
|
|
if (m_was_one_shot)
|
|
|
|
strm.Printf("one-shot breakpoint %d", m_break_id);
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-04-30 07:30:46 +08:00
|
|
|
strm.Printf("breakpoint %d which has been deleted.",
|
|
|
|
m_break_id);
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
} else if (m_address == LLDB_INVALID_ADDRESS)
|
|
|
|
strm.Printf("breakpoint site %" PRIi64
|
|
|
|
" which has been deleted - unknown address",
|
|
|
|
m_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-04-30 07:30:46 +08:00
|
|
|
strm.Printf("breakpoint site %" PRIi64
|
|
|
|
" which has been deleted - was at 0x%" PRIx64,
|
|
|
|
m_value, m_address);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-11-17 05:15:24 +08:00
|
|
|
m_description = strm.GetString();
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2012-11-10 10:08:14 +08:00
|
|
|
return m_description.c_str();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
protected:
|
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2012-04-21 05:16:56 +08:00
|
|
|
assert(m_should_stop_is_valid);
|
|
|
|
return m_should_stop;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-11-10 10:08:14 +08:00
|
|
|
void PerformAction(Event *event_ptr) override {
|
2013-04-30 07:30:46 +08:00
|
|
|
if (!m_should_perform_action)
|
2016-09-07 04:57:50 +08:00
|
|
|
return;
|
2011-02-08 13:20:59 +08:00
|
|
|
m_should_perform_action = false;
|
2017-02-15 19:42:47 +08:00
|
|
|
bool internal_breakpoint = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
if (thread_sp) {
|
2014-08-05 09:58:14 +08:00
|
|
|
Log *log = lldb_private::GetLogIfAnyCategoriesSet(
|
|
|
|
LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
if (!thread_sp->IsValid()) {
|
|
|
|
// This shouldn't ever happen, but just in case, don't do more harm.
|
2012-11-10 10:08:14 +08:00
|
|
|
if (log) {
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "PerformAction got called with an invalid thread.");
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
|
|
|
m_should_stop_is_valid = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
BreakpointSiteSP bp_site_sp(
|
|
|
|
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
|
2015-04-23 08:28:25 +08:00
|
|
|
std::unordered_set<break_id_t> precondition_breakpoints;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
if (bp_site_sp) {
|
2015-07-30 01:51:36 +08:00
|
|
|
// Let's copy the owners list out of the site and store them in a local
|
2018-05-01 00:49:04 +08:00
|
|
|
// list. That way if one of the breakpoint actions changes the site,
|
|
|
|
// then we won't be operating on a bad list.
|
2015-07-30 01:51:36 +08:00
|
|
|
BreakpointLocationCollection site_locations;
|
|
|
|
size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-11-10 10:08:14 +08:00
|
|
|
if (num_owners == 0) {
|
2011-12-09 12:17:31 +08:00
|
|
|
m_should_stop = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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
|
2013-04-30 07:30:46 +08:00
|
|
|
// we're going to restart, without running the rest of the callbacks.
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-03-12 10:45:34 +08:00
|
|
|
// We don't select threads as we go through them testing breakpoint
|
2018-05-01 00:49:04 +08:00
|
|
|
// conditions and running commands. So we need to set the thread for
|
|
|
|
// expression evaluation here:
|
2016-03-12 10:45:34 +08:00
|
|
|
ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
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
|
2018-05-01 00:49:04 +08:00
|
|
|
// asynchronous breakpoint commands or expressions. That could
|
|
|
|
// lead to infinite recursion if the command or condition re-calls
|
|
|
|
// the function with this breakpoint.
|
2013-04-30 07:30:46 +08:00
|
|
|
// 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
|
2018-05-01 00:49:04 +08:00
|
|
|
// function that hits another breakpoint, and only stop running
|
|
|
|
// commands when we see the same breakpoint hit a second time.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop_is_valid = true;
|
2018-11-30 17:45:52 +08:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "StopInfoBreakpoint::PerformAction - Hit a "
|
|
|
|
"breakpoint while running an expression,"
|
|
|
|
" not running commands to avoid recursion.");
|
2013-04-30 07:30:46 +08:00
|
|
|
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;
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"StopInfoBreakpoint::PerformAction - in expression, "
|
|
|
|
"continuing: %s.",
|
|
|
|
m_should_stop ? "true" : "false");
|
2013-04-30 07:30:46 +08:00
|
|
|
process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
|
2018-12-11 06:30:19 +08:00
|
|
|
"Warning: hit breakpoint while running function, skipping "
|
|
|
|
"commands and conditions to prevent recursion.\n");
|
2016-02-19 02:52:47 +08:00
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2016-02-19 02:52:47 +08:00
|
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, false);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-10-22 09:54:17 +08:00
|
|
|
// For safety's sake let's also grab an extra reference to the
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-10-22 09:54:17 +08:00
|
|
|
std::vector<lldb::BreakpointSP> location_owners;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
for (size_t j = 0; j < num_owners; j++) {
|
2015-07-30 01:51:36 +08:00
|
|
|
BreakpointLocationSP loc(site_locations.GetByIndex(j));
|
2014-10-22 09:54:17 +08:00
|
|
|
location_owners.push_back(loc->GetBreakpoint().shared_from_this());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
for (size_t j = 0; j < num_owners; j++) {
|
|
|
|
lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
|
2017-08-04 02:13:24 +08:00
|
|
|
StreamString loc_desc;
|
|
|
|
if (log) {
|
|
|
|
bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
|
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
// If another action disabled this breakpoint or its location, then
|
|
|
|
// don't run the actions.
|
|
|
|
if (!bp_loc_sp->IsEnabled() ||
|
2016-02-19 02:52:47 +08:00
|
|
|
!bp_loc_sp->GetBreakpoint().IsEnabled())
|
2013-04-30 07:30:46 +08:00
|
|
|
continue;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
// The breakpoint site may have many locations associated with it,
|
2018-05-01 00:49:04 +08:00
|
|
|
// not all of them valid for this thread. Skip the ones that
|
|
|
|
// aren't:
|
2013-04-30 07:30:46 +08:00
|
|
|
if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
|
2016-09-07 04:57:50 +08:00
|
|
|
if (log) {
|
2019-07-25 01:56:10 +08:00
|
|
|
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()));
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
continue;
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
|
|
|
|
2017-08-04 02:13:24 +08:00
|
|
|
internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
// First run the precondition, but since the precondition is per
|
2018-05-01 00:49:04 +08:00
|
|
|
// breakpoint, only run it once per breakpoint.
|
2013-04-30 07:30:46 +08:00
|
|
|
std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
|
|
|
|
precondition_breakpoints.insert(
|
|
|
|
bp_loc_sp->GetBreakpoint().GetID());
|
|
|
|
if (!result.second)
|
|
|
|
continue;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-04-23 08:28:25 +08:00
|
|
|
bool precondition_result =
|
2013-04-30 07:30:46 +08:00
|
|
|
bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
|
|
|
|
if (!precondition_result)
|
|
|
|
continue;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
// Next run the condition for the breakpoint. If that says we
|
2018-05-01 00:49:04 +08:00
|
|
|
// should stop, then we'll run the callback for the breakpoint. If
|
|
|
|
// the callback says we shouldn't stop that will win.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
if (bp_loc_sp->GetConditionText() != nullptr) {
|
2017-05-12 12:51:55 +08:00
|
|
|
Status condition_error;
|
2013-04-30 07:30:46 +08:00
|
|
|
bool condition_says_stop =
|
|
|
|
bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-01-26 10:19:28 +08:00
|
|
|
if (!condition_error.Success()) {
|
2013-04-30 07:30:46 +08:00
|
|
|
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>");
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
error_sp->PutCString(err_str);
|
|
|
|
error_sp->EOL();
|
|
|
|
error_sp->Flush();
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Condition evaluated for breakpoint %s on thread "
|
|
|
|
"0x%llx conditon_says_stop: %i.",
|
|
|
|
loc_desc.GetData(),
|
|
|
|
static_cast<unsigned long long>(thread_sp->GetID()),
|
|
|
|
condition_says_stop);
|
2013-04-30 07:30:46 +08:00
|
|
|
if (!condition_says_stop) {
|
|
|
|
// We don't want to increment the hit count of breakpoints if
|
2018-05-01 00:49:04 +08:00
|
|
|
// the condition fails. We've already bumped it by the time
|
|
|
|
// we get here, so undo the bump:
|
2013-04-30 07:30:46 +08:00
|
|
|
bp_loc_sp->UndoBumpHitCount();
|
|
|
|
continue;
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
|
|
|
|
2017-08-04 02:13:24 +08:00
|
|
|
// 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())
|
|
|
|
{
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Continuing breakpoint %s as AutoContinue was set.",
|
|
|
|
loc_desc.GetData());
|
2017-08-04 02:13:24 +08:00
|
|
|
// 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;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
// 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
|
2013-04-30 07:30:46 +08:00
|
|
|
// change.
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
|
|
|
|
bool old_async = debugger.GetAsyncExecution();
|
|
|
|
debugger.SetAsyncExecution(true);
|
|
|
|
|
2014-08-05 09:58:14 +08:00
|
|
|
callback_says_stop = bp_loc_sp->InvokeCallback(&context);
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2015-04-23 08:28:25 +08:00
|
|
|
debugger.SetAsyncExecution(old_async);
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2017-08-04 02:13:24 +08:00
|
|
|
if (callback_says_stop && auto_continue_says_stop)
|
2015-07-30 01:51:36 +08:00
|
|
|
m_should_stop = true;
|
2017-02-15 19:42:47 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
// If we are going to stop for this breakpoint, then remove the
|
|
|
|
// breakpoint.
|
|
|
|
if (callback_says_stop && bp_loc_sp &&
|
2015-04-23 08:28:25 +08:00
|
|
|
bp_loc_sp->GetBreakpoint().IsOneShot()) {
|
2014-04-04 12:06:10 +08:00
|
|
|
thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
|
2013-04-30 07:30:46 +08:00
|
|
|
bp_loc_sp->GetBreakpoint().GetID());
|
|
|
|
}
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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
|
2016-09-07 04:57:50 +08:00
|
|
|
// here.
|
2013-04-30 07:30:46 +08:00
|
|
|
if (HasTargetRunSinceMe()) {
|
|
|
|
m_should_stop = false;
|
|
|
|
break;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-10 08:59:59 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
// 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;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
|
|
|
m_should_stop_is_valid = true;
|
|
|
|
Log *log_process(
|
|
|
|
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log_process,
|
|
|
|
"Process::%s could not find breakpoint site id: %" PRId64
|
|
|
|
"...",
|
|
|
|
__FUNCTION__, m_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2017-02-15 19:42:47 +08:00
|
|
|
|
2018-12-15 08:15:33 +08:00
|
|
|
if ((!m_should_stop || internal_breakpoint) &&
|
|
|
|
thread_sp->CompletedPlanOverridesBreakpoint()) {
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Override should_stop decision when we have completed step plan
|
|
|
|
// additionally to the breakpoint
|
2017-02-15 19:42:47 +08:00
|
|
|
m_should_stop = true;
|
|
|
|
|
2019-08-16 05:37:52 +08:00
|
|
|
// 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();
|
2017-02-15 19:42:47 +08:00
|
|
|
}
|
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Process::%s returning from action with m_should_stop: %d.",
|
|
|
|
__FUNCTION__, m_should_stop);
|
2010-08-10 08:59:59 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
bool m_should_stop;
|
|
|
|
bool m_should_stop_is_valid;
|
2011-02-08 13:20:59 +08:00
|
|
|
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.
|
2011-10-28 09:12:19 +08:00
|
|
|
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.
|
2012-10-06 03:16:31 +08:00
|
|
|
lldb::break_id_t m_break_id;
|
|
|
|
bool m_was_one_shot;
|
2010-08-04 09:40:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// StopInfoWatchpoint
|
|
|
|
|
|
|
|
class StopInfoWatchpoint : public StopInfo {
|
|
|
|
public:
|
2012-11-10 10:08:14 +08:00
|
|
|
// Make sure watchpoint is properly disabled and subsequently enabled while
|
|
|
|
// performing watchpoint actions.
|
|
|
|
class WatchpointSentry {
|
|
|
|
public:
|
2016-10-26 04:34:32 +08:00
|
|
|
WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
|
|
|
|
watchpoint_sp(w_sp) {
|
|
|
|
if (process_sp && watchpoint_sp) {
|
2012-12-18 10:03:49 +08:00
|
|
|
const bool notify = false;
|
2016-10-26 04:34:32 +08:00
|
|
|
watchpoint_sp->TurnOnEphemeralMode();
|
|
|
|
process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
|
|
|
|
process_sp->AddPreResumeAction(SentryPreResumeAction, this);
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
|
|
|
}
|
2016-10-26 04:34:32 +08:00
|
|
|
|
|
|
|
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);
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2016-10-26 04:34:32 +08:00
|
|
|
|
|
|
|
~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;
|
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
private:
|
2016-10-26 04:34:32 +08:00
|
|
|
ProcessSP process_sp;
|
|
|
|
WatchpointSP watchpoint_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
};
|
2015-10-24 02:39:37 +08:00
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
StopInfoWatchpoint(Thread &thread, break_id_t watch_id,
|
2015-08-13 11:44:09 +08:00
|
|
|
lldb::addr_t watch_hit_addr)
|
2010-10-15 07:45:03 +08:00
|
|
|
: StopInfo(thread, watch_id), m_should_stop(false),
|
2010-08-04 09:40:35 +08:00
|
|
|
m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
~StopInfoWatchpoint() override = default;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
2012-11-10 10:08:14 +08:00
|
|
|
if (m_description.empty()) {
|
|
|
|
StreamString strm;
|
2012-11-30 05:49:15 +08:00
|
|
|
strm.Printf("watchpoint %" PRIi64, m_value);
|
2016-11-17 05:15:24 +08:00
|
|
|
m_description = strm.GetString();
|
2012-11-10 10:08:14 +08:00
|
|
|
}
|
|
|
|
return m_description.c_str();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-11-10 10:08:14 +08:00
|
|
|
|
|
|
|
protected:
|
2015-10-24 02:39:37 +08:00
|
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
2018-05-01 00:49:04 +08:00
|
|
|
// ShouldStop() method is idempotent and should not affect hit count. See
|
|
|
|
// Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
|
2011-10-18 02:58:00 +08:00
|
|
|
// -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
|
|
|
|
// Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
|
|
|
|
// StopInfoWatchpoint::ShouldStop() and
|
|
|
|
// Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
|
|
|
|
// StopInfoWatchpoint::PerformAction().
|
2011-09-22 06:47:15 +08:00
|
|
|
if (m_should_stop_is_valid)
|
|
|
|
return m_should_stop;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
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);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Process::%s could not find watchpoint location id: %" PRId64
|
|
|
|
"...",
|
|
|
|
__FUNCTION__, GetValue());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2011-09-22 06:47:15 +08:00
|
|
|
m_should_stop_is_valid = true;
|
|
|
|
return m_should_stop;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2013-02-23 05:23:43 +08:00
|
|
|
assert(m_should_stop_is_valid);
|
2011-09-22 06:47:15 +08:00
|
|
|
return m_should_stop;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
void PerformAction(Event *event_ptr) override {
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
|
2011-10-18 02:58:00 +08:00
|
|
|
// We're going to calculate if we should stop or not in some way during the
|
2018-05-01 00:49:04 +08:00
|
|
|
// course of this code. Also by default we're going to stop, so set that
|
|
|
|
// here.
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2016-10-26 04:34:32 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
WatchpointSP wp_sp(
|
|
|
|
thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
|
2016-10-26 04:34:32 +08:00
|
|
|
GetValue()));
|
2013-04-30 07:30:46 +08:00
|
|
|
if (wp_sp) {
|
|
|
|
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
|
2016-10-26 04:34:32 +08:00
|
|
|
ProcessSP process_sp = exe_ctx.GetProcessSP();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-22 06:47:15 +08:00
|
|
|
{
|
2013-04-30 07:30:46 +08:00
|
|
|
// check if this process is running on an architecture where
|
2018-05-01 00:49:04 +08:00
|
|
|
// watchpoints trigger before the associated instruction runs. if so,
|
|
|
|
// disable the WP, single-step and then re-enable the watchpoint
|
2016-10-26 04:34:32 +08:00
|
|
|
if (process_sp) {
|
2013-05-04 08:39:52 +08:00
|
|
|
uint32_t num;
|
|
|
|
bool wp_triggers_after;
|
2016-10-26 04:34:32 +08:00
|
|
|
|
|
|
|
if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
|
2013-04-30 07:30:46 +08:00
|
|
|
.Success()) {
|
|
|
|
if (!wp_triggers_after) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// We need to preserve the watch_index before watchpoint is
|
|
|
|
// disable. Since Watchpoint::SetEnabled will clear the watch
|
|
|
|
// index. This will fix TestWatchpointIter failure
|
2016-12-09 21:54:47 +08:00
|
|
|
Watchpoint *wp = wp_sp.get();
|
|
|
|
uint32_t watch_index = wp->GetHardwareIndex();
|
|
|
|
process_sp->DisableWatchpoint(wp, false);
|
2013-04-30 07:30:46 +08:00
|
|
|
StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
|
|
|
|
assert(stored_stop_info_sp.get() == this);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-11-15 09:18:15 +08:00
|
|
|
Status new_plan_status;
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadPlanSP new_plan_sp(
|
|
|
|
thread_sp->QueueThreadPlanForStepSingleInstruction(
|
2018-11-15 09:18:15 +08:00
|
|
|
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);
|
|
|
|
}
|
2016-10-26 04:34:32 +08:00
|
|
|
process_sp->GetThreadList().SetSelectedThreadByID(
|
2013-04-30 07:30:46 +08:00
|
|
|
thread_sp->GetID());
|
2016-10-26 04:34:32 +08:00
|
|
|
process_sp->ResumeSynchronous(nullptr);
|
|
|
|
process_sp->GetThreadList().SetSelectedThreadByID(
|
2013-04-30 07:30:46 +08:00
|
|
|
thread_sp->GetID());
|
|
|
|
thread_sp->SetStopInfo(stored_stop_info_sp);
|
2016-12-09 21:54:47 +08:00
|
|
|
process_sp->EnableWatchpoint(wp, false);
|
|
|
|
wp->SetHardwareIndex(watch_index);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2011-09-22 06:47:15 +08:00
|
|
|
|
2016-10-26 04:34:32 +08:00
|
|
|
// This sentry object makes sure the current watchpoint is disabled
|
2018-05-01 00:49:04 +08:00
|
|
|
// while performing watchpoint actions, and it is then enabled after we
|
|
|
|
// are finished.
|
2016-10-26 04:34:32 +08:00
|
|
|
WatchpointSentry sentry(process_sp, wp_sp);
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
/*
|
2013-04-30 07:30:46 +08:00
|
|
|
* MIPS: Last 3bits of the watchpoint address are masked by the kernel.
|
2015-08-13 11:44:09 +08:00
|
|
|
* For example:
|
2013-04-30 07:30:46 +08:00
|
|
|
* 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is
|
2015-08-13 11:44:09 +08:00
|
|
|
* set at 'm', then
|
2013-04-30 07:30:46 +08:00
|
|
|
* 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
|
2015-08-13 11:44:09 +08:00
|
|
|
* packet. If watchpoint
|
2013-04-30 07:30:46 +08:00
|
|
|
* is not set on this address by user then this do not stop.
|
2016-09-07 04:57:50 +08:00
|
|
|
*/
|
2013-04-30 07:30:46 +08:00
|
|
|
if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) {
|
2015-08-13 11:44:09 +08:00
|
|
|
WatchpointSP wp_hit_sp =
|
2013-04-30 07:30:46 +08:00
|
|
|
thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
|
2015-08-13 11:44:09 +08:00
|
|
|
m_watch_hit_addr);
|
|
|
|
if (!wp_hit_sp) {
|
|
|
|
m_should_stop = false;
|
2013-04-30 07:30:46 +08:00
|
|
|
wp_sp->IncrementFalseAlarmsAndReviseHitCount();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2011-09-22 06:47:15 +08:00
|
|
|
|
2015-11-03 17:04:33 +08:00
|
|
|
// 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
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2015-11-03 17:04:33 +08:00
|
|
|
if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
|
2015-08-13 11:44:09 +08:00
|
|
|
m_should_stop = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-10-26 04:34:32 +08:00
|
|
|
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
|
|
|
|
|
2016-02-19 02:52:47 +08:00
|
|
|
if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
|
2013-04-30 07:30:46 +08:00
|
|
|
// We need to make sure the user sees any parse errors in their
|
2016-11-08 12:52:16 +08:00
|
|
|
// condition, so we'll hook the constructor errors up to the
|
|
|
|
// debugger's Async I/O.
|
2014-05-05 10:26:40 +08:00
|
|
|
ExpressionResults result_code;
|
2013-11-05 03:35:17 +08:00
|
|
|
EvaluateExpressionOptions expr_options;
|
|
|
|
expr_options.SetUnwindOnError(true);
|
|
|
|
expr_options.SetIgnoreBreakpoints(true);
|
2013-04-30 07:30:46 +08:00
|
|
|
ValueObjectSP result_value_sp;
|
2017-05-12 12:51:55 +08:00
|
|
|
Status error;
|
2016-02-19 02:52:47 +08:00
|
|
|
result_code = UserExpression::Evaluate(
|
2016-11-08 12:52:16 +08:00
|
|
|
exe_ctx, expr_options, wp_sp->GetConditionText(),
|
|
|
|
llvm::StringRef(), result_value_sp, error);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-05-05 10:47:44 +08:00
|
|
|
if (result_code == eExpressionCompleted) {
|
2013-04-30 07:30:46 +08:00
|
|
|
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
|
2018-05-01 00:49:04 +08:00
|
|
|
// the watchpoint whether it should stop (aka ignore count
|
|
|
|
// and friends). See also StopInfoWatchpoint::ShouldStop()
|
|
|
|
// as well as Process::ProcessEventData::DoOnRemoval().
|
2015-08-13 11:44:09 +08:00
|
|
|
m_should_stop = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Condition successfully evaluated, result is %s.\n",
|
|
|
|
m_should_stop ? "true" : "false");
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
m_should_stop = true;
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(
|
|
|
|
log,
|
|
|
|
"Failed to get an integer result from the expression.");
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-04-30 07:30:46 +08:00
|
|
|
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>");
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
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;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-22 06:47:15 +08:00
|
|
|
}
|
2012-08-22 06:06:34 +08:00
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
// If the condition says to stop, we run the callback to further decide
|
|
|
|
// whether to stop.
|
|
|
|
if (m_should_stop) {
|
2016-10-26 04:34:32 +08:00
|
|
|
// 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);
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
StoppointCallbackContext context(event_ptr, exe_ctx, false);
|
|
|
|
bool stop_requested = wp_sp->InvokeCallback(&context);
|
2016-10-26 04:34:32 +08:00
|
|
|
|
|
|
|
debugger.SetAsyncExecution(old_async);
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// 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.
|
2013-04-30 07:30:46 +08:00
|
|
|
if (HasTargetRunSinceMe())
|
2013-07-03 05:12:44 +08:00
|
|
|
m_should_stop = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-07-03 05:12:44 +08:00
|
|
|
if (m_should_stop && !stop_requested) {
|
2013-07-19 05:48:26 +08:00
|
|
|
// We have been vetoed by the callback mechanism.
|
|
|
|
m_should_stop = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
}
|
2015-08-13 11:44:09 +08:00
|
|
|
// Finally, if we are going to stop, print out the new & old values:
|
|
|
|
if (m_should_stop) {
|
|
|
|
wp_sp->CaptureWatchedValue(exe_ctx);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-08-13 11:44:09 +08:00
|
|
|
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
|
|
|
|
StreamSP output_sp = debugger.GetAsyncOutputStream();
|
2015-10-06 13:25:17 +08:00
|
|
|
wp_sp->DumpSnapshots(output_sp.get());
|
2013-04-30 07:30:46 +08:00
|
|
|
output_sp->EOL();
|
|
|
|
output_sp->Flush();
|
2015-10-06 13:25:17 +08:00
|
|
|
}
|
|
|
|
|
2013-04-30 07:30:46 +08:00
|
|
|
} else {
|
|
|
|
Log *log_process(
|
|
|
|
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
|
2011-10-18 02:58:00 +08:00
|
|
|
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log_process,
|
|
|
|
"Process::%s could not find watchpoint id: %" PRId64 "...",
|
|
|
|
__FUNCTION__, m_value);
|
2012-08-10 07:10:57 +08:00
|
|
|
}
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log,
|
|
|
|
"Process::%s returning from action with m_should_stop: %d.",
|
|
|
|
__FUNCTION__, m_should_stop);
|
2013-04-30 07:30:46 +08:00
|
|
|
|
|
|
|
m_should_stop_is_valid = true;
|
2011-10-18 02:58:00 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
private:
|
2011-09-22 06:47:15 +08:00
|
|
|
bool m_should_stop;
|
|
|
|
bool m_should_stop_is_valid;
|
2015-08-13 11:44:09 +08:00
|
|
|
lldb::addr_t m_watch_hit_addr;
|
2010-08-04 09:40:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// StopInfoUnixSignal
|
|
|
|
|
|
|
|
class StopInfoUnixSignal : public StopInfo {
|
|
|
|
public:
|
Report inferior SIGSEGV as a signal instead of an exception on linux
Summary:
Previously, we reported inferior receiving SIGSEGV (or SIGILL, SIGFPE, SIGBUS) as an "exception"
to LLDB, presumably to match OSX behaviour. Beside the fact that we were basically lying to the
user, this was also causing problems with inferiors which handle SIGSEGV by themselves, since
LLDB was unable to reinject this signal back into the inferior.
This commit changes LLGS to report SIGSEGV as a signal. This has necessitated some changes in the
test-suite, which had previously used eStopReasonException to locate threads that crashed. Now it
uses platform-specific logic, which in the case of linux searches for eStopReasonSignaled with
signal=SIGSEGV.
I have also added the ability to set the description of StopInfoUnixSignal using the description
field of the gdb-remote packet. The linux stub uses this to display additional information about
the segfault (invalid address, address access protected, etc.).
Test Plan: All tests pass on linux and osx.
Reviewers: ovyalov, clayborg, emaste
Subscribers: emaste, lldb-commits
Differential Revision: http://reviews.llvm.org/D10057
llvm-svn: 238549
2015-05-29 18:13:03 +08:00
|
|
|
StopInfoUnixSignal(Thread &thread, int signo, const char *description)
|
2011-06-04 09:26:29 +08:00
|
|
|
: StopInfo(thread, signo) {
|
Report inferior SIGSEGV as a signal instead of an exception on linux
Summary:
Previously, we reported inferior receiving SIGSEGV (or SIGILL, SIGFPE, SIGBUS) as an "exception"
to LLDB, presumably to match OSX behaviour. Beside the fact that we were basically lying to the
user, this was also causing problems with inferiors which handle SIGSEGV by themselves, since
LLDB was unable to reinject this signal back into the inferior.
This commit changes LLGS to report SIGSEGV as a signal. This has necessitated some changes in the
test-suite, which had previously used eStopReasonException to locate threads that crashed. Now it
uses platform-specific logic, which in the case of linux searches for eStopReasonSignaled with
signal=SIGSEGV.
I have also added the ability to set the description of StopInfoUnixSignal using the description
field of the gdb-remote packet. The linux stub uses this to display additional information about
the segfault (invalid address, address access protected, etc.).
Test Plan: All tests pass on linux and osx.
Reviewers: ovyalov, clayborg, emaste
Subscribers: emaste, lldb-commits
Differential Revision: http://reviews.llvm.org/D10057
llvm-svn: 238549
2015-05-29 18:13:03 +08:00
|
|
|
SetDescription(description);
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
~StopInfoUnixSignal() override = default;
|
2010-08-04 09:40:35 +08:00
|
|
|
|
2015-07-14 09:09:28 +08:00
|
|
|
StopReason GetStopReason() const override { return eStopReasonSignal; }
|
2013-02-09 09:29:05 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
bool ShouldStopSynchronous(Event *event_ptr) override {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp)
|
2015-07-14 09:09:28 +08:00
|
|
|
return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
|
2013-04-30 07:30:46 +08:00
|
|
|
return false;
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2015-10-24 02:39:37 +08:00
|
|
|
|
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp)
|
2016-02-19 02:52:47 +08:00
|
|
|
return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
|
2013-04-30 07:30:46 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
// If should stop returns false, check if we should notify of this event
|
2015-10-24 02:39:37 +08:00
|
|
|
bool DoShouldNotify(Event *event_ptr) override {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
2015-07-14 09:09:28 +08:00
|
|
|
bool should_notify =
|
|
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
|
2013-04-30 07:30:46 +08:00
|
|
|
if (should_notify) {
|
|
|
|
StreamString strm;
|
|
|
|
strm.Printf(
|
|
|
|
"thread %d received signal: %s", thread_sp->GetIndexID(),
|
2015-07-14 09:09:28 +08:00
|
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
|
|
|
|
m_value));
|
2013-04-30 07:30:46 +08:00
|
|
|
Process::ProcessEventData::AddRestartedReason(event_ptr,
|
|
|
|
strm.GetData());
|
|
|
|
}
|
|
|
|
return should_notify;
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2013-04-30 07:30:46 +08:00
|
|
|
return true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
void WillResume(lldb::StateType resume_state) override {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
2016-02-19 02:52:47 +08:00
|
|
|
if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
|
|
|
|
m_value))
|
2013-04-30 07:30:46 +08:00
|
|
|
thread_sp->SetResumeSignal(m_value);
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
2010-08-04 09:40:35 +08:00
|
|
|
if (m_description.empty()) {
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp) {
|
|
|
|
StreamString strm;
|
2015-07-14 09:09:28 +08:00
|
|
|
const char *signal_name =
|
|
|
|
thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
|
|
|
|
m_value);
|
2013-04-30 07:30:46 +08:00
|
|
|
if (signal_name)
|
|
|
|
strm.Printf("signal %s", signal_name);
|
|
|
|
else
|
|
|
|
strm.Printf("signal %" PRIi64, m_value);
|
2016-11-17 05:15:24 +08:00
|
|
|
m_description = strm.GetString();
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return m_description.c_str();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// StopInfoTrace
|
|
|
|
|
|
|
|
class StopInfoTrace : public StopInfo {
|
|
|
|
public:
|
|
|
|
StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
|
2015-10-24 02:39:37 +08:00
|
|
|
|
|
|
|
~StopInfoTrace() override = default;
|
|
|
|
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonTrace; }
|
2010-08-04 09:40:35 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
2011-06-04 09:26:29 +08:00
|
|
|
if (m_description.empty())
|
2015-10-24 02:39:37 +08:00
|
|
|
return "trace";
|
2011-06-04 09:26:29 +08:00
|
|
|
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);
|
|
|
|
}
|
2015-10-24 02:39:37 +08:00
|
|
|
|
|
|
|
~StopInfoException() override = default;
|
|
|
|
|
|
|
|
StopReason GetStopReason() const override { return eStopReasonException; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
2011-06-04 09:26:29 +08:00
|
|
|
if (m_description.empty())
|
|
|
|
return "exception";
|
|
|
|
else
|
|
|
|
return m_description.c_str();
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// StopInfoThreadPlan
|
|
|
|
|
|
|
|
class StopInfoThreadPlan : public StopInfo {
|
|
|
|
public:
|
2015-09-05 04:49:51 +08:00
|
|
|
StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
|
|
|
|
ExpressionVariableSP &expression_variable_sp)
|
2010-08-04 09:40:35 +08:00
|
|
|
: StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
|
2014-07-08 09:07:32 +08:00
|
|
|
m_return_valobj_sp(return_valobj_sp),
|
|
|
|
m_expression_variable_sp(expression_variable_sp) {}
|
2010-08-04 09:40:35 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
~StopInfoThreadPlan() override = default;
|
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override {
|
2010-08-04 09:40:35 +08:00
|
|
|
if (m_description.empty()) {
|
|
|
|
StreamString strm;
|
|
|
|
m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
|
2016-11-17 05:15:24 +08:00
|
|
|
m_description = strm.GetString();
|
2011-12-17 09:35:57 +08:00
|
|
|
}
|
2015-09-05 04:49:51 +08:00
|
|
|
return m_description.c_str();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2015-09-05 04:49:51 +08:00
|
|
|
ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-07-08 09:07:32 +08:00
|
|
|
ExpressionVariableSP GetExpressionVariable() {
|
|
|
|
return m_expression_variable_sp;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-02-09 09:29:05 +08:00
|
|
|
protected:
|
2015-10-24 02:39:37 +08:00
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
2013-02-09 09:29:05 +08:00
|
|
|
if (m_plan_sp)
|
|
|
|
return m_plan_sp->ShouldStop(event_ptr);
|
|
|
|
else
|
|
|
|
return StopInfo::ShouldStop(event_ptr);
|
|
|
|
}
|
2010-08-04 09:40:35 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
ThreadPlanSP m_plan_sp;
|
2011-12-17 09:35:57 +08:00
|
|
|
ValueObjectSP m_return_valobj_sp;
|
2015-09-05 04:49:51 +08:00
|
|
|
ExpressionVariableSP m_expression_variable_sp;
|
2010-08-04 09:40:35 +08:00
|
|
|
};
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-12-05 10:50:45 +08:00
|
|
|
// StopInfoExec
|
|
|
|
|
2012-12-05 08:16:59 +08:00
|
|
|
class StopInfoExec : public StopInfo {
|
|
|
|
public:
|
|
|
|
StopInfoExec(Thread &thread)
|
|
|
|
: StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
|
2015-10-24 02:39:37 +08:00
|
|
|
|
|
|
|
~StopInfoExec() override = default;
|
|
|
|
|
2017-12-05 10:50:45 +08:00
|
|
|
bool ShouldStop(Event *event_ptr) override {
|
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp)
|
|
|
|
return thread_sp->GetProcess()->GetStopOnExec();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
StopReason GetStopReason() const override { return eStopReasonExec; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-10-24 02:39:37 +08:00
|
|
|
const char *GetDescription() override { return "exec"; }
|
|
|
|
|
2012-12-05 08:16:59 +08:00
|
|
|
protected:
|
2015-10-24 02:39:37 +08:00
|
|
|
void PerformAction(Event *event_ptr) override {
|
2012-12-05 08:16:59 +08:00
|
|
|
// Only perform the action once
|
|
|
|
if (m_performed_action)
|
|
|
|
return;
|
|
|
|
m_performed_action = true;
|
2013-04-30 07:30:46 +08:00
|
|
|
ThreadSP thread_sp(m_thread_wp.lock());
|
|
|
|
if (thread_sp)
|
|
|
|
thread_sp->GetProcess()->DidExec();
|
2012-12-05 08:16:59 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-12-05 08:16:59 +08:00
|
|
|
bool m_performed_action;
|
|
|
|
};
|
|
|
|
|
2011-08-09 10:12:22 +08:00
|
|
|
} // namespace lldb_private
|
2010-08-04 09:40:35 +08:00
|
|
|
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
|
|
|
|
break_id_t break_id) {
|
|
|
|
return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
|
|
|
|
}
|
|
|
|
|
2010-10-15 07:45:03 +08:00
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
|
|
|
|
break_id_t break_id,
|
|
|
|
bool should_stop) {
|
|
|
|
return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
|
|
|
|
}
|
|
|
|
|
2010-08-04 09:40:35 +08:00
|
|
|
StopInfoSP
|
2015-08-13 11:44:09 +08:00
|
|
|
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));
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
|
Report inferior SIGSEGV as a signal instead of an exception on linux
Summary:
Previously, we reported inferior receiving SIGSEGV (or SIGILL, SIGFPE, SIGBUS) as an "exception"
to LLDB, presumably to match OSX behaviour. Beside the fact that we were basically lying to the
user, this was also causing problems with inferiors which handle SIGSEGV by themselves, since
LLDB was unable to reinject this signal back into the inferior.
This commit changes LLGS to report SIGSEGV as a signal. This has necessitated some changes in the
test-suite, which had previously used eStopReasonException to locate threads that crashed. Now it
uses platform-specific logic, which in the case of linux searches for eStopReasonSignaled with
signal=SIGSEGV.
I have also added the ability to set the description of StopInfoUnixSignal using the description
field of the gdb-remote packet. The linux stub uses this to display additional information about
the segfault (invalid address, address access protected, etc.).
Test Plan: All tests pass on linux and osx.
Reviewers: ovyalov, clayborg, emaste
Subscribers: emaste, lldb-commits
Differential Revision: http://reviews.llvm.org/D10057
llvm-svn: 238549
2015-05-29 18:13:03 +08:00
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
|
|
|
|
const char *description) {
|
|
|
|
return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
|
|
|
|
return StopInfoSP(new StopInfoTrace(thread));
|
|
|
|
}
|
|
|
|
|
2014-07-08 09:07:32 +08:00
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithPlan(
|
|
|
|
ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
|
2015-09-05 04:49:51 +08:00
|
|
|
ExpressionVariableSP expression_variable_sp) {
|
2014-07-08 09:07:32 +08:00
|
|
|
return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
|
|
|
|
expression_variable_sp));
|
2010-08-04 09:40:35 +08:00
|
|
|
}
|
2011-06-04 09:26:29 +08:00
|
|
|
|
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
|
|
|
|
const char *description) {
|
|
|
|
return StopInfoSP(new StopInfoException(thread, description));
|
|
|
|
}
|
2011-12-17 09:35:57 +08:00
|
|
|
|
2012-12-05 08:16:59 +08:00
|
|
|
StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
|
|
|
|
return StopInfoSP(new StopInfoExec(thread));
|
|
|
|
}
|
|
|
|
|
2011-12-17 09:35:57 +08:00
|
|
|
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();
|
|
|
|
}
|
2014-07-08 09:07:32 +08:00
|
|
|
|
|
|
|
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
|
2015-09-05 04:49:51 +08:00
|
|
|
return ExpressionVariableSP();
|
2014-07-08 09:07:32 +08:00
|
|
|
}
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
|
|
|
|
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();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
ThreadSP thread_sp = stop_info_sp->GetThread();
|
|
|
|
if (!thread_sp) {
|
|
|
|
return ValueObjectSP();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
if (!frame_sp) {
|
|
|
|
return ValueObjectSP();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
const char address_string[] = "address=";
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
const char *address_loc = strstr(description, address_string);
|
|
|
|
if (!address_loc) {
|
|
|
|
return ValueObjectSP();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
address_loc += (sizeof(address_string) - 1);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
[lldb] NFC modernize codebase with modernize-use-nullptr
Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]
This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.
This is the command I ran and I to fix and format the code base:
```
run-clang-tidy.py \
-header-filter='.*' \
-checks='-*,modernize-use-nullptr' \
-fix ~/dev/llvm-project/lldb/.* \
-format \
-style LLVM \
-p ~/llvm-builds/debug-ninja-gcc
```
NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.
NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.
Reviewers: martong, espindola, shafik, #lldb, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits
Tags: #lldb, #llvm
Differential Revision: https://reviews.llvm.org/D61847
llvm-svn: 361484
2019-05-23 19:14:47 +08:00
|
|
|
uint64_t address = strtoull(address_loc, nullptr, 0);
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
if (crashing_address) {
|
|
|
|
*crashing_address = address;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Added the "frame diagnose" command and use its output to make crash info better.
When a process stops due to a crash, we get the crashing instruction and the
crashing memory location (if there is one). From the user's perspective it is
often unclear what the reason for the crash is in a symbolic sense.
To address this, I have added new fuctionality to StackFrame to parse the
disassembly and reconstruct the sequence of dereferneces and offsets that were
applied to a known variable (or fuction retrn value) to obtain the invalid
pointer.
This makes use of enhancements in the disassembler, as well as new information
provided by the DWARF expression infrastructure, and is exposed through a
"frame diagnose" command. It is also used to provide symbolic information, when
available, in the event of a crash.
The algorithm is very rudimentary, and it needs a bunch of work, including
- better parsing for assembly, preferably with help from LLVM
- support for non-Apple platforms
- cleanup of the algorithm core, preferably to make it all work in terms of
Operands instead of register/offset pairs
- improvement of the GetExpressioPath() logic to make prettier expression
paths, and
- better handling of vtables.
I welcome all suggestios, improvements, and testcases.
llvm-svn: 280692
2016-09-06 12:48:36 +08:00
|
|
|
return frame_sp->GuessValueForAddress(address);
|
|
|
|
}
|