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

   1 //===-- ThreadPlanStepOut.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/ThreadPlanStepOut.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Breakpoint/Breakpoint.h"
  17 #include "lldb/lldb-private-log.h"
  18 #include "lldb/Core/Log.h"
  19 #include "lldb/Core/Value.h"
  20 #include "lldb/Core/ValueObjectConstResult.h"
  21 #include "lldb/Symbol/Block.h"
  22 #include "lldb/Symbol/Function.h"
  23 #include "lldb/Symbol/Type.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/ThreadPlanStepOverRange.h"
  29 #include "lldb/Target/ThreadPlanStepThrough.h"
  30
  31 using namespace lldb;
  32 using namespace lldb_private;
  33
  34 uint32_t ThreadPlanStepOut::s_default_flag_values = 0;
  35
  36 //----------------------------------------------------------------------
  37 // ThreadPlanStepOut: Step out of the current frame
  38 //----------------------------------------------------------------------
  39 ThreadPlanStepOut::ThreadPlanStepOut
  40 (
  41     Thread &thread,
  42     SymbolContext *context,
  43     bool first_insn,
  44     bool stop_others,
  45     Vote stop_vote,
  46     Vote run_vote,
  47     uint32_t frame_idx,
  48     LazyBool step_out_avoids_code_without_debug_info
  49 ) :
  50     ThreadPlan (ThreadPlan::eKindStepOut, "Step out", thread, stop_vote, run_vote),
  51     ThreadPlanShouldStopHere (this),
  52     m_step_from_insn (LLDB_INVALID_ADDRESS),
  53     m_return_bp_id (LLDB_INVALID_BREAK_ID),
  54     m_return_addr (LLDB_INVALID_ADDRESS),
  55     m_stop_others (stop_others),
  56     m_immediate_step_from_function(NULL)
  57 {
  58     SetFlagsToDefault();
  59     SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);
  60
  61     m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
  62
  63     StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
  64     StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (frame_idx));
  65
  66     if (!return_frame_sp || !immediate_return_from_sp)
  67         return; // we can't do anything here.  ValidatePlan() will return false.
  68
  69     m_step_out_to_id = return_frame_sp->GetStackID();
  70     m_immediate_step_from_id = immediate_return_from_sp->GetStackID();
  71
  72     StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  73
  74     // If the frame directly below the one we are returning to is inlined, we have to be
  75     // a little more careful.  It is non-trivial to determine the real "return code address" for
  76     // an inlined frame, so we have to work our way to that frame and then step out.
  77     if (immediate_return_from_sp && immediate_return_from_sp->IsInlined())
  78     {
  79         if (frame_idx > 0)
  80         {
  81             // First queue a plan that gets us to this inlined frame, and when we get there we'll queue a second
  82             // plan that walks us out of this frame.
  83             m_step_out_to_inline_plan_sp.reset (new ThreadPlanStepOut(m_thread,
  84                                                             NULL,
  85                                                             false,
  86                                                             stop_others,
  87                                                             eVoteNoOpinion,
  88                                                             eVoteNoOpinion,
  89                                                             frame_idx - 1,
  90                                                             eLazyBoolNo));
  91             static_cast<ThreadPlanStepOut *>(m_step_out_to_inline_plan_sp.get())->SetShouldStopHereCallbacks(nullptr, nullptr);
  92             m_step_out_to_inline_plan_sp->SetPrivate(true);
  93         }
  94         else
  95         {
  96             // If we're already at the inlined frame we're stepping through, then just do that now.
  97             QueueInlinedStepPlan(false);
  98         }
  99
 100     }
 101     else if (return_frame_sp)
 102     {
 103         // Find the return address and set a breakpoint there:
 104         // FIXME - can we do this more securely if we know first_insn?
 105
 106         m_return_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(&m_thread.GetProcess()->GetTarget());
 107
 108         if (m_return_addr == LLDB_INVALID_ADDRESS)
 109             return;
 110
 111         Breakpoint *return_bp = m_thread.CalculateTarget()->CreateBreakpoint (m_return_addr, true, false).get();
 112         if (return_bp != NULL)
 113         {
 114             return_bp->SetThreadID(m_thread.GetID());
 115             m_return_bp_id = return_bp->GetID();
 116             return_bp->SetBreakpointKind ("step-out");
 117         }
 118
 119         if (immediate_return_from_sp)
 120         {
 121             const SymbolContext &sc = immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
 122             if (sc.function)
 123             {
 124                 m_immediate_step_from_function = sc.function;
 125             }
 126         }
 127     }
 128
 129 }
 130
 131 void
 132 ThreadPlanStepOut::SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info)
 133 {
 134     bool avoid_nodebug = true;
 135     switch (step_out_avoids_code_without_debug_info)
 136     {
 137         case eLazyBoolYes:
 138             avoid_nodebug = true;
 139             break;
 140         case eLazyBoolNo:
 141             avoid_nodebug = false;
 142             break;
 143         case eLazyBoolCalculate:
 144             avoid_nodebug = m_thread.GetStepOutAvoidsNoDebug();
 145             break;
 146     }
 147     if (avoid_nodebug)
 148         GetFlags().Set (ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
 149     else
 150         GetFlags().Clear (ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
 151 }
 152
 153 void
 154 ThreadPlanStepOut::DidPush()
 155 {
 156     if (m_step_out_to_inline_plan_sp)
 157         m_thread.QueueThreadPlan(m_step_out_to_inline_plan_sp, false);
 158     else if (m_step_through_inline_plan_sp)
 159         m_thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
 160 }
 161
 162 ThreadPlanStepOut::~ThreadPlanStepOut ()
 163 {
 164     if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
 165         m_thread.CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
 166 }
 167
 168 void
 169 ThreadPlanStepOut::GetDescription (Stream *s, lldb::DescriptionLevel level)
 170 {
 171     if (level == lldb::eDescriptionLevelBrief)
 172         s->Printf ("step out");
 173     else
 174     {
 175         if (m_step_out_to_inline_plan_sp)
 176             s->Printf ("Stepping out to inlined frame so we can walk through it.");
 177         else if (m_step_through_inline_plan_sp)
 178             s->Printf ("Stepping out by stepping through inlined function.");
 179         else
 180         {
 181             s->Printf ("Stepping out from ");
 182             Address tmp_address;
 183             if (tmp_address.SetLoadAddress (m_step_from_insn, &GetTarget()))
 184             {
 185                 tmp_address.Dump(s, &GetThread(), Address::DumpStyleResolvedDescription, Address::DumpStyleLoadAddress);
 186             }
 187             else
 188             {
 189                 s->Printf ("address 0x%" PRIx64 "", (uint64_t)m_step_from_insn);
 190             }
 191
 192             // FIXME: find some useful way to present the m_return_id, since there may be multiple copies of the
 193             // same function on the stack.
 194
 195             s->Printf ("returning to frame at ");
 196             if (tmp_address.SetLoadAddress (m_return_addr, &GetTarget()))
 197             {
 198                 tmp_address.Dump(s, &GetThread(), Address::DumpStyleResolvedDescription, Address::DumpStyleLoadAddress);
 199             }
 200             else
 201             {
 202                 s->Printf ("address 0x%" PRIx64 "", (uint64_t)m_return_addr);
 203             }
 204
 205             if (level == eDescriptionLevelVerbose)
 206                 s->Printf(" using breakpoint site %d", m_return_bp_id);
 207         }
 208     }
 209 }
 210
 211 bool
 212 ThreadPlanStepOut::ValidatePlan (Stream *error)
 213 {
 214     if (m_step_out_to_inline_plan_sp)
 215         return m_step_out_to_inline_plan_sp->ValidatePlan (error);
 216     else if (m_step_through_inline_plan_sp)
 217         return m_step_through_inline_plan_sp->ValidatePlan (error);
 218     else if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
 219     {
 220         if (error)
 221             error->PutCString("Could not create return address breakpoint.");
 222         return false;
 223     }
 224     else
 225         return true;
 226 }
 227
 228 bool
 229 ThreadPlanStepOut::DoPlanExplainsStop (Event *event_ptr)
 230 {
 231     // If the step out plan is done, then we just need to step through the inlined frame.
 232     if (m_step_out_to_inline_plan_sp)
 233     {
 234         if (m_step_out_to_inline_plan_sp->MischiefManaged())
 235             return true;
 236         else
 237             return false;
 238     }
 239     else if (m_step_through_inline_plan_sp)
 240     {
 241         if (m_step_through_inline_plan_sp->MischiefManaged())
 242         {
 243             CalculateReturnValue();
 244             SetPlanComplete();
 245             return true;
 246         }
 247         else
 248             return false;
 249     }
 250     else if (m_step_out_further_plan_sp)
 251     {
 252         if (m_step_out_further_plan_sp->MischiefManaged())
 253             return true;
 254         else
 255             return false;
 256     }
 257
 258     // We don't explain signals or breakpoints (breakpoints that handle stepping in or
 259     // out will be handled by a child plan.
 260
 261     StopInfoSP stop_info_sp = GetPrivateStopInfo ();
 262     if (stop_info_sp)
 263     {
 264         StopReason reason = stop_info_sp->GetStopReason();
 265         switch (reason)
 266         {
 267         case eStopReasonBreakpoint:
 268         {
 269             // If this is OUR breakpoint, we're fine, otherwise we don't know why this happened...
 270             BreakpointSiteSP site_sp (m_thread.GetProcess()->GetBreakpointSiteList().FindByID (stop_info_sp->GetValue()));
 271             if (site_sp && site_sp->IsBreakpointAtThisSite (m_return_bp_id))
 272             {
 273                 bool done;
 274
 275                 StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 276
 277                 if (m_step_out_to_id == frame_zero_id)
 278                     done = true;
 279                 else if (m_step_out_to_id < frame_zero_id)
 280                 {
 281                     // Either we stepped past the breakpoint, or the stack ID calculation
 282                     // was incorrect and we should probably stop.
 283                     done = true;
 284                 }
 285                 else
 286                 {
 287                     if (m_immediate_step_from_id < frame_zero_id)
 288                         done = true;
 289                     else
 290                         done = false;
 291                 }
 292
 293                 if (done)
 294                 {
 295                     if (InvokeShouldStopHereCallback (eFrameCompareOlder))
 296                     {
 297                         CalculateReturnValue();
 298                         SetPlanComplete();
 299                     }
 300                 }
 301
 302                 // If there was only one owner, then we're done.  But if we also hit some
 303                 // user breakpoint on our way out, we should mark ourselves as done, but
 304                 // also not claim to explain the stop, since it is more important to report
 305                 // the user breakpoint than the step out completion.
 306
 307                 if (site_sp->GetNumberOfOwners() == 1)
 308                     return true;
 309
 310             }
 311             return false;
 312         }
 313         case eStopReasonWatchpoint:
 314         case eStopReasonSignal:
 315         case eStopReasonException:
 316         case eStopReasonExec:
 317         case eStopReasonThreadExiting:
 318             return false;
 319
 320         default:
 321             return true;
 322         }
 323     }
 324     return true;
 325 }
 326
 327 bool
 328 ThreadPlanStepOut::ShouldStop (Event *event_ptr)
 329 {
 330     if (IsPlanComplete())
 331         return true;
 332
 333     bool done = false;
 334     if (m_step_out_to_inline_plan_sp)
 335     {
 336         if (m_step_out_to_inline_plan_sp->MischiefManaged())
 337         {
 338             // Now step through the inlined stack we are in:
 339             if (QueueInlinedStepPlan(true))
 340             {
 341                 // If we can't queue a plan to do this, then just call ourselves done.
 342                 m_step_out_to_inline_plan_sp.reset();
 343                 SetPlanComplete (false);
 344                 return true;
 345             }
 346             else
 347                 done = true;
 348         }
 349         else
 350             return m_step_out_to_inline_plan_sp->ShouldStop(event_ptr);
 351     }
 352     else if (m_step_through_inline_plan_sp)
 353     {
 354         if (m_step_through_inline_plan_sp->MischiefManaged())
 355             done = true;
 356         else
 357             return m_step_through_inline_plan_sp->ShouldStop(event_ptr);
 358     }
 359     else if (m_step_out_further_plan_sp)
 360     {
 361         if (m_step_out_further_plan_sp->MischiefManaged())
 362             m_step_out_further_plan_sp.reset();
 363         else
 364             return m_step_out_further_plan_sp->ShouldStop(event_ptr);
 365     }
 366
 367     if (!done)
 368     {
 369         StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 370         if (frame_zero_id < m_step_out_to_id)
 371             done = false;
 372         else
 373             done = true;
 374     }
 375
 376     // The normal step out computations think we are done, so all we need to do is consult the ShouldStopHere,
 377     // and we are done.
 378
 379     if (done)
 380     {
 381         if (InvokeShouldStopHereCallback(eFrameCompareOlder))
 382         {
 383             CalculateReturnValue();
 384             SetPlanComplete();
 385         }
 386         else
 387         {
 388             m_step_out_further_plan_sp = QueueStepOutFromHerePlan(m_flags, eFrameCompareOlder);
 389             done = false;
 390         }
 391     }
 392
 393     return done;
 394 }
 395
 396 bool
 397 ThreadPlanStepOut::StopOthers ()
 398 {
 399     return m_stop_others;
 400 }
 401
 402 StateType
 403 ThreadPlanStepOut::GetPlanRunState ()
 404 {
 405     return eStateRunning;
 406 }
 407
 408 bool
 409 ThreadPlanStepOut::DoWillResume (StateType resume_state, bool current_plan)
 410 {
 411     if (m_step_out_to_inline_plan_sp || m_step_through_inline_plan_sp)
 412         return true;
 413
 414     if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
 415         return false;
 416
 417     if (current_plan)
 418     {
 419         Breakpoint *return_bp = m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
 420         if (return_bp != NULL)
 421             return_bp->SetEnabled (true);
 422     }
 423     return true;
 424 }
 425
 426 bool
 427 ThreadPlanStepOut::WillStop ()
 428 {
 429     if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
 430     {
 431         Breakpoint *return_bp = m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
 432         if (return_bp != NULL)
 433             return_bp->SetEnabled (false);
 434     }
 435
 436     return true;
 437 }
 438
 439 bool
 440 ThreadPlanStepOut::MischiefManaged ()
 441 {
 442     if (IsPlanComplete())
 443     {
 444         // Did I reach my breakpoint?  If so I'm done.
 445         //
 446         // I also check the stack depth, since if we've blown past the breakpoint for some
 447         // reason and we're now stopping for some other reason altogether, then we're done
 448         // with this step out operation.
 449
 450         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 451         if (log)
 452             log->Printf("Completed step out plan.");
 453         if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
 454         {
 455             m_thread.CalculateTarget()->RemoveBreakpointByID (m_return_bp_id);
 456             m_return_bp_id = LLDB_INVALID_BREAK_ID;
 457         }
 458
 459         ThreadPlan::MischiefManaged ();
 460         return true;
 461     }
 462     else
 463     {
 464         return false;
 465     }
 466 }
 467
 468 bool
 469 ThreadPlanStepOut::QueueInlinedStepPlan (bool queue_now)
 470 {
 471     // Now figure out the range of this inlined block, and set up a "step through range"
 472     // plan for that.  If we've been provided with a context, then use the block in that
 473     // context.
 474     StackFrameSP immediate_return_from_sp (m_thread.GetStackFrameAtIndex (0));
 475     if (!immediate_return_from_sp)
 476         return false;
 477
 478     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 479     if (log)
 480     {
 481         StreamString s;
 482         immediate_return_from_sp->Dump(&s, true, false);
 483         log->Printf("Queuing inlined frame to step past: %s.", s.GetData());
 484     }
 485
 486     Block *from_block = immediate_return_from_sp->GetFrameBlock();
 487     if (from_block)
 488     {
 489         Block *inlined_block = from_block->GetContainingInlinedBlock();
 490         if (inlined_block)
 491         {
 492             size_t num_ranges = inlined_block->GetNumRanges();
 493             AddressRange inline_range;
 494             if (inlined_block->GetRangeAtIndex(0, inline_range))
 495             {
 496                 SymbolContext inlined_sc;
 497                 inlined_block->CalculateSymbolContext(&inlined_sc);
 498                 inlined_sc.target_sp = GetTarget().shared_from_this();
 499                 RunMode run_mode = m_stop_others ? lldb::eOnlyThisThread : lldb::eAllThreads;
 500                 const LazyBool avoid_no_debug = eLazyBoolNo;
 501
 502                 m_step_through_inline_plan_sp.reset (new ThreadPlanStepOverRange(m_thread,
 503                                                                                  inline_range,
 504                                                                                  inlined_sc,
 505                                                                                  run_mode,
 506                                                                                  avoid_no_debug));
 507                 ThreadPlanStepOverRange *step_through_inline_plan_ptr
 508                         = static_cast<ThreadPlanStepOverRange *>(m_step_through_inline_plan_sp.get());
 509                 m_step_through_inline_plan_sp->SetPrivate(true);
 510
 511                 step_through_inline_plan_ptr->SetOkayToDiscard(true);
 512                 StreamString errors;
 513                 if (!step_through_inline_plan_ptr->ValidatePlan(&errors))
 514                 {
 515                     //FIXME: Log this failure.
 516                     delete step_through_inline_plan_ptr;
 517                     return false;
 518                 }
 519
 520                 for (size_t i = 1; i < num_ranges; i++)
 521                 {
 522                     if (inlined_block->GetRangeAtIndex (i, inline_range))
 523                         step_through_inline_plan_ptr->AddRange (inline_range);
 524                 }
 525
 526                 if (queue_now)
 527                     m_thread.QueueThreadPlan (m_step_through_inline_plan_sp, false);
 528                 return true;
 529             }
 530         }
 531     }
 532
 533     return false;
 534 }
 535
 536 void
 537 ThreadPlanStepOut::CalculateReturnValue ()
 538 {
 539     if (m_return_valobj_sp)
 540         return;
 541
 542     if (m_immediate_step_from_function != NULL)
 543     {
 544         ClangASTType return_clang_type = m_immediate_step_from_function->GetClangType().GetFunctionReturnType();
 545         if (return_clang_type)
 546         {
 547             lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI();
 548             if (abi_sp)
 549                 m_return_valobj_sp = abi_sp->GetReturnValueObject(m_thread, return_clang_type);
 550         }
 551     }
 552 }
 553
 554 bool
 555 ThreadPlanStepOut::IsPlanStale()
 556 {
 557     // If we are still lower on the stack than the frame we are returning to, then
 558     // there's something for us to do.  Otherwise, we're stale.
 559
 560     StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 561     if (frame_zero_id < m_step_out_to_id)
 562         return false;
 563     else
 564         return true;
 565 }