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 #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
  33 using namespace lldb;
  34 using namespace lldb_private;
  35
  36 //----------------------------------------------------------------------
  37 // ThreadPlanCallFunction: Plan to call a single function
  38 //----------------------------------------------------------------------
  39 bool
  40 ThreadPlanCallFunction::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
 126 ThreadPlanCallFunction::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
 164 ThreadPlanCallFunction::~ThreadPlanCallFunction ()
 165 {
 166     DoTakedown(PlanSucceeded());
 167 }
 168
 169 void
 170 ThreadPlanCallFunction::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
 197 void
 198 ThreadPlanCallFunction::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
 245 void
 246 ThreadPlanCallFunction::WillPop ()
 247 {
 248     DoTakedown(PlanSucceeded());
 249 }
 250
 251 void
 252 ThreadPlanCallFunction::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
 265 bool
 266 ThreadPlanCallFunction::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
 284 Vote
 285 ThreadPlanCallFunction::ShouldReportStop(Event *event_ptr)
 286 {
 287     if (m_takedown_done || IsPlanComplete())
 288         return eVoteYes;
 289     else
 290         return ThreadPlan::ShouldReportStop(event_ptr);
 291 }
 292
 293 bool
 294 ThreadPlanCallFunction::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
 404 bool
 405 ThreadPlanCallFunction::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
 422 bool
 423 ThreadPlanCallFunction::StopOthers ()
 424 {
 425     return m_stop_other_threads;
 426 }
 427
 428 void
 429 ThreadPlanCallFunction::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
 439 StateType
 440 ThreadPlanCallFunction::GetPlanRunState ()
 441 {
 442     return eStateRunning;
 443 }
 444
 445 void
 446 ThreadPlanCallFunction::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
 463 bool
 464 ThreadPlanCallFunction::WillStop ()
 465 {
 466     return true;
 467 }
 468
 469 bool
 470 ThreadPlanCallFunction::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
 488 void
 489 ThreadPlanCallFunction::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
 510 void
 511 ThreadPlanCallFunction::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
 522 bool
 523 ThreadPlanCallFunction::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
 550 bool
 551 ThreadPlanCallFunction::RestoreThreadState()
 552 {
 553     return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state);
 554 }
 555