33 : m_thread_wp(thread.shared_from_this()),
34 m_stop_id(thread.GetProcess()->GetStopID()),
35 m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
42 return thread_sp->GetProcess()->GetStopID() ==
m_stop_id;
49 m_stop_id = thread_sp->GetProcess()->GetStopID();
50 m_resume_id = thread_sp->GetProcess()->GetResumeID();
70 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
71 uint32_t last_user_expression_id =
72 thread_sp->GetProcess()->GetLastUserExpressionResumeID();
75 }
else if (curr_resume_id > last_user_expression_id) {
110 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(
m_value));
112 uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
113 if (num_owners == 1) {
116 Breakpoint & bkpt = bp_loc_sp->GetBreakpoint();
123 for (uint32_t i = 0; i < num_owners; i++) {
124 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
130 m_address = bp_site_sp->GetLoadAddress();
139 process_sp->GetBreakpointSiteList().FindByID(
m_value));
141 return bp_site_sp->ValidForThisThread(thread);
154 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(
m_value));
158 bp_site_sp->BumpHitCounts();
164 "Process::%s could not find breakpoint site id: %" PRId64
186 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(
m_value));
191 if (bp_site_sp->IsInternal()) {
192 size_t num_owners = bp_site_sp->GetNumberOfOwners();
193 for (
size_t idx = 0; idx < num_owners; idx++) {
194 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
196 .GetBreakpointKind();
197 if (kind !=
nullptr) {
204 strm.
Printf(
"breakpoint ");
211 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
214 if (break_sp->IsInternal()) {
215 const char *kind = break_sp->GetBreakpointKind();
227 strm.
Printf(
"breakpoint %d which has been deleted.",
231 strm.
Printf(
"breakpoint site %" PRIi64
232 " which has been deleted - unknown address",
235 strm.
Printf(
"breakpoint site %" PRIi64
236 " which has been deleted - was at 0x%" PRIx64,
259 bool all_stopping_locs_internal =
true;
266 if (!thread_sp->IsValid()) {
269 LLDB_LOGF(log,
"PerformAction got called with an invalid thread.");
277 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(
m_value));
278 std::unordered_set<break_id_t> precondition_breakpoints;
285 bool actually_hit_any_locations =
false;
291 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
293 if (num_owners == 0) {
295 actually_hit_any_locations =
true;
321 bool async_should_stop =
false;
324 bool actually_said_continue =
false;
354 if (thread_sp->CompletedPlanOverridesBreakpoint()) {
356 thread_sp->ResetStopInfo();
360 LLDB_LOGF(log,
"StopInfoBreakpoint::PerformAction - Hit a "
361 "breakpoint while running an expression,"
362 " not running commands to avoid recursion.");
363 bool ignoring_breakpoints =
371 "StopInfoBreakpoint::PerformAction - in expression, "
375 "hit breakpoint while running function, skipping commands "
376 "and conditions to prevent recursion",
391 std::vector<lldb::BreakpointSP> location_owners;
393 for (
size_t j = 0; j < num_owners; j++) {
395 location_owners.push_back(loc->GetBreakpoint().shared_from_this());
398 for (
size_t j = 0; j < num_owners; j++) {
406 if (!bp_loc_sp->IsEnabled() ||
407 !bp_loc_sp->GetBreakpoint().IsEnabled())
413 if (!bp_loc_sp->ValidForThisThread(*thread_sp)) {
416 "Breakpoint %s hit on thread 0x%llx but it was not "
417 "for this thread, continuing.",
419 static_cast<unsigned long long>(thread_sp->GetID()));
426 std::pair<std::unordered_set<break_id_t>::iterator,
bool> result =
427 precondition_breakpoints.insert(
428 bp_loc_sp->GetBreakpoint().GetID());
432 bool precondition_result =
433 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
434 if (!precondition_result) {
435 actually_said_continue =
true;
442 if (bp_loc_sp->GetConditionText() ==
nullptr)
443 actually_hit_any_locations =
true;
446 bool condition_says_stop =
447 bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
449 if (!condition_error.
Success()) {
452 actually_hit_any_locations =
true;
453 const char *err_str =
454 condition_error.
AsCString(
"<unknown error>");
455 LLDB_LOGF(log,
"Error evaluating condition: \"%s\"\n", err_str);
458 strm <<
"stopped due to an error evaluating condition of "
461 strm <<
": \"" << bp_loc_sp->GetConditionText() <<
"\"\n";
469 "Condition evaluated for breakpoint %s on thread "
470 "0x%llx condition_says_stop: %i.",
472 static_cast<unsigned long long>(thread_sp->GetID()),
473 condition_says_stop);
474 if (condition_says_stop)
475 actually_hit_any_locations =
true;
480 bp_loc_sp->UndoBumpHitCount();
481 actually_said_continue =
true;
491 if (!bp_loc_sp->IgnoreCountShouldStop()) {
492 actually_said_continue =
true;
502 bool auto_continue_says_stop =
true;
503 if (bp_loc_sp->IsAutoContinue())
506 "Continuing breakpoint %s as AutoContinue was set.",
510 if (!bp_loc_sp->GetBreakpoint().IsInternal())
511 thread_sp->SetShouldReportStop(
eVoteYes);
512 auto_continue_says_stop =
false;
515 bool callback_says_stop =
true;
525 if (!bp_loc_sp->IsCallbackSynchronous()) {
526 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
530 callback_says_stop = bp_loc_sp->InvokeCallback(&context);
534 if (callback_says_stop && auto_continue_says_stop)
537 actually_said_continue =
true;
540 if (
m_should_stop && !bp_loc_sp->GetBreakpoint().IsInternal())
541 all_stopping_locs_internal =
false;
545 if (callback_says_stop && bp_loc_sp &&
546 bp_loc_sp->GetBreakpoint().IsOneShot()) {
547 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
548 bp_loc_sp->GetBreakpoint().GetID());
555 actually_said_continue =
true;
571 actually_hit_any_locations =
true;
575 "Process::%s could not find breakpoint site id: %" PRId64
581 thread_sp->CompletedPlanOverridesBreakpoint()) {
590 thread_sp->CalculatePublicStopInfo();
591 }
else if (!actually_hit_any_locations) {
595 LLDB_LOGF(log,
"Process::%s all locations failed condition checks.",
600 "Process::%s returning from action with m_should_stop: %d.",
632 const bool notify =
false;
641 bool was_disabled =
watchpoint_sp->IsDisabledDuringEphemeralMode();
643 const bool notify =
false;
706 bool current_plan)
override {
784 LLDB_LOG(log,
"We didn't run but stopped with a StopInfoWatchpoint, we "
785 "have already handled this one, don't do it again.");
792 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
GetValue()));
797 "Process::%s could not find watchpoint location id: %" PRId64
825 bool wp_triggers_after = process_sp->GetWatchpointReportedAfter();
827 if (!wp_triggers_after) {
830 = std::static_pointer_cast<StopInfoWatchpoint>(shared_from_this());
832 *(thread_sp.get()), me_as_siwp_sp, wp_sp));
835 step_over_wp_sp->SetIsControllingPlan(
true);
836 step_over_wp_sp->SetOkayToDiscard(
false);
839 error = thread_sp->QueueThreadPlan(step_over_wp_sp,
false);
841 if (!
error.Success()) {
842 LLDB_LOGF(log,
"Could not push our step over watchpoint plan: %s",
851 thread_sp->SetShouldRunBeforePublicStop(
true);
884 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
897 wp_sp->UndoHitCount();
900 if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount()) {
918 exe_ctx, expr_options, wp_sp->GetConditionText(),
919 llvm::StringRef(), result_value_sp,
error);
922 if (result_value_sp) {
924 if (result_value_sp->ResolveValue(scalar_value)) {
928 wp_sp->UndoHitCount();
933 "Condition successfully evaluated, result is %s.\n",
939 "Failed to get an integer result from the expression.");
943 const char *err_str =
error.AsCString(
"<unknown error>");
944 LLDB_LOGF(log,
"Error evaluating condition: \"%s\"\n", err_str);
947 strm <<
"stopped due to an error evaluating condition of "
950 strm <<
": \"" << wp_sp->GetConditionText() <<
"\"\n";
971 bool stop_requested = wp_sp->InvokeCallback(&context);
988 if (
m_should_stop && !wp_sp->WatchedValueReportable(exe_ctx))
993 wp_sp->CaptureWatchedValue(exe_ctx);
997 wp_sp->DumpSnapshots(output_sp.get());
1006 "Process::%s could not find watchpoint id: %" PRId64
"...",
1010 "Process::%s returning from action with m_should_stop: %d.",
1045 std::optional<int> code)
1057 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(
m_value);
1064 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(
m_value);
1072 bool should_notify =
1073 thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(
m_value);
1074 if (should_notify) {
1077 "thread {0:d} received signal: {1}", thread_sp->GetIndexID(),
1078 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsStringRef(
1083 return should_notify;
1091 if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
1093 thread_sp->SetResumeSignal(
m_value);
1101 UnixSignalsSP unix_signals = thread_sp->GetProcess()->GetUnixSignals();
1105 std::string signal_name =
1107 if (signal_name.size())
1108 strm << signal_name;
1181 return "processor trace event";
1219 return m_plan_sp->ShouldStop(event_ptr);
1241 return thread_sp->GetProcess()->GetStopOnExec();
1257 thread_sp->GetProcess()->DidExec();
1353 thread_sp->GetProcess()->DidVForkDone();
1374 bool silently_continue) {
1380 const char *description,
1381 std::optional<int> code) {
1382 thread.
GetProcess()->GetUnixSignals()->IncrementSignalHitCount(signo);
1394 expression_variable_sp));
1398 const char *description) {
1403 const char *description) {
1451 if (!stop_info_sp) {
1455 const char *description = stop_info_sp->GetDescription();
1460 ThreadSP thread_sp = stop_info_sp->GetThread();
1472 const char address_string[] =
"address=";
1474 const char *address_loc = strstr(description, address_string);
1479 address_loc += (
sizeof(address_string) - 1);
1481 uint64_t address = strtoull(address_loc,
nullptr, 0);
1482 if (crashing_address) {
1483 *crashing_address = address;
1486 return frame_sp->GuessValueForAddress(address);
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
lldb::BreakpointLocationSP GetByIndex(size_t i)
Returns a shared pointer to the breakpoint location with index i.
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
bool IsOneShot() const
Check the OneShot state.
bool IsInternal() const
Tell whether this breakpoint is an "internal" breakpoint.
A class to manage flag bits.
lldb::StreamSP GetAsyncOutputStream()
void SetAsyncExecution(bool async)
static void ReportWarning(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report warning events.
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
void SetUnwindOnError(bool unwind=false)
void SetIgnoreBreakpoints(bool ignore=false)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
Target & GetTargetRef() const
Returns a reference to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
bool IsRunningExpression() const
bool GetIgnoreBreakpointsInExpressions() const
static void AddRestartedReason(Event *event_ptr, const char *reason)
A plug-in interface definition class for debugging a process.
const ProcessModID & GetModIDRef() const
Target & GetTarget()
Get the target object pointer for this module.
unsigned long long ULongLong(unsigned long long fail_value=0) const
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
bool Success() const
Test for success condition.
void PerformAction(Event *event_ptr) override
const char * GetDescription() override
bool ShouldStopSynchronous(Event *event_ptr) override
bool IsValidForOperatingSystemThread(Thread &thread) override
bool DoShouldNotify(Event *event_ptr) override
~StopInfoBreakpoint() override=default
StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
bool m_should_perform_action
lldb::break_id_t m_break_id
StopInfoBreakpoint(Thread &thread, break_id_t break_id)
bool ShouldStop(Event *event_ptr) override
bool m_should_stop_is_valid
StopReason GetStopReason() const override
const char * GetDescription() override
~StopInfoException() override=default
StopInfoException(Thread &thread, const char *description)
StopReason GetStopReason() const override
~StopInfoExec() override=default
StopInfoExec(Thread &thread)
const char * GetDescription() override
StopReason GetStopReason() const override
void PerformAction(Event *event_ptr) override
bool ShouldStop(Event *event_ptr) override
void PerformAction(Event *event_ptr) override
bool ShouldStop(Event *event_ptr) override
StopReason GetStopReason() const override
StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
~StopInfoFork() override=default
const char * GetDescription() override
StopInfoProcessorTrace(Thread &thread, const char *description)
~StopInfoProcessorTrace() override=default
const char * GetDescription() override
StopReason GetStopReason() const override
ValueObjectSP m_return_valobj_sp
bool ShouldStop(Event *event_ptr) override
~StopInfoThreadPlan() override=default
ExpressionVariableSP m_expression_variable_sp
ExpressionVariableSP GetExpressionVariable()
const char * GetDescription() override
StopReason GetStopReason() const override
ValueObjectSP GetReturnValueObject()
StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp)
const char * GetDescription() override
~StopInfoTrace() override=default
StopReason GetStopReason() const override
StopInfoTrace(Thread &thread)
StopInfoUnixSignal(Thread &thread, int signo, const char *description, std::optional< int > code)
void WillResume(lldb::StateType resume_state) override
bool DoShouldNotify(Event *event_ptr) override
~StopInfoUnixSignal() override=default
const char * GetDescription() override
std::optional< int > m_code
bool ShouldStopSynchronous(Event *event_ptr) override
bool ShouldStop(Event *event_ptr) override
StopReason GetStopReason() const override
const char * GetDescription() override
~StopInfoVForkDone() override=default
bool ShouldStop(Event *event_ptr) override
StopInfoVForkDone(Thread &thread)
StopReason GetStopReason() const override
void PerformAction(Event *event_ptr) override
bool ShouldStop(Event *event_ptr) override
StopReason GetStopReason() const override
void PerformAction(Event *event_ptr) override
~StopInfoVFork() override=default
StopInfoVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
const char * GetDescription() override
ThreadPlanStepOverWatchpoint(Thread &thread, StopInfoWatchpointSP stop_info_sp, WatchpointSP watch_sp)
StopInfoWatchpointSP m_stop_info_sp
bool DoPlanExplainsStop(Event *event_ptr) override
bool ShouldStop(Event *event_ptr) override
bool ShouldRunBeforePublicStop() override
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
WatchpointSP watchpoint_sp
WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp)
static bool SentryPreResumeAction(void *sentry_void)
~StopInfoWatchpoint() override=default
std::shared_ptr< StopInfoWatchpoint > StopInfoWatchpointSP
StopInfoWatchpoint(Thread &thread, break_id_t watch_id, bool silently_skip_wp)
const char * GetDescription() override
void PerformAction(Event *event_ptr) override
void SetStepOverPlanComplete()
bool ShouldStop(Event *event_ptr) override
bool m_using_step_over_plan
bool m_should_stop_is_valid
bool ShouldStopSynchronous(Event *event_ptr) override
bool m_step_over_plan_complete
StopReason GetStopReason() const override
std::string m_description
static lldb::StopInfoSP CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan, lldb::ValueObjectSP return_valobj_sp, lldb::ExpressionVariableSP expression_variable_sp)
uint64_t GetValue() const
static lldb::ExpressionVariableSP GetExpressionVariable(lldb::StopInfoSP &stop_info_sp)
static lldb::ValueObjectSP GetReturnValueObject(lldb::StopInfoSP &stop_info_sp)
static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread)
static lldb::StopInfoSP CreateStopReasonVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
static lldb::StopInfoSP CreateStopReasonWithSignal(Thread &thread, int signo, const char *description=nullptr, std::optional< int > code=std::nullopt)
lldb::ThreadSP GetThread() const
static lldb::StopInfoSP CreateStopReasonFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
static lldb::StopInfoSP CreateStopReasonVForkDone(Thread &thread)
static lldb::StopInfoSP CreateStopReasonWithWatchpointID(Thread &thread, lldb::break_id_t watch_id, bool silently_continue=false)
virtual void SetDescription(const char *desc_cstr)
static lldb::StopInfoSP CreateStopReasonWithException(Thread &thread, const char *description)
static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(Thread &thread, lldb::break_id_t break_id)
static lldb::ValueObjectSP GetCrashingDereference(lldb::StopInfoSP &stop_info_sp, lldb::addr_t *crashing_address=nullptr)
static lldb::StopInfoSP CreateStopReasonProcessorTrace(Thread &thread, const char *description)
static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread)
bool HasTargetRunSinceMe()
StopInfo(Thread &thread, uint64_t value)
lldb::ThreadWP m_thread_wp
virtual bool ShouldStop(Event *event_ptr)
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
lldb::break_id_t GetID() const
const char * GetData() const
llvm::StringRef GetString() const
void Format(const char *format, Args &&... args)
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
bool DoPlanExplainsStop(Event *event_ptr) override
bool MischiefManaged() override
bool ShouldStop(Event *event_ptr) override
Thread & GetThread()
Returns the Thread that is using this thread plan.
virtual lldb::StopInfoSP GetPrivateStopInfo(bool calculate=true)
void SetStopInfo(const lldb::StopInfoSP &stop_info_sp)
lldb::ProcessSP GetProcess() const
static lldb::ExpressionResults Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, llvm::StringRef expr_cstr, llvm::StringRef expr_prefix, lldb::ValueObjectSP &result_valobj_sp, Status &error, std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Evaluate one expression in the scratch context of the target passed in the exe_ctx and return its res...
#define LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_INDEX32
#define LLDB_INVALID_ADDRESS
@ DoNoSelectMostRelevantFrame
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
StateType
Process and Thread States.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
std::shared_ptr< lldb_private::Stream > StreamSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
ExpressionResults
The results of expression evaluation.
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
StopReason
Thread stop reasons.
@ eStopReasonPlanComplete
@ eStopReasonExec
Program was re-exec'ed.
@ eStopReasonProcessorTrace
lldb::user_id_t GetID() const
Get accessor for the user ID.