diff options
Diffstat (limited to 'source/Target/StopInfo.cpp')
| -rw-r--r-- | source/Target/StopInfo.cpp | 1143 |
1 files changed, 1143 insertions, 0 deletions
diff --git a/source/Target/StopInfo.cpp b/source/Target/StopInfo.cpp new file mode 100644 index 000000000000..81b9d866f711 --- /dev/null +++ b/source/Target/StopInfo.cpp @@ -0,0 +1,1143 @@ +//===-- StopInfo.cpp ---------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/lldb-python.h" + +#include "lldb/Target/StopInfo.h" + +// C Includes +// C++ Includes +#include <string> + +// Other libraries and framework includes +// Project includes +#include "lldb/Core/Log.h" +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Breakpoint/Watchpoint.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamString.h" +#include "lldb/Expression/ClangUserExpression.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlan.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/UnixSignals.h" + +using namespace lldb; +using namespace lldb_private; + +StopInfo::StopInfo (Thread &thread, uint64_t value) : + m_thread_wp (thread.shared_from_this()), + m_stop_id (thread.GetProcess()->GetStopID()), + m_resume_id (thread.GetProcess()->GetResumeID()), + m_value (value), + m_override_should_notify (eLazyBoolCalculate), + m_override_should_stop (eLazyBoolCalculate) +{ +} + +bool +StopInfo::IsValid () const +{ + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + return thread_sp->GetProcess()->GetStopID() == m_stop_id; + return false; +} + +void +StopInfo::MakeStopInfoValid () +{ + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + m_stop_id = thread_sp->GetProcess()->GetStopID(); + m_resume_id = thread_sp->GetProcess()->GetResumeID(); + } +} + +bool +StopInfo::HasTargetRunSinceMe () +{ + ThreadSP thread_sp (m_thread_wp.lock()); + + if (thread_sp) + { + lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState(); + if (ret_type == eStateRunning) + { + return true; + } + else if (ret_type == eStateStopped) + { + // This is a little tricky. We want to count "run and stopped again before you could + // ask this question as a "TRUE" answer to HasTargetRunSinceMe. But we don't want to + // include any running of the target done for expressions. So we track both resumes, + // and resumes caused by expressions, and check if there are any resumes NOT caused + // by expressions. + + uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID(); + uint32_t last_user_expression_id = thread_sp->GetProcess()->GetLastUserExpressionResumeID (); + if (curr_resume_id == m_resume_id) + { + return false; + } + else if (curr_resume_id > last_user_expression_id) + { + return true; + } + } + } + return false; +} + +//---------------------------------------------------------------------- +// StopInfoBreakpoint +//---------------------------------------------------------------------- + +namespace lldb_private +{ +class StopInfoBreakpoint : public StopInfo +{ +public: + + StopInfoBreakpoint (Thread &thread, break_id_t break_id) : + StopInfo (thread, break_id), + m_description(), + m_should_stop (false), + m_should_stop_is_valid (false), + m_should_perform_action (true), + m_address (LLDB_INVALID_ADDRESS), + m_break_id(LLDB_INVALID_BREAK_ID), + m_was_one_shot (false) + { + StoreBPInfo(); + } + + StopInfoBreakpoint (Thread &thread, break_id_t break_id, bool should_stop) : + StopInfo (thread, break_id), + m_description(), + m_should_stop (should_stop), + m_should_stop_is_valid (true), + m_should_perform_action (true), + m_address (LLDB_INVALID_ADDRESS), + m_break_id(LLDB_INVALID_BREAK_ID), + m_was_one_shot (false) + { + StoreBPInfo(); + } + + void + StoreBPInfo () + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value)); + if (bp_site_sp) + { + if (bp_site_sp->GetNumberOfOwners() == 1) + { + BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0); + if (bp_loc_sp) + { + m_break_id = bp_loc_sp->GetBreakpoint().GetID(); + m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot(); + } + } + m_address = bp_site_sp->GetLoadAddress(); + } + } + } + + virtual ~StopInfoBreakpoint () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonBreakpoint; + } + + virtual bool + ShouldStopSynchronous (Event *event_ptr) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + if (!m_should_stop_is_valid) + { + // Only check once if we should stop at a breakpoint + BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value)); + if (bp_site_sp) + { + ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0)); + StoppointCallbackContext context (event_ptr, exe_ctx, true); + m_should_stop = bp_site_sp->ShouldStop (&context); + } + else + { + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); + + if (log) + log->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value); + + m_should_stop = true; + } + m_should_stop_is_valid = true; + } + return m_should_stop; + } + return false; + } + + virtual bool + DoShouldNotify (Event *event_ptr) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value)); + if (bp_site_sp) + { + bool all_internal = true; + + for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) + { + if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) + { + all_internal = false; + break; + } + } + return all_internal == false; + } + } + return true; + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value)); + if (bp_site_sp) + { + StreamString strm; + // If we have just hit an internal breakpoint, and it has a kind description, print that instead of the + // full breakpoint printing: + if (bp_site_sp->IsInternal()) + { + size_t num_owners = bp_site_sp->GetNumberOfOwners(); + for (size_t idx = 0; idx < num_owners; idx++) + { + const char *kind = bp_site_sp->GetOwnerAtIndex(idx)->GetBreakpoint().GetBreakpointKind(); + if (kind != NULL) + { + m_description.assign (kind); + return kind; + } + } + } + + strm.Printf("breakpoint "); + bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief); + m_description.swap (strm.GetString()); + } + else + { + StreamString strm; + if (m_break_id != LLDB_INVALID_BREAK_ID) + { + BreakpointSP break_sp = thread_sp->GetProcess()->GetTarget().GetBreakpointByID(m_break_id); + if (break_sp) + { + if (break_sp->IsInternal()) + { + const char *kind = break_sp->GetBreakpointKind(); + if (kind) + strm.Printf ("internal %s breakpoint(%d).", kind, m_break_id); + else + strm.Printf ("internal breakpoint(%d).", m_break_id); + } + else + { + strm.Printf ("breakpoint %d.", m_break_id); + } + } + else + { + if (m_was_one_shot) + strm.Printf ("one-shot breakpoint %d", m_break_id); + else + strm.Printf ("breakpoint %d which has been deleted.", m_break_id); + } + } + else if (m_address == LLDB_INVALID_ADDRESS) + strm.Printf("breakpoint site %" PRIi64 " which has been deleted - unknown address", m_value); + else + strm.Printf("breakpoint site %" PRIi64 " which has been deleted - was at 0x%" PRIx64, m_value, m_address); + + m_description.swap (strm.GetString()); + } + } + } + return m_description.c_str(); + } + +protected: + bool + ShouldStop (Event *event_ptr) + { + // This just reports the work done by PerformAction or the synchronous stop. It should + // only ever get called after they have had a chance to run. + assert (m_should_stop_is_valid); + return m_should_stop; + } + + virtual void + PerformAction (Event *event_ptr) + { + if (!m_should_perform_action) + return; + m_should_perform_action = false; + + ThreadSP thread_sp (m_thread_wp.lock()); + + if (thread_sp) + { + Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); + + if (!thread_sp->IsValid()) + { + // This shouldn't ever happen, but just in case, don't do more harm. + if (log) + { + log->Printf ("PerformAction got called with an invalid thread."); + } + m_should_stop = true; + m_should_stop_is_valid = true; + return; + } + + BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value)); + + if (bp_site_sp) + { + size_t num_owners = bp_site_sp->GetNumberOfOwners(); + + if (num_owners == 0) + { + m_should_stop = true; + } + else + { + // We go through each location, and test first its condition. If the condition says to stop, + // then we run the callback for that location. If that callback says to stop as well, then + // we set m_should_stop to true; we are going to stop. + // But we still want to give all the breakpoints whose conditions say we are going to stop a + // chance to run their callbacks. + // Of course if any callback restarts the target by putting "continue" in the callback, then + // we're going to restart, without running the rest of the callbacks. And in this case we will + // end up not stopping even if another location said we should stop. But that's better than not + // running all the callbacks. + + m_should_stop = false; + + ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0)); + Process *process = exe_ctx.GetProcessPtr(); + if (process->GetModIDRef().IsLastResumeForUserExpression()) + { + // If we are in the middle of evaluating an expression, don't run asynchronous breakpoint commands or + // expressions. That could lead to infinite recursion if the command or condition re-calls the function + // with this breakpoint. + // TODO: We can keep a list of the breakpoints we've seen while running expressions in the nested + // PerformAction calls that can arise when the action runs a function that hits another breakpoint, + // and only stop running commands when we see the same breakpoint hit a second time. + + m_should_stop_is_valid = true; + if (log) + log->Printf ("StopInfoBreakpoint::PerformAction - Hit a breakpoint while running an expression," + " not running commands to avoid recursion."); + bool ignoring_breakpoints = process->GetIgnoreBreakpointsInExpressions(); + if (ignoring_breakpoints) + { + m_should_stop = false; + // Internal breakpoints will always stop. + for (size_t j = 0; j < num_owners; j++) + { + lldb::BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(j); + if (bp_loc_sp->GetBreakpoint().IsInternal()) + { + m_should_stop = true; + break; + } + } + } + else + { + m_should_stop = true; + } + if (log) + log->Printf ("StopInfoBreakpoint::PerformAction - in expression, continuing: %s.", + m_should_stop ? "true" : "false"); + process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf("Warning: hit breakpoint while " + "running function, skipping commands and conditions to prevent recursion."); + return; + } + + StoppointCallbackContext context (event_ptr, exe_ctx, false); + + // Let's copy the breakpoint locations out of the site and store them in a local list. That way if + // one of the breakpoint actions changes the site, then we won't be operating on a bad list. + + BreakpointLocationCollection site_locations; + for (size_t j = 0; j < num_owners; j++) + site_locations.Add(bp_site_sp->GetOwnerAtIndex(j)); + + for (size_t j = 0; j < num_owners; j++) + { + lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j); + + // If another action disabled this breakpoint or its location, then don't run the actions. + if (!bp_loc_sp->IsEnabled() || !bp_loc_sp->GetBreakpoint().IsEnabled()) + continue; + + // The breakpoint site may have many locations associated with it, not all of them valid for + // this thread. Skip the ones that aren't: + if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) + continue; + + // First run the condition for the breakpoint. If that says we should stop, then we'll run + // the callback for the breakpoint. If the callback says we shouldn't stop that will win. + + if (bp_loc_sp->GetConditionText() != NULL) + { + Error condition_error; + bool condition_says_stop = bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error); + + if (!condition_error.Success()) + { + Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); + StreamSP error_sp = debugger.GetAsyncErrorStream (); + error_sp->Printf ("Stopped due to an error evaluating condition of breakpoint "); + bp_loc_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief); + error_sp->Printf (": \"%s\"", + bp_loc_sp->GetConditionText()); + error_sp->EOL(); + const char *err_str = condition_error.AsCString("<Unknown Error>"); + if (log) + log->Printf("Error evaluating condition: \"%s\"\n", err_str); + + error_sp->PutCString (err_str); + error_sp->EOL(); + error_sp->Flush(); + // If the condition fails to be parsed or run, we should stop. + condition_says_stop = true; + } + else + { + if (!condition_says_stop) + continue; + } + } + + bool callback_says_stop; + + // FIXME: For now the callbacks have to run in async mode - the first time we restart we need + // to get out of there. So set it here. + // When we figure out how to nest breakpoint hits then this will change. + + Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger(); + bool old_async = debugger.GetAsyncExecution(); + debugger.SetAsyncExecution (true); + + callback_says_stop = bp_loc_sp->InvokeCallback (&context); + + debugger.SetAsyncExecution (old_async); + + if (callback_says_stop) + m_should_stop = true; + + // If we are going to stop for this breakpoint, then remove the breakpoint. + if (callback_says_stop && bp_loc_sp && bp_loc_sp->GetBreakpoint().IsOneShot()) + { + thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID (bp_loc_sp->GetBreakpoint().GetID()); + } + + // Also make sure that the callback hasn't continued the target. + // If it did, when we'll set m_should_start to false and get out of here. + if (HasTargetRunSinceMe ()) + { + m_should_stop = false; + break; + } + } + } + // We've figured out what this stop wants to do, so mark it as valid so we don't compute it again. + m_should_stop_is_valid = true; + + } + else + { + m_should_stop = true; + m_should_stop_is_valid = true; + Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); + + if (log_process) + log_process->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value); + } + if (log) + log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop); + } + } + +private: + std::string m_description; + bool m_should_stop; + bool m_should_stop_is_valid; + bool m_should_perform_action; // Since we are trying to preserve the "state" of the system even if we run functions + // etc. behind the users backs, we need to make sure we only REALLY perform the action once. + lldb::addr_t m_address; // We use this to capture the breakpoint site address when we create the StopInfo, + // in case somebody deletes it between the time the StopInfo is made and the + // description is asked for. + lldb::break_id_t m_break_id; + bool m_was_one_shot; +}; + + +//---------------------------------------------------------------------- +// StopInfoWatchpoint +//---------------------------------------------------------------------- + +class StopInfoWatchpoint : public StopInfo +{ +public: + // Make sure watchpoint is properly disabled and subsequently enabled while performing watchpoint actions. + class WatchpointSentry { + public: + WatchpointSentry(Process *p, Watchpoint *w): + process(p), + watchpoint(w) + { + if (process && watchpoint) + { + const bool notify = false; + watchpoint->TurnOnEphemeralMode(); + process->DisableWatchpoint(watchpoint, notify); + } + } + ~WatchpointSentry() + { + if (process && watchpoint) + { + if (!watchpoint->IsDisabledDuringEphemeralMode()) + { + const bool notify = false; + process->EnableWatchpoint(watchpoint, notify); + } + watchpoint->TurnOffEphemeralMode(); + } + } + private: + Process *process; + Watchpoint *watchpoint; + }; + + StopInfoWatchpoint (Thread &thread, break_id_t watch_id) : + StopInfo(thread, watch_id), + m_description(), + m_should_stop(false), + m_should_stop_is_valid(false) + { + } + + virtual ~StopInfoWatchpoint () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonWatchpoint; + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + { + StreamString strm; + strm.Printf("watchpoint %" PRIi64, m_value); + m_description.swap (strm.GetString()); + } + return m_description.c_str(); + } + +protected: + virtual bool + ShouldStopSynchronous (Event *event_ptr) + { + // ShouldStop() method is idempotent and should not affect hit count. + // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent() + // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()-> + // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()-> + // StopInfoWatchpoint::ShouldStop() and + // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()-> + // StopInfoWatchpoint::PerformAction(). + if (m_should_stop_is_valid) + return m_should_stop; + + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue())); + if (wp_sp) + { + // Check if we should stop at a watchpoint. + ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0)); + StoppointCallbackContext context (event_ptr, exe_ctx, true); + m_should_stop = wp_sp->ShouldStop (&context); + } + else + { + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); + + if (log) + log->Printf ("Process::%s could not find watchpoint location id: %" PRId64 "...", + __FUNCTION__, GetValue()); + + m_should_stop = true; + } + } + m_should_stop_is_valid = true; + return m_should_stop; + } + + bool + ShouldStop (Event *event_ptr) + { + // This just reports the work done by PerformAction or the synchronous stop. It should + // only ever get called after they have had a chance to run. + assert (m_should_stop_is_valid); + return m_should_stop; + } + + virtual void + PerformAction (Event *event_ptr) + { + Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS); + // We're going to calculate if we should stop or not in some way during the course of + // this code. Also by default we're going to stop, so set that here. + m_should_stop = true; + + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + + WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue())); + if (wp_sp) + { + ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0)); + Process* process = exe_ctx.GetProcessPtr(); + + // This sentry object makes sure the current watchpoint is disabled while performing watchpoint actions, + // and it is then enabled after we are finished. + WatchpointSentry sentry(process, wp_sp.get()); + + { + // check if this process is running on an architecture where watchpoints trigger + // before the associated instruction runs. if so, disable the WP, single-step and then + // re-enable the watchpoint + if (process) + { + uint32_t num; + bool wp_triggers_after; + if (process->GetWatchpointSupportInfo(num, wp_triggers_after).Success()) + { + if (!wp_triggers_after) + { + StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo(); + assert (stored_stop_info_sp.get() == this); + + ThreadPlanSP new_plan_sp(thread_sp->QueueThreadPlanForStepSingleInstruction(false, // step-over + false, // abort_other_plans + true)); // stop_other_threads + new_plan_sp->SetIsMasterPlan (true); + new_plan_sp->SetOkayToDiscard (false); + new_plan_sp->SetPrivate (true); + process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID()); + process->Resume (); + process->WaitForProcessToStop (NULL); + process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID()); + thread_sp->SetStopInfo(stored_stop_info_sp); + } + } + } + } + + if (m_should_stop && wp_sp->GetConditionText() != NULL) + { + // We need to make sure the user sees any parse errors in their condition, so we'll hook the + // constructor errors up to the debugger's Async I/O. + ExecutionResults result_code; + ValueObjectSP result_value_sp; + const bool unwind_on_error = true; + const bool ignore_breakpoints = true; + Error error; + result_code = ClangUserExpression::EvaluateWithError (exe_ctx, + eExecutionPolicyOnlyWhenNeeded, + lldb::eLanguageTypeUnknown, + ClangUserExpression::eResultTypeAny, + unwind_on_error, + ignore_breakpoints, + wp_sp->GetConditionText(), + NULL, + result_value_sp, + error, + true, + ClangUserExpression::kDefaultTimeout); + if (result_code == eExecutionCompleted) + { + if (result_value_sp) + { + Scalar scalar_value; + if (result_value_sp->ResolveValue (scalar_value)) + { + if (scalar_value.ULongLong(1) == 0) + { + // We have been vetoed. This takes precedence over querying + // the watchpoint whether it should stop (aka ignore count and + // friends). See also StopInfoWatchpoint::ShouldStop() as well + // as Process::ProcessEventData::DoOnRemoval(). + m_should_stop = false; + } + else + m_should_stop = true; + if (log) + log->Printf("Condition successfully evaluated, result is %s.\n", + m_should_stop ? "true" : "false"); + } + else + { + m_should_stop = true; + if (log) + log->Printf("Failed to get an integer result from the expression."); + } + } + } + else + { + Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); + 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>"); + if (log) + log->Printf("Error evaluating condition: \"%s\"\n", err_str); + + error_sp->PutCString (err_str); + error_sp->EOL(); + error_sp->Flush(); + // If the condition fails to be parsed or run, we should stop. + m_should_stop = true; + } + } + + // If the condition says to stop, we run the callback to further decide whether to stop. + if (m_should_stop) + { + StoppointCallbackContext context (event_ptr, exe_ctx, false); + bool stop_requested = wp_sp->InvokeCallback (&context); + // Also make sure that the callback hasn't continued the target. + // If it did, when we'll set m_should_stop to false and get out of here. + if (HasTargetRunSinceMe ()) + m_should_stop = false; + + if (m_should_stop && !stop_requested) + { + // We have been vetoed by the callback mechanism. + m_should_stop = false; + } + } + // Finally, if we are going to stop, print out the new & old values: + if (m_should_stop) + { + wp_sp->CaptureWatchedValue(exe_ctx); + + Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); + StreamSP output_sp = debugger.GetAsyncOutputStream (); + wp_sp->DumpSnapshots(output_sp.get()); + output_sp->EOL(); + output_sp->Flush(); + } + + } + else + { + Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); + + if (log_process) + log_process->Printf ("Process::%s could not find watchpoint id: %" PRId64 "...", __FUNCTION__, m_value); + } + if (log) + log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop); + + m_should_stop_is_valid = true; + } + } + +private: + std::string m_description; + bool m_should_stop; + bool m_should_stop_is_valid; +}; + + + +//---------------------------------------------------------------------- +// StopInfoUnixSignal +//---------------------------------------------------------------------- + +class StopInfoUnixSignal : public StopInfo +{ +public: + + StopInfoUnixSignal (Thread &thread, int signo) : + StopInfo (thread, signo) + { + } + + virtual ~StopInfoUnixSignal () + { + } + + + virtual StopReason + GetStopReason () const + { + return eStopReasonSignal; + } + + virtual bool + ShouldStopSynchronous (Event *event_ptr) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value); + return false; + } + + virtual bool + ShouldStop (Event *event_ptr) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value); + return false; + } + + + // If should stop returns false, check if we should notify of this event + virtual bool + DoShouldNotify (Event *event_ptr) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + bool should_notify = thread_sp->GetProcess()->GetUnixSignals().GetShouldNotify (m_value); + if (should_notify) + { + StreamString strm; + strm.Printf ("thread %d received signal: %s", + thread_sp->GetIndexID(), + thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value)); + Process::ProcessEventData::AddRestartedReason(event_ptr, strm.GetData()); + } + return should_notify; + } + return true; + } + + + virtual void + WillResume (lldb::StateType resume_state) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + if (thread_sp->GetProcess()->GetUnixSignals().GetShouldSuppress(m_value) == false) + thread_sp->SetResumeSignal(m_value); + } + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + { + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + { + StreamString strm; + const char *signal_name = thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value); + if (signal_name) + strm.Printf("signal %s", signal_name); + else + strm.Printf("signal %" PRIi64, m_value); + m_description.swap (strm.GetString()); + } + } + return m_description.c_str(); + } +}; + +//---------------------------------------------------------------------- +// StopInfoTrace +//---------------------------------------------------------------------- + +class StopInfoTrace : public StopInfo +{ +public: + + StopInfoTrace (Thread &thread) : + StopInfo (thread, LLDB_INVALID_UID) + { + } + + virtual ~StopInfoTrace () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonTrace; + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + return "trace"; + else + return m_description.c_str(); + } +}; + + +//---------------------------------------------------------------------- +// StopInfoException +//---------------------------------------------------------------------- + +class StopInfoException : public StopInfo +{ +public: + + StopInfoException (Thread &thread, const char *description) : + StopInfo (thread, LLDB_INVALID_UID) + { + if (description) + SetDescription (description); + } + + virtual + ~StopInfoException () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonException; + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + return "exception"; + else + return m_description.c_str(); + } +}; + + +//---------------------------------------------------------------------- +// StopInfoThreadPlan +//---------------------------------------------------------------------- + +class StopInfoThreadPlan : public StopInfo +{ +public: + + StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp) : + StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID), + m_plan_sp (plan_sp), + m_return_valobj_sp (return_valobj_sp) + { + } + + virtual ~StopInfoThreadPlan () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonPlanComplete; + } + + virtual const char * + GetDescription () + { + if (m_description.empty()) + { + StreamString strm; + m_plan_sp->GetDescription (&strm, eDescriptionLevelBrief); + m_description.swap (strm.GetString()); + } + return m_description.c_str(); + } + + ValueObjectSP + GetReturnValueObject() + { + return m_return_valobj_sp; + } + +protected: + virtual bool + ShouldStop (Event *event_ptr) + { + if (m_plan_sp) + return m_plan_sp->ShouldStop(event_ptr); + else + return StopInfo::ShouldStop(event_ptr); + } + +private: + ThreadPlanSP m_plan_sp; + ValueObjectSP m_return_valobj_sp; +}; + +class StopInfoExec : public StopInfo +{ +public: + + StopInfoExec (Thread &thread) : + StopInfo (thread, LLDB_INVALID_UID), + m_performed_action (false) + { + } + + virtual + ~StopInfoExec () + { + } + + virtual StopReason + GetStopReason () const + { + return eStopReasonExec; + } + + virtual const char * + GetDescription () + { + return "exec"; + } +protected: + + virtual void + PerformAction (Event *event_ptr) + { + // Only perform the action once + if (m_performed_action) + return; + m_performed_action = true; + ThreadSP thread_sp (m_thread_wp.lock()); + if (thread_sp) + thread_sp->GetProcess()->DidExec(); + } + + bool m_performed_action; +}; + +} // namespace lldb_private + +StopInfoSP +StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id) +{ + return StopInfoSP (new StopInfoBreakpoint (thread, break_id)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id, bool should_stop) +{ + return StopInfoSP (new StopInfoBreakpoint (thread, break_id, should_stop)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id) +{ + return StopInfoSP (new StopInfoWatchpoint (thread, watch_id)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo) +{ + return StopInfoSP (new StopInfoUnixSignal (thread, signo)); +} + +StopInfoSP +StopInfo::CreateStopReasonToTrace (Thread &thread) +{ + return StopInfoSP (new StopInfoTrace (thread)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp) +{ + return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithException (Thread &thread, const char *description) +{ + return StopInfoSP (new StopInfoException (thread, description)); +} + +StopInfoSP +StopInfo::CreateStopReasonWithExec (Thread &thread) +{ + return StopInfoSP (new StopInfoExec (thread)); +} + +ValueObjectSP +StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) +{ + if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete) + { + StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); + return plan_stop_info->GetReturnValueObject(); + } + else + return ValueObjectSP(); +} |