1//===-- ThreadPlanBase.cpp --------------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "lldb/Target/ThreadPlanBase.h" 11 12// C Includes 13// C++ Includes 14// Other libraries and framework includes 15// Project includes 16// 17#include "lldb/Breakpoint/StoppointCallbackContext.h" 18#include "lldb/Breakpoint/BreakpointSite.h" 19#include "lldb/Breakpoint/BreakpointLocation.h" 20#include "lldb/Breakpoint/Breakpoint.h" 21#include "lldb/Core/Log.h" 22#include "lldb/Core/Stream.h" 23#include "lldb/Target/Process.h" 24#include "lldb/Target/RegisterContext.h" 25#include "lldb/Target/StopInfo.h" 26 27using namespace lldb; 28using namespace lldb_private; 29 30//---------------------------------------------------------------------- 31// ThreadPlanBase: This one always stops, and never has anything particular 32// to do. 33// FIXME: The "signal handling" policies should probably go here. 34//---------------------------------------------------------------------- 35 36ThreadPlanBase::ThreadPlanBase (Thread &thread) : 37 ThreadPlan(ThreadPlan::eKindBase, "base plan", thread, eVoteYes, eVoteNoOpinion) 38{ 39 // Set the tracer to a default tracer. 40 // FIXME: need to add a thread settings variable to pix various tracers... 41#define THREAD_PLAN_USE_ASSEMBLY_TRACER 1 42 43#ifdef THREAD_PLAN_USE_ASSEMBLY_TRACER 44 ThreadPlanTracerSP new_tracer_sp (new ThreadPlanAssemblyTracer (m_thread)); 45#else 46 ThreadPlanTracerSP new_tracer_sp (new ThreadPlanTracer (m_thread)); 47#endif 48 new_tracer_sp->EnableTracing (m_thread.GetTraceEnabledState()); 49 SetThreadPlanTracer(new_tracer_sp); 50 SetIsMasterPlan (true); 51} 52 53ThreadPlanBase::~ThreadPlanBase () 54{ 55 56} 57 58void 59ThreadPlanBase::GetDescription (Stream *s, lldb::DescriptionLevel level) 60{ 61 s->Printf ("Base thread plan."); 62} 63 64bool 65ThreadPlanBase::ValidatePlan (Stream *error) 66{ 67 return true; 68} 69 70bool 71ThreadPlanBase::DoPlanExplainsStop (Event *event_ptr) 72{ 73 // The base plan should defer to its tracer, since by default it 74 // always handles the stop. 75 if (TracerExplainsStop()) 76 return false; 77 else 78 return true; 79} 80 81Vote 82ThreadPlanBase::ShouldReportStop(Event *event_ptr) 83{ 84 StopInfoSP stop_info_sp = m_thread.GetStopInfo (); 85 if (stop_info_sp) 86 { 87 bool should_notify = stop_info_sp->ShouldNotify(event_ptr); 88 if (should_notify) 89 return eVoteYes; 90 else 91 return eVoteNoOpinion; 92 } 93 else 94 return eVoteNoOpinion; 95} 96 97bool 98ThreadPlanBase::ShouldStop (Event *event_ptr) 99{ 100 m_stop_vote = eVoteYes; 101 m_run_vote = eVoteYes; 102 103 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 104 105 StopInfoSP stop_info_sp = GetPrivateStopInfo (); 106 if (stop_info_sp) 107 { 108 StopReason reason = stop_info_sp->GetStopReason (); 109 switch (reason) 110 { 111 case eStopReasonInvalid: 112 case eStopReasonNone: 113 // This 114 m_run_vote = eVoteNoOpinion; 115 m_stop_vote = eVoteNo; 116 return false; 117 118 case eStopReasonBreakpoint: 119 case eStopReasonWatchpoint: 120 if (stop_info_sp->ShouldStopSynchronous(event_ptr)) 121 { 122 // If we are going to stop for a breakpoint, then unship the other plans 123 // at this point. Don't force the discard, however, so Master plans can stay 124 // in place if they want to. 125 if (log) 126 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (breakpoint hit.)", m_thread.GetID()); 127 m_thread.DiscardThreadPlans(false); 128 return true; 129 } 130 // If we aren't going to stop at this breakpoint, and it is internal, 131 // don't report this stop or the subsequent running event. 132 // Otherwise we will post the stopped & running, but the stopped event will get marked 133 // with "restarted" so the UI will know to wait and expect the consequent "running". 134 if (stop_info_sp->ShouldNotify (event_ptr)) 135 { 136 m_stop_vote = eVoteYes; 137 m_run_vote = eVoteYes; 138 } 139 else 140 { 141 m_stop_vote = eVoteNo; 142 m_run_vote = eVoteNo; 143 } 144 return false; 145 146 // TODO: the break below was missing, was this intentional??? If so 147 // please mention it 148 break; 149 150 case eStopReasonException: 151 // If we crashed, discard thread plans and stop. Don't force the discard, however, 152 // since on rerun the target may clean up this exception and continue normally from there. 153 if (log) 154 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exception.)", m_thread.GetID()); 155 m_thread.DiscardThreadPlans(false); 156 return true; 157 158 case eStopReasonExec: 159 // If we crashed, discard thread plans and stop. Don't force the discard, however, 160 // since on rerun the target may clean up this exception and continue normally from there. 161 if (log) 162 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (exec.)", m_thread.GetID()); 163 m_thread.DiscardThreadPlans(false); 164 return true; 165 166 case eStopReasonThreadExiting: 167 case eStopReasonSignal: 168 if (stop_info_sp->ShouldStop(event_ptr)) 169 { 170 if (log) 171 log->Printf("Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64 " (signal.)", m_thread.GetID()); 172 m_thread.DiscardThreadPlans(false); 173 return true; 174 } 175 else 176 { 177 // We're not going to stop, but while we are here, let's figure out 178 // whether to report this. 179 if (stop_info_sp->ShouldNotify(event_ptr)) 180 m_stop_vote = eVoteYes; 181 else 182 m_stop_vote = eVoteNo; 183 } 184 return false; 185 186 default: 187 return true; 188 } 189 190 } 191 else 192 { 193 m_run_vote = eVoteNoOpinion; 194 m_stop_vote = eVoteNo; 195 } 196 197 // If there's no explicit reason to stop, then we will continue. 198 return false; 199} 200 201bool 202ThreadPlanBase::StopOthers () 203{ 204 return false; 205} 206 207StateType 208ThreadPlanBase::GetPlanRunState () 209{ 210 return eStateRunning; 211} 212 213bool 214ThreadPlanBase::WillStop () 215{ 216 return true; 217} 218 219bool 220ThreadPlanBase::DoWillResume (lldb::StateType resume_state, bool current_plan) 221{ 222 // Reset these to the default values so we don't set them wrong, then not get asked 223 // for a while, then return the wrong answer. 224 m_run_vote = eVoteNoOpinion; 225 m_stop_vote = eVoteNo; 226 return true; 227} 228 229 230// The base plan is never done. 231bool 232ThreadPlanBase::MischiefManaged () 233{ 234 // The base plan is never done. 235 return false; 236} 237 238