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