contrib/llvm/tools/lldb/source/Target/ThreadPlanCallFunction.cpp

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