ThreadPlanCallFunction.cpp revision 263367
1//===-- ThreadPlanCallFunction.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/ThreadPlanCallFunction.h" 11 12// C Includes 13// C++ Includes 14// Other libraries and framework includes 15#include "llvm/Support/MachO.h" 16// Project includes 17#include "lldb/lldb-private-log.h" 18#include "lldb/Breakpoint/Breakpoint.h" 19#include "lldb/Breakpoint/BreakpointLocation.h" 20#include "lldb/Core/Address.h" 21#include "lldb/Core/Log.h" 22#include "lldb/Core/Module.h" 23#include "lldb/Core/Stream.h" 24#include "lldb/Symbol/ObjectFile.h" 25#include "lldb/Target/LanguageRuntime.h" 26#include "lldb/Target/Process.h" 27#include "lldb/Target/RegisterContext.h" 28#include "lldb/Target/StopInfo.h" 29#include "lldb/Target/Target.h" 30#include "lldb/Target/Thread.h" 31#include "lldb/Target/ThreadPlanRunToAddress.h" 32 33using namespace lldb; 34using namespace lldb_private; 35 36//---------------------------------------------------------------------- 37// ThreadPlanCallFunction: Plan to call a single function 38//---------------------------------------------------------------------- 39bool 40ThreadPlanCallFunction::ConstructorSetup (Thread &thread, 41 ABI *& abi, 42 lldb::addr_t &start_load_addr, 43 lldb::addr_t &function_load_addr) 44{ 45 SetIsMasterPlan (true); 46 SetOkayToDiscard (false); 47 SetPrivate (true); 48 49 ProcessSP process_sp (thread.GetProcess()); 50 if (!process_sp) 51 return false; 52 53 abi = process_sp->GetABI().get(); 54 55 if (!abi) 56 return false; 57 58 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP)); 59 60 SetBreakpoints(); 61 62 m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize(); 63 // If we can't read memory at the point of the process where we are planning to put our function, we're 64 // not going to get any further... 65 Error error; 66 process_sp->ReadUnsignedIntegerFromMemory(m_function_sp, 4, 0, error); 67 if (!error.Success()) 68 { 69 m_constructor_errors.Printf ("Trying to put the stack in unreadable memory at: 0x%" PRIx64 ".", m_function_sp); 70 if (log) 71 log->Printf ("ThreadPlanCallFunction(%p): %s.", this, m_constructor_errors.GetData()); 72 return false; 73 } 74 75 Module *exe_module = GetTarget().GetExecutableModulePointer(); 76 77 if (exe_module == NULL) 78 { 79 m_constructor_errors.Printf ("Can't execute code without an executable module."); 80 if (log) 81 log->Printf ("ThreadPlanCallFunction(%p): %s.", this, m_constructor_errors.GetData()); 82 return false; 83 } 84 else 85 { 86 ObjectFile *objectFile = exe_module->GetObjectFile(); 87 if (!objectFile) 88 { 89 m_constructor_errors.Printf ("Could not find object file for module \"%s\".", 90 exe_module->GetFileSpec().GetFilename().AsCString()); 91 92 if (log) 93 log->Printf ("ThreadPlanCallFunction(%p): %s.", this, m_constructor_errors.GetData()); 94 return false; 95 } 96 97 m_start_addr = objectFile->GetEntryPointAddress(); 98 if (!m_start_addr.IsValid()) 99 { 100 m_constructor_errors.Printf ("Could not find entry point address for executable module \"%s\".", 101 exe_module->GetFileSpec().GetFilename().AsCString()); 102 if (log) 103 log->Printf ("ThreadPlanCallFunction(%p): %s.", this, m_constructor_errors.GetData()); 104 return false; 105 } 106 } 107 108 start_load_addr = m_start_addr.GetLoadAddress (&GetTarget()); 109 110 // Checkpoint the thread state so we can restore it later. 111 if (log && log->GetVerbose()) 112 ReportRegisterState ("About to checkpoint thread before function call. Original register state was:"); 113 114 if (!thread.CheckpointThreadState (m_stored_thread_state)) 115 { 116 m_constructor_errors.Printf ("Setting up ThreadPlanCallFunction, failed to checkpoint thread state."); 117 if (log) 118 log->Printf ("ThreadPlanCallFunction(%p): %s.", this, m_constructor_errors.GetData()); 119 return false; 120 } 121 function_load_addr = m_function_addr.GetLoadAddress (&GetTarget()); 122 123 return true; 124} 125 126ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread, 127 const Address &function, 128 const ClangASTType &return_type, 129 llvm::ArrayRef<addr_t> args, 130 const EvaluateExpressionOptions &options) : 131 ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion), 132 m_valid (false), 133 m_stop_other_threads (options.GetStopOthers()), 134 m_unwind_on_error (options.DoesUnwindOnError()), 135 m_ignore_breakpoints (options.DoesIgnoreBreakpoints()), 136 m_debug_execution (options.GetDebug()), 137 m_trap_exceptions (options.GetTrapExceptions()), 138 m_function_addr (function), 139 m_function_sp (0), 140 m_return_type (return_type), 141 m_takedown_done (false), 142 m_should_clear_objc_exception_bp(false), 143 m_should_clear_cxx_exception_bp (false), 144 m_stop_address (LLDB_INVALID_ADDRESS) 145{ 146 lldb::addr_t start_load_addr; 147 ABI *abi; 148 lldb::addr_t function_load_addr; 149 if (!ConstructorSetup (thread, abi, start_load_addr, function_load_addr)) 150 return; 151 152 if (!abi->PrepareTrivialCall(thread, 153 m_function_sp, 154 function_load_addr, 155 start_load_addr, 156 args)) 157 return; 158 159 ReportRegisterState ("Function call was set up. Register state was:"); 160 161 m_valid = true; 162} 163 164ThreadPlanCallFunction::~ThreadPlanCallFunction () 165{ 166 DoTakedown(PlanSucceeded()); 167} 168 169void 170ThreadPlanCallFunction::ReportRegisterState (const char *message) 171{ 172 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_VERBOSE)); 173 if (log) 174 { 175 StreamString strm; 176 RegisterContext *reg_ctx = m_thread.GetRegisterContext().get(); 177 178 log->PutCString(message); 179 180 RegisterValue reg_value; 181 182 for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount(); 183 reg_idx < num_registers; 184 ++reg_idx) 185 { 186 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx); 187 if (reg_ctx->ReadRegister(reg_info, reg_value)) 188 { 189 reg_value.Dump(&strm, reg_info, true, false, eFormatDefault); 190 strm.EOL(); 191 } 192 } 193 log->PutCString(strm.GetData()); 194 } 195} 196 197void 198ThreadPlanCallFunction::DoTakedown (bool success) 199{ 200 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP)); 201 202 if (!m_valid) 203 { 204 //Don't call DoTakedown if we were never valid to begin with. 205 if (log) 206 log->Printf ("ThreadPlanCallFunction(%p): Log called on ThreadPlanCallFunction that was never valid.", this); 207 return; 208 } 209 210 if (!m_takedown_done) 211 { 212 if (success) 213 { 214 ProcessSP process_sp (m_thread.GetProcess()); 215 const ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 216 if (abi && m_return_type.IsValid()) 217 { 218 const bool persistent = false; 219 m_return_valobj_sp = abi->GetReturnValueObject (m_thread, m_return_type, persistent); 220 } 221 } 222 if (log) 223 log->Printf ("ThreadPlanCallFunction(%p): DoTakedown called for thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n", this, m_thread.GetID(), m_valid, IsPlanComplete()); 224 m_takedown_done = true; 225 m_stop_address = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC(); 226 m_real_stop_info_sp = GetPrivateStopInfo (); 227 if (!m_thread.RestoreRegisterStateFromCheckpoint(m_stored_thread_state)) 228 { 229 if (log) 230 log->Printf("ThreadPlanCallFunction(%p): DoTakedown failed to restore register state", this); 231 } 232 SetPlanComplete(success); 233 ClearBreakpoints(); 234 if (log && log->GetVerbose()) 235 ReportRegisterState ("Restoring thread state after function call. Restored register state:"); 236 237 } 238 else 239 { 240 if (log) 241 log->Printf ("ThreadPlanCallFunction(%p): DoTakedown called as no-op for thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n", this, m_thread.GetID(), m_valid, IsPlanComplete()); 242 } 243} 244 245void 246ThreadPlanCallFunction::WillPop () 247{ 248 DoTakedown(PlanSucceeded()); 249} 250 251void 252ThreadPlanCallFunction::GetDescription (Stream *s, DescriptionLevel level) 253{ 254 if (level == eDescriptionLevelBrief) 255 { 256 s->Printf("Function call thread plan"); 257 } 258 else 259 { 260 TargetSP target_sp (m_thread.CalculateTarget()); 261 s->Printf("Thread plan to call 0x%" PRIx64, m_function_addr.GetLoadAddress(target_sp.get())); 262 } 263} 264 265bool 266ThreadPlanCallFunction::ValidatePlan (Stream *error) 267{ 268 if (!m_valid) 269 { 270 if (error) 271 { 272 if (m_constructor_errors.GetSize() > 0) 273 error->PutCString (m_constructor_errors.GetData()); 274 else 275 error->PutCString ("Unknown error"); 276 } 277 return false; 278 } 279 280 return true; 281} 282 283 284Vote 285ThreadPlanCallFunction::ShouldReportStop(Event *event_ptr) 286{ 287 if (m_takedown_done || IsPlanComplete()) 288 return eVoteYes; 289 else 290 return ThreadPlan::ShouldReportStop(event_ptr); 291} 292 293bool 294ThreadPlanCallFunction::DoPlanExplainsStop (Event *event_ptr) 295{ 296 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP|LIBLLDB_LOG_PROCESS)); 297 m_real_stop_info_sp = GetPrivateStopInfo (); 298 299 // If our subplan knows why we stopped, even if it's done (which would forward the question to us) 300 // we answer yes. 301 if (m_subplan_sp.get() != NULL && m_subplan_sp->PlanExplainsStop(event_ptr)) 302 { 303 SetPlanComplete(); 304 return true; 305 } 306 307 // Check if the breakpoint is one of ours. 308 309 StopReason stop_reason; 310 if (!m_real_stop_info_sp) 311 stop_reason = eStopReasonNone; 312 else 313 stop_reason = m_real_stop_info_sp->GetStopReason(); 314 if (log) 315 log->Printf ("ThreadPlanCallFunction::PlanExplainsStop: Got stop reason - %s.", Thread::StopReasonAsCString(stop_reason)); 316 317 if (stop_reason == eStopReasonBreakpoint && BreakpointsExplainStop()) 318 return true; 319 320 // We control breakpoints separately from other "stop reasons." So first, 321 // check the case where we stopped for an internal breakpoint, in that case, continue on. 322 // If it is not an internal breakpoint, consult m_ignore_breakpoints. 323 324 325 if (stop_reason == eStopReasonBreakpoint) 326 { 327 ProcessSP process_sp (m_thread.CalculateProcess()); 328 uint64_t break_site_id = m_real_stop_info_sp->GetValue(); 329 BreakpointSiteSP bp_site_sp; 330 if (process_sp) 331 bp_site_sp = process_sp->GetBreakpointSiteList().FindByID(break_site_id); 332 if (bp_site_sp) 333 { 334 uint32_t num_owners = bp_site_sp->GetNumberOfOwners(); 335 bool is_internal = true; 336 for (uint32_t i = 0; i < num_owners; i++) 337 { 338 Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint(); 339 if (log) 340 log->Printf ("ThreadPlanCallFunction::PlanExplainsStop: hit breakpoint %d while calling function", bp.GetID()); 341 342 if (!bp.IsInternal()) 343 { 344 is_internal = false; 345 break; 346 } 347 } 348 if (is_internal) 349 { 350 if (log) 351 log->Printf ("ThreadPlanCallFunction::PlanExplainsStop hit an internal breakpoint, not stopping."); 352 return false; 353 } 354 } 355 356 if (m_ignore_breakpoints) 357 { 358 if (log) 359 log->Printf("ThreadPlanCallFunction::PlanExplainsStop: we are ignoring breakpoints, overriding breakpoint stop info ShouldStop, returning true"); 360 m_real_stop_info_sp->OverrideShouldStop(false); 361 return true; 362 } 363 else 364 { 365 if (log) 366 log->Printf("ThreadPlanCallFunction::PlanExplainsStop: we are not ignoring breakpoints, overriding breakpoint stop info ShouldStop, returning true"); 367 m_real_stop_info_sp->OverrideShouldStop(true); 368 return false; 369 } 370 } 371 else if (!m_unwind_on_error) 372 { 373 // If we don't want to discard this plan, than any stop we don't understand should be propagated up the stack. 374 return false; 375 } 376 else 377 { 378 // If the subplan is running, any crashes are attributable to us. 379 // If we want to discard the plan, then we say we explain the stop 380 // but if we are going to be discarded, let whoever is above us 381 // explain the stop. 382 // But don't discard the plan if the stop would restart itself (for instance if it is a 383 // signal that is set not to stop. Check that here first. We just say we explain the stop 384 // but aren't done and everything will continue on from there. 385 386 if (m_real_stop_info_sp->ShouldStopSynchronous(event_ptr)) 387 { 388 SetPlanComplete(false); 389 if (m_subplan_sp) 390 { 391 if (m_unwind_on_error) 392 return true; 393 else 394 return false; 395 } 396 else 397 return false; 398 } 399 else 400 return true; 401 } 402} 403 404bool 405ThreadPlanCallFunction::ShouldStop (Event *event_ptr) 406{ 407 // We do some computation in DoPlanExplainsStop that may or may not set the plan as complete. 408 // We need to do that here to make sure our state is correct. 409 DoPlanExplainsStop(event_ptr); 410 411 if (IsPlanComplete()) 412 { 413 ReportRegisterState ("Function completed. Register state was:"); 414 return true; 415 } 416 else 417 { 418 return false; 419 } 420} 421 422bool 423ThreadPlanCallFunction::StopOthers () 424{ 425 return m_stop_other_threads; 426} 427 428void 429ThreadPlanCallFunction::SetStopOthers (bool new_value) 430{ 431 if (m_subplan_sp) 432 { 433 ThreadPlanRunToAddress *address_plan = static_cast<ThreadPlanRunToAddress *>(m_subplan_sp.get()); 434 address_plan->SetStopOthers(new_value); 435 } 436 m_stop_other_threads = new_value; 437} 438 439StateType 440ThreadPlanCallFunction::GetPlanRunState () 441{ 442 return eStateRunning; 443} 444 445void 446ThreadPlanCallFunction::DidPush () 447{ 448//#define SINGLE_STEP_EXPRESSIONS 449 450 // Now set the thread state to "no reason" so we don't run with whatever signal was outstanding... 451 // Wait till the plan is pushed so we aren't changing the stop info till we're about to run. 452 453 GetThread().SetStopInfoToNothing(); 454 455#ifndef SINGLE_STEP_EXPRESSIONS 456 m_subplan_sp.reset(new ThreadPlanRunToAddress(m_thread, m_start_addr, m_stop_other_threads)); 457 458 m_thread.QueueThreadPlan(m_subplan_sp, false); 459 m_subplan_sp->SetPrivate (true); 460#endif 461} 462 463bool 464ThreadPlanCallFunction::WillStop () 465{ 466 return true; 467} 468 469bool 470ThreadPlanCallFunction::MischiefManaged () 471{ 472 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 473 474 if (IsPlanComplete()) 475 { 476 if (log) 477 log->Printf("ThreadPlanCallFunction(%p): Completed call function plan.", this); 478 479 ThreadPlan::MischiefManaged (); 480 return true; 481 } 482 else 483 { 484 return false; 485 } 486} 487 488void 489ThreadPlanCallFunction::SetBreakpoints () 490{ 491 ProcessSP process_sp (m_thread.CalculateProcess()); 492 if (m_trap_exceptions && process_sp) 493 { 494 m_cxx_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeC_plus_plus); 495 m_objc_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeObjC); 496 497 if (m_cxx_language_runtime) 498 { 499 m_should_clear_cxx_exception_bp = !m_cxx_language_runtime->ExceptionBreakpointsAreSet(); 500 m_cxx_language_runtime->SetExceptionBreakpoints(); 501 } 502 if (m_objc_language_runtime) 503 { 504 m_should_clear_objc_exception_bp = !m_objc_language_runtime->ExceptionBreakpointsAreSet(); 505 m_objc_language_runtime->SetExceptionBreakpoints(); 506 } 507 } 508} 509 510void 511ThreadPlanCallFunction::ClearBreakpoints () 512{ 513 if (m_trap_exceptions) 514 { 515 if (m_cxx_language_runtime && m_should_clear_cxx_exception_bp) 516 m_cxx_language_runtime->ClearExceptionBreakpoints(); 517 if (m_objc_language_runtime && m_should_clear_objc_exception_bp) 518 m_objc_language_runtime->ClearExceptionBreakpoints(); 519 } 520} 521 522bool 523ThreadPlanCallFunction::BreakpointsExplainStop() 524{ 525 StopInfoSP stop_info_sp = GetPrivateStopInfo (); 526 527 if (m_trap_exceptions) 528 { 529 if ((m_cxx_language_runtime && 530 m_cxx_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp)) 531 ||(m_objc_language_runtime && 532 m_objc_language_runtime->ExceptionBreakpointsExplainStop(stop_info_sp))) 533 { 534 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP)); 535 if (log) 536 log->Printf ("ThreadPlanCallFunction::BreakpointsExplainStop - Hit an exception breakpoint, setting plan complete."); 537 538 SetPlanComplete(false); 539 540 // If the user has set the ObjC language breakpoint, it would normally get priority over our internal 541 // catcher breakpoint, but in this case we can't let that happen, so force the ShouldStop here. 542 stop_info_sp->OverrideShouldStop (true); 543 return true; 544 } 545 } 546 547 return false; 548} 549 550bool 551ThreadPlanCallFunction::RestoreThreadState() 552{ 553 return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state); 554} 555 556