1 //===-- ThreadPlan.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/lldb-python.h" 11 12 #include "lldb/Target/ThreadPlan.h" 13 14 // C Includes 15 // C++ Includes 16 // Other libraries and framework includes 17 // Project includes 18 #include "lldb/Core/Debugger.h" 19 #include "lldb/Core/Log.h" 20 #include "lldb/Core/State.h" 21 #include "lldb/Target/RegisterContext.h" 22 #include "lldb/Target/Thread.h" 23 #include "lldb/Target/Process.h" 24 #include "lldb/Target/Target.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 29 //---------------------------------------------------------------------- 30 // ThreadPlan constructor 31 //---------------------------------------------------------------------- 32 ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, Vote stop_vote, Vote run_vote) : 33 m_thread (thread), 34 m_stop_vote (stop_vote), 35 m_run_vote (run_vote), 36 m_kind (kind), 37 m_name (name), 38 m_plan_complete_mutex (Mutex::eMutexTypeRecursive), 39 m_cached_plan_explains_stop (eLazyBoolCalculate), 40 m_plan_complete (false), 41 m_plan_private (false), 42 m_okay_to_discard (true), 43 m_is_master_plan (false), 44 m_plan_succeeded(true) 45 { 46 SetID (GetNextID()); 47 } 48 49 //---------------------------------------------------------------------- 50 // Destructor 51 //---------------------------------------------------------------------- 52 ThreadPlan::~ThreadPlan() 53 { 54 } 55 56 bool 57 ThreadPlan::PlanExplainsStop (Event *event_ptr) 58 { 59 if (m_cached_plan_explains_stop == eLazyBoolCalculate) 60 { 61 bool actual_value = DoPlanExplainsStop(event_ptr); 62 m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo; 63 return actual_value; 64 } 65 else 66 { 67 return m_cached_plan_explains_stop == eLazyBoolYes; 68 } 69 } 70 71 bool 72 ThreadPlan::IsPlanComplete () 73 { 74 Mutex::Locker locker(m_plan_complete_mutex); 75 return m_plan_complete; 76 } 77 78 void 79 ThreadPlan::SetPlanComplete (bool success) 80 { 81 Mutex::Locker locker(m_plan_complete_mutex); 82 m_plan_complete = true; 83 m_plan_succeeded = success; 84 } 85 86 bool 87 ThreadPlan::MischiefManaged () 88 { 89 Mutex::Locker locker(m_plan_complete_mutex); 90 // Mark the plan is complete, but don't override the success flag. 91 m_plan_complete = true; 92 return true; 93 } 94 95 Vote 96 ThreadPlan::ShouldReportStop (Event *event_ptr) 97 { 98 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 99 100 if (m_stop_vote == eVoteNoOpinion) 101 { 102 ThreadPlan *prev_plan = GetPreviousPlan (); 103 if (prev_plan) 104 { 105 Vote prev_vote = prev_plan->ShouldReportStop (event_ptr); 106 if (log) 107 log->Printf ("ThreadPlan::ShouldReportStop() returning previous thread plan vote: %s", 108 GetVoteAsCString (prev_vote)); 109 return prev_vote; 110 } 111 } 112 if (log) 113 log->Printf ("ThreadPlan::ShouldReportStop() returning vote: %s", GetVoteAsCString (m_stop_vote)); 114 return m_stop_vote; 115 } 116 117 Vote 118 ThreadPlan::ShouldReportRun (Event *event_ptr) 119 { 120 if (m_run_vote == eVoteNoOpinion) 121 { 122 ThreadPlan *prev_plan = GetPreviousPlan (); 123 if (prev_plan) 124 return prev_plan->ShouldReportRun (event_ptr); 125 } 126 return m_run_vote; 127 } 128 129 bool 130 ThreadPlan::StopOthers () 131 { 132 ThreadPlan *prev_plan; 133 prev_plan = GetPreviousPlan (); 134 if (prev_plan == NULL) 135 return false; 136 else 137 return prev_plan->StopOthers(); 138 } 139 140 void 141 ThreadPlan::SetStopOthers (bool new_value) 142 { 143 // SetStopOthers doesn't work up the hierarchy. You have to set the 144 // explicit ThreadPlan you want to affect. 145 } 146 147 bool 148 ThreadPlan::WillResume (StateType resume_state, bool current_plan) 149 { 150 m_cached_plan_explains_stop = eLazyBoolCalculate; 151 152 if (current_plan) 153 { 154 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 155 156 if (log) 157 { 158 RegisterContext *reg_ctx = m_thread.GetRegisterContext().get(); 159 addr_t pc = reg_ctx->GetPC(); 160 addr_t sp = reg_ctx->GetSP(); 161 addr_t fp = reg_ctx->GetFP(); 162 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 ", " 163 "plan = '%s', state = %s, stop others = %d", 164 __FUNCTION__, 165 m_thread.GetIndexID(), 166 &m_thread, 167 m_thread.GetID(), 168 (uint64_t)pc, 169 (uint64_t)sp, 170 (uint64_t)fp, 171 m_name.c_str(), 172 StateAsCString(resume_state), 173 StopOthers()); 174 } 175 } 176 return DoWillResume (resume_state, current_plan); 177 } 178 179 lldb::user_id_t 180 ThreadPlan::GetNextID() 181 { 182 static uint32_t g_nextPlanID = 0; 183 return ++g_nextPlanID; 184 } 185 186 void 187 ThreadPlan::DidPush() 188 { 189 } 190 191 void 192 ThreadPlan::WillPop() 193 { 194 } 195 196 bool 197 ThreadPlan::OkayToDiscard() 198 { 199 if (!IsMasterPlan()) 200 return true; 201 else 202 return m_okay_to_discard; 203 } 204 205 lldb::StateType 206 ThreadPlan::RunState () 207 { 208 if (m_tracer_sp && m_tracer_sp->TracingEnabled() && m_tracer_sp->SingleStepEnabled()) 209 return eStateStepping; 210 else 211 return GetPlanRunState(); 212 } 213 214 //---------------------------------------------------------------------- 215 // ThreadPlanNull 216 //---------------------------------------------------------------------- 217 218 ThreadPlanNull::ThreadPlanNull (Thread &thread) : 219 ThreadPlan (ThreadPlan::eKindNull, 220 "Null Thread Plan", 221 thread, 222 eVoteNoOpinion, 223 eVoteNoOpinion) 224 { 225 } 226 227 ThreadPlanNull::~ThreadPlanNull () 228 { 229 } 230 231 void 232 ThreadPlanNull::GetDescription (Stream *s, 233 lldb::DescriptionLevel level) 234 { 235 s->PutCString("Null thread plan - thread has been destroyed."); 236 } 237 238 bool 239 ThreadPlanNull::ValidatePlan (Stream *error) 240 { 241 #ifdef LLDB_CONFIGURATION_DEBUG 242 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 243 __PRETTY_FUNCTION__, 244 m_thread.GetID(), 245 m_thread.GetProtocolID()); 246 #else 247 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 248 if (log) 249 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 250 __PRETTY_FUNCTION__, 251 m_thread.GetID(), 252 m_thread.GetProtocolID()); 253 #endif 254 return true; 255 } 256 257 bool 258 ThreadPlanNull::ShouldStop (Event *event_ptr) 259 { 260 #ifdef LLDB_CONFIGURATION_DEBUG 261 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 262 __PRETTY_FUNCTION__, 263 m_thread.GetID(), 264 m_thread.GetProtocolID()); 265 #else 266 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 267 if (log) 268 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 269 __PRETTY_FUNCTION__, 270 m_thread.GetID(), 271 m_thread.GetProtocolID()); 272 #endif 273 return true; 274 } 275 276 bool 277 ThreadPlanNull::WillStop () 278 { 279 #ifdef LLDB_CONFIGURATION_DEBUG 280 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 281 __PRETTY_FUNCTION__, 282 m_thread.GetID(), 283 m_thread.GetProtocolID()); 284 #else 285 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 286 if (log) 287 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 288 __PRETTY_FUNCTION__, 289 m_thread.GetID(), 290 m_thread.GetProtocolID()); 291 #endif 292 return true; 293 } 294 295 bool 296 ThreadPlanNull::DoPlanExplainsStop (Event *event_ptr) 297 { 298 #ifdef LLDB_CONFIGURATION_DEBUG 299 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 300 __PRETTY_FUNCTION__, 301 m_thread.GetID(), 302 m_thread.GetProtocolID()); 303 #else 304 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 305 if (log) 306 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 307 __PRETTY_FUNCTION__, 308 m_thread.GetID(), 309 m_thread.GetProtocolID()); 310 #endif 311 return true; 312 } 313 314 // The null plan is never done. 315 bool 316 ThreadPlanNull::MischiefManaged () 317 { 318 // The null plan is never done. 319 #ifdef LLDB_CONFIGURATION_DEBUG 320 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 321 __PRETTY_FUNCTION__, 322 m_thread.GetID(), 323 m_thread.GetProtocolID()); 324 #else 325 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 326 if (log) 327 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 328 __PRETTY_FUNCTION__, 329 m_thread.GetID(), 330 m_thread.GetProtocolID()); 331 #endif 332 return false; 333 } 334 335 lldb::StateType 336 ThreadPlanNull::GetPlanRunState () 337 { 338 // Not sure what to return here. This is a dead thread. 339 #ifdef LLDB_CONFIGURATION_DEBUG 340 fprintf(stderr, "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 341 __PRETTY_FUNCTION__, 342 m_thread.GetID(), 343 m_thread.GetProtocolID()); 344 #else 345 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 346 if (log) 347 log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64 ", ptid = 0x%" PRIx64 ")", 348 __PRETTY_FUNCTION__, 349 m_thread.GetID(), 350 m_thread.GetProtocolID()); 351 #endif 352 return eStateRunning; 353 } 354
