| //===-- ThreadPlan.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/ThreadPlan.h" |
| |
| // C Includes |
| // C++ Includes |
| // Other libraries and framework includes |
| // Project includes |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/Log.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Target/RegisterContext.h" |
| #include "lldb/Target/Thread.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/Target.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| //---------------------------------------------------------------------- |
| // ThreadPlan constructor |
| //---------------------------------------------------------------------- |
| ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, Vote stop_vote, Vote run_vote) : |
| m_thread (thread), |
| m_stop_vote (stop_vote), |
| m_run_vote (run_vote), |
| m_kind (kind), |
| m_name (name), |
| m_plan_complete_mutex (Mutex::eMutexTypeRecursive), |
| m_cached_plan_explains_stop (eLazyBoolCalculate), |
| m_plan_complete (false), |
| m_plan_private (false), |
| m_okay_to_discard (true), |
| m_is_master_plan (false), |
| m_plan_succeeded(true) |
| { |
| SetID (GetNextID()); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| ThreadPlan::~ThreadPlan() |
| { |
| } |
| |
| bool |
| ThreadPlan::PlanExplainsStop (Event *event_ptr) |
| { |
| if (m_cached_plan_explains_stop == eLazyBoolCalculate) |
| { |
| bool actual_value = DoPlanExplainsStop(event_ptr); |
| m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo; |
| return actual_value; |
| } |
| else |
| { |
| return m_cached_plan_explains_stop == eLazyBoolYes; |
| } |
| } |
| |
| bool |
| ThreadPlan::IsPlanComplete () |
| { |
| Mutex::Locker locker(m_plan_complete_mutex); |
| return m_plan_complete; |
| } |
| |
| void |
| ThreadPlan::SetPlanComplete (bool success) |
| { |
| Mutex::Locker locker(m_plan_complete_mutex); |
| m_plan_complete = true; |
| m_plan_succeeded = success; |
| } |
| |
| bool |
| ThreadPlan::MischiefManaged () |
| { |
| Mutex::Locker locker(m_plan_complete_mutex); |
| // Mark the plan is complete, but don't override the success flag. |
| m_plan_complete = true; |
| return true; |
| } |
| |
| Vote |
| ThreadPlan::ShouldReportStop (Event *event_ptr) |
| { |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
| |
| if (m_stop_vote == eVoteNoOpinion) |
| { |
| ThreadPlan *prev_plan = GetPreviousPlan (); |
| if (prev_plan) |
| { |
| Vote prev_vote = prev_plan->ShouldReportStop (event_ptr); |
| if (log) |
| log->Printf ("ThreadPlan::ShouldReportStop() returning previous thread plan vote: %s", |
| GetVoteAsCString (prev_vote)); |
| return prev_vote; |
| } |
| } |
| if (log) |
| log->Printf ("ThreadPlan::ShouldReportStop() returning vote: %s", GetVoteAsCString (m_stop_vote)); |
| return m_stop_vote; |
| } |
| |
| Vote |
| ThreadPlan::ShouldReportRun (Event *event_ptr) |
| { |
| if (m_run_vote == eVoteNoOpinion) |
| { |
| ThreadPlan *prev_plan = GetPreviousPlan (); |
| if (prev_plan) |
| return prev_plan->ShouldReportRun (event_ptr); |
| } |
| return m_run_vote; |
| } |
| |
| bool |
| ThreadPlan::StopOthers () |
| { |
| ThreadPlan *prev_plan; |
| prev_plan = GetPreviousPlan (); |
| if (prev_plan == NULL) |
| return false; |
| else |
| return prev_plan->StopOthers(); |
| } |
| |
| void |
| ThreadPlan::SetStopOthers (bool new_value) |
| { |
| // SetStopOthers doesn't work up the hierarchy. You have to set the |
| // explicit ThreadPlan you want to affect. |
| } |
| |
| bool |
| ThreadPlan::WillResume (StateType resume_state, bool current_plan) |
| { |
| m_cached_plan_explains_stop = eLazyBoolCalculate; |
| |
| if (current_plan) |
| { |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
| |
| if (log) |
| { |
| RegisterContext *reg_ctx = m_thread.GetRegisterContext().get(); |
| addr_t pc = reg_ctx->GetPC(); |
| addr_t sp = reg_ctx->GetSP(); |
| addr_t fp = reg_ctx->GetFP(); |
| log->Printf("%s Thread #%u (0x%p): tid = 0x%4.4" PRIx64 ", pc = 0x%8.8" PRIx64 ", sp = 0x%8.8" PRIx64 ", fp = 0x%8.8" PRIx64 ", " |
| "plan = '%s', state = %s, stop others = %d", |
| __FUNCTION__, |
| m_thread.GetIndexID(), |
| &m_thread, |
| m_thread.GetID(), |
| (uint64_t)pc, |
| (uint64_t)sp, |
| (uint64_t)fp, |
| m_name.c_str(), |
| StateAsCString(resume_state), |
| StopOthers()); |
| } |
| } |
| return DoWillResume (resume_state, current_plan); |
| } |
| |
| lldb::user_id_t |
| ThreadPlan::GetNextID() |
| { |
| static uint32_t g_nextPlanID = 0; |
| return ++g_nextPlanID; |
| } |
| |
| void |
| ThreadPlan::DidPush() |
| { |
| } |
| |
| void |
| ThreadPlan::WillPop() |
| { |
| } |
| |
| bool |
| ThreadPlan::OkayToDiscard() |
| { |
| if (!IsMasterPlan()) |
| return true; |
| else |
| return m_okay_to_discard; |
| } |
| |
| lldb::StateType |
| ThreadPlan::RunState () |
| { |
| if (m_tracer_sp && m_tracer_sp->TracingEnabled() && m_tracer_sp->SingleStepEnabled()) |
| return eStateStepping; |
| else |
| return GetPlanRunState(); |
| } |
| |
| //---------------------------------------------------------------------- |
| // ThreadPlanNull |
| //---------------------------------------------------------------------- |
| |
| ThreadPlanNull::ThreadPlanNull (Thread &thread) : |
| ThreadPlan (ThreadPlan::eKindNull, |
| "Null Thread Plan", |
| thread, |
| eVoteNoOpinion, |
| eVoteNoOpinion) |
| { |
| } |
| |
| ThreadPlanNull::~ThreadPlanNull () |
| { |
| } |
| |
| void |
| ThreadPlanNull::GetDescription (Stream *s, |
| lldb::DescriptionLevel level) |
| { |
| s->PutCString("Null thread plan - thread has been destroyed."); |
| } |
| |
| bool |
| ThreadPlanNull::ValidatePlan (Stream *error) |
| { |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return true; |
| } |
| |
| bool |
| ThreadPlanNull::ShouldStop (Event *event_ptr) |
| { |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return true; |
| } |
| |
| bool |
| ThreadPlanNull::WillStop () |
| { |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return true; |
| } |
| |
| bool |
| ThreadPlanNull::DoPlanExplainsStop (Event *event_ptr) |
| { |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return true; |
| } |
| |
| // The null plan is never done. |
| bool |
| ThreadPlanNull::MischiefManaged () |
| { |
| // The null plan is never done. |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return false; |
| } |
| |
| lldb::StateType |
| ThreadPlanNull::GetPlanRunState () |
| { |
| // Not sure what to return here. This is a dead thread. |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #else |
| Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); |
| if (log) |
| log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", |
| __PRETTY_FUNCTION__, |
| m_thread.GetID(), |
| m_thread.GetProtocolID()); |
| #endif |
| return eStateRunning; |
| } |
