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

   1 //===-- ThreadPlanStepUntil.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 //m_should_stop
  10
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "lldb/Target/ThreadPlanStepUntil.h"
  15
  16 // C Includes
  17 // C++ Includes
  18 // Other libraries and framework includes
  19 // Project includes
  20 #include "lldb/Breakpoint/Breakpoint.h"
  21 #include "lldb/lldb-private-log.h"
  22 #include "lldb/Core/Log.h"
  23 #include "lldb/Target/Process.h"
  24 #include "lldb/Target/RegisterContext.h"
  25 #include "lldb/Target/StopInfo.h"
  26 #include "lldb/Target/Target.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30
  31 //----------------------------------------------------------------------
  32 // ThreadPlanStepUntil: Run until we reach a given line number or step out of the current frame
  33 //----------------------------------------------------------------------
  34
  35 ThreadPlanStepUntil::ThreadPlanStepUntil
  36 (
  37     Thread &thread,
  38     lldb::addr_t *address_list,
  39     size_t num_addresses,
  40     bool stop_others,
  41     uint32_t frame_idx
  42 ) :
  43     ThreadPlan (ThreadPlan::eKindStepUntil, "Step until", thread, eVoteNoOpinion, eVoteNoOpinion),
  44     m_step_from_insn (LLDB_INVALID_ADDRESS),
  45     m_return_bp_id (LLDB_INVALID_BREAK_ID),
  46     m_return_addr (LLDB_INVALID_ADDRESS),
  47     m_stepped_out (false),
  48     m_should_stop (false),
  49     m_ran_analyze (false),
  50     m_explains_stop (false),
  51     m_until_points (),
  52     m_stop_others (stop_others)
  53 {
  54     // Stash away our "until" addresses:
  55     TargetSP target_sp (m_thread.CalculateTarget());
  56
  57     StackFrameSP frame_sp (m_thread.GetStackFrameAtIndex (frame_idx));
  58     if (frame_sp)
  59     {
  60         m_step_from_insn = frame_sp->GetStackID().GetPC();
  61         lldb::user_id_t thread_id = m_thread.GetID();
  62
  63         // Find the return address and set a breakpoint there:
  64         // FIXME - can we do this more securely if we know first_insn?
  65
  66         StackFrameSP return_frame_sp (m_thread.GetStackFrameAtIndex(frame_idx + 1));
  67         if (return_frame_sp)
  68         {
  69             // TODO: add inline functionality
  70             m_return_addr = return_frame_sp->GetStackID().GetPC();
  71             Breakpoint *return_bp = target_sp->CreateBreakpoint (m_return_addr, true).get();
  72             if (return_bp != NULL)
  73             {
  74                 return_bp->SetThreadID(thread_id);
  75                 m_return_bp_id = return_bp->GetID();
  76                 return_bp->SetBreakpointKind ("until-return-backstop");
  77             }
  78         }
  79
  80         m_stack_id = m_thread.GetStackFrameAtIndex(frame_idx)->GetStackID();
  81
  82         // Now set breakpoints on all our return addresses:
  83         for (size_t i = 0; i < num_addresses; i++)
  84         {
  85             Breakpoint *until_bp = target_sp->CreateBreakpoint (address_list[i], true).get();
  86             if (until_bp != NULL)
  87             {
  88                 until_bp->SetThreadID(thread_id);
  89                 m_until_points[address_list[i]] = until_bp->GetID();
  90                 until_bp->SetBreakpointKind("until-target");
  91             }
  92             else
  93             {
  94                 m_until_points[address_list[i]] = LLDB_INVALID_BREAK_ID;
  95             }
  96         }
  97     }
  98 }
  99
 100 ThreadPlanStepUntil::~ThreadPlanStepUntil ()
 101 {
 102     Clear();
 103 }
 104
 105 void
 106 ThreadPlanStepUntil::Clear()
 107 {
 108     TargetSP target_sp (m_thread.CalculateTarget());
 109     if (target_sp)
 110     {
 111         if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
 112         {
 113             target_sp->RemoveBreakpointByID(m_return_bp_id);
 114             m_return_bp_id = LLDB_INVALID_BREAK_ID;
 115         }
 116
 117         until_collection::iterator pos, end = m_until_points.end();
 118         for (pos = m_until_points.begin(); pos != end; pos++)
 119         {
 120             target_sp->RemoveBreakpointByID((*pos).second);
 121         }
 122     }
 123     m_until_points.clear();
 124 }
 125
 126 void
 127 ThreadPlanStepUntil::GetDescription (Stream *s, lldb::DescriptionLevel level)
 128 {
 129     if (level == lldb::eDescriptionLevelBrief)
 130     {
 131         s->Printf ("step until");
 132         if (m_stepped_out)
 133             s->Printf (" - stepped out");
 134     }
 135     else
 136     {
 137         if (m_until_points.size() == 1)
 138             s->Printf ("Stepping from address 0x%" PRIx64 " until we reach 0x%" PRIx64 " using breakpoint %d",
 139                        (uint64_t)m_step_from_insn,
 140                        (uint64_t) (*m_until_points.begin()).first,
 141                        (*m_until_points.begin()).second);
 142         else
 143         {
 144             until_collection::iterator pos, end = m_until_points.end();
 145             s->Printf ("Stepping from address 0x%" PRIx64 " until we reach one of:",
 146                        (uint64_t)m_step_from_insn);
 147             for (pos = m_until_points.begin(); pos != end; pos++)
 148             {
 149                 s->Printf ("\n\t0x%" PRIx64 " (bp: %d)", (uint64_t) (*pos).first, (*pos).second);
 150             }
 151         }
 152         s->Printf(" stepped out address is 0x%" PRIx64 ".", (uint64_t) m_return_addr);
 153     }
 154 }
 155
 156 bool
 157 ThreadPlanStepUntil::ValidatePlan (Stream *error)
 158 {
 159     if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
 160         return false;
 161     else
 162     {
 163         until_collection::iterator pos, end = m_until_points.end();
 164         for (pos = m_until_points.begin(); pos != end; pos++)
 165         {
 166             if (!LLDB_BREAK_ID_IS_VALID ((*pos).second))
 167                 return false;
 168         }
 169         return true;
 170     }
 171 }
 172
 173 void
 174 ThreadPlanStepUntil::AnalyzeStop()
 175 {
 176     if (m_ran_analyze)
 177         return;
 178
 179     StopInfoSP stop_info_sp = GetPrivateStopInfo ();
 180     m_should_stop = true;
 181     m_explains_stop = false;
 182
 183     if (stop_info_sp)
 184     {
 185         StopReason reason = stop_info_sp->GetStopReason();
 186
 187         switch (reason)
 188         {
 189             case eStopReasonBreakpoint:
 190             {
 191                 // If this is OUR breakpoint, we're fine, otherwise we don't know why this happened...
 192                 BreakpointSiteSP this_site = m_thread.GetProcess()->GetBreakpointSiteList().FindByID (stop_info_sp->GetValue());
 193                 if (!this_site)
 194                 {
 195                     m_explains_stop = false;
 196                     return;
 197                 }
 198
 199                 if (this_site->IsBreakpointAtThisSite (m_return_bp_id))
 200                 {
 201                     // If we are at our "step out" breakpoint, and the stack depth has shrunk, then
 202                     // this is indeed our stop.
 203                     // If the stack depth has grown, then we've hit our step out breakpoint recursively.
 204                     // If we are the only breakpoint at that location, then we do explain the stop, and
 205                     // we'll just continue.
 206                     // If there was another breakpoint here, then we don't explain the stop, but we won't
 207                     // mark ourselves Completed, because maybe that breakpoint will continue, and then
 208                     // we'll finish the "until".
 209                     bool done;
 210                     StackID cur_frame_zero_id;
 211
 212                     if (m_stack_id < cur_frame_zero_id)
 213                         done = true;
 214                     else
 215                         done = false;
 216
 217                     if (done)
 218                     {
 219                         m_stepped_out = true;
 220                         SetPlanComplete();
 221                     }
 222                     else
 223                         m_should_stop = false;
 224
 225                     if (this_site->GetNumberOfOwners() == 1)
 226                         m_explains_stop = true;
 227                     else
 228                         m_explains_stop = false;
 229                     return;
 230                 }
 231                 else
 232                 {
 233                     // Check if we've hit one of our "until" breakpoints.
 234                     until_collection::iterator pos, end = m_until_points.end();
 235                     for (pos = m_until_points.begin(); pos != end; pos++)
 236                     {
 237                         if (this_site->IsBreakpointAtThisSite ((*pos).second))
 238                         {
 239                             // If we're at the right stack depth, then we're done.
 240
 241                             bool done;
 242                             StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 243
 244                             if (frame_zero_id == m_stack_id)
 245                                 done = true;
 246                             else if (frame_zero_id < m_stack_id)
 247                                 done = false;
 248                             else
 249                             {
 250                                 StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
 251
 252                                 // But if we can't even unwind one frame we should just get out of here & stop...
 253                                 if (older_frame_sp)
 254                                 {
 255                                     const SymbolContext &older_context
 256                                         = older_frame_sp->GetSymbolContext(eSymbolContextEverything);
 257                                     SymbolContext stack_context;
 258                                     m_stack_id.GetSymbolContextScope()->CalculateSymbolContext(&stack_context);
 259
 260                                     if (older_context == stack_context)
 261                                         done = true;
 262                                     else
 263                                         done = false;
 264                                 }
 265                                 else
 266                                     done = false;
 267                             }
 268
 269                             if (done)
 270                                 SetPlanComplete();
 271                             else
 272                                 m_should_stop = false;
 273
 274                             // Otherwise we've hit this breakpoint recursively.  If we're the
 275                             // only breakpoint here, then we do explain the stop, and we'll continue.
 276                             // If not then we should let higher plans handle this stop.
 277                             if (this_site->GetNumberOfOwners() == 1)
 278                                 m_explains_stop = true;
 279                             else
 280                             {
 281                                 m_should_stop = true;
 282                                 m_explains_stop = false;
 283                             }
 284                             return;
 285                         }
 286                     }
 287                 }
 288                 // If we get here we haven't hit any of our breakpoints, so let the higher
 289                 // plans take care of the stop.
 290                 m_explains_stop = false;
 291                 return;
 292             }
 293             case eStopReasonWatchpoint:
 294             case eStopReasonSignal:
 295             case eStopReasonException:
 296             case eStopReasonExec:
 297             case eStopReasonThreadExiting:
 298                 m_explains_stop = false;
 299                 break;
 300             default:
 301                 m_explains_stop = true;
 302                 break;
 303         }
 304     }
 305 }
 306
 307 bool
 308 ThreadPlanStepUntil::DoPlanExplainsStop (Event *event_ptr)
 309 {
 310     // We don't explain signals or breakpoints (breakpoints that handle stepping in or
 311     // out will be handled by a child plan.
 312     AnalyzeStop();
 313     return m_explains_stop;
 314 }
 315
 316 bool
 317 ThreadPlanStepUntil::ShouldStop (Event *event_ptr)
 318 {
 319     // If we've told our self in ExplainsStop that we plan to continue, then
 320     // do so here.  Otherwise, as long as this thread has stopped for a reason,
 321     // we will stop.
 322
 323     StopInfoSP stop_info_sp = GetPrivateStopInfo ();
 324     if (!stop_info_sp || stop_info_sp->GetStopReason() == eStopReasonNone)
 325         return false;
 326
 327     AnalyzeStop();
 328     return m_should_stop;
 329 }
 330
 331 bool
 332 ThreadPlanStepUntil::StopOthers ()
 333 {
 334     return m_stop_others;
 335 }
 336
 337 StateType
 338 ThreadPlanStepUntil::GetPlanRunState ()
 339 {
 340     return eStateRunning;
 341 }
 342
 343 bool
 344 ThreadPlanStepUntil::DoWillResume (StateType resume_state, bool current_plan)
 345 {
 346     if (current_plan)
 347     {
 348         TargetSP target_sp (m_thread.CalculateTarget());
 349         if (target_sp)
 350         {
 351             Breakpoint *return_bp = target_sp->GetBreakpointByID(m_return_bp_id).get();
 352             if (return_bp != NULL)
 353                 return_bp->SetEnabled (true);
 354
 355             until_collection::iterator pos, end = m_until_points.end();
 356             for (pos = m_until_points.begin(); pos != end; pos++)
 357             {
 358                 Breakpoint *until_bp = target_sp->GetBreakpointByID((*pos).second).get();
 359                 if (until_bp != NULL)
 360                     until_bp->SetEnabled (true);
 361             }
 362         }
 363     }
 364
 365     m_should_stop = true;
 366     m_ran_analyze = false;
 367     m_explains_stop = false;
 368     return true;
 369 }
 370
 371 bool
 372 ThreadPlanStepUntil::WillStop ()
 373 {
 374     TargetSP target_sp (m_thread.CalculateTarget());
 375     if (target_sp)
 376     {
 377         Breakpoint *return_bp = target_sp->GetBreakpointByID(m_return_bp_id).get();
 378         if (return_bp != NULL)
 379             return_bp->SetEnabled (false);
 380
 381         until_collection::iterator pos, end = m_until_points.end();
 382         for (pos = m_until_points.begin(); pos != end; pos++)
 383         {
 384             Breakpoint *until_bp = target_sp->GetBreakpointByID((*pos).second).get();
 385             if (until_bp != NULL)
 386                 until_bp->SetEnabled (false);
 387         }
 388     }
 389     return true;
 390 }
 391
 392 bool
 393 ThreadPlanStepUntil::MischiefManaged ()
 394 {
 395
 396     // I'm letting "PlanExplainsStop" do all the work, and just reporting that here.
 397     bool done = false;
 398     if (IsPlanComplete())
 399     {
 400         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 401         if (log)
 402             log->Printf("Completed step until plan.");
 403
 404         Clear();
 405         done = true;
 406     }
 407     if (done)
 408         ThreadPlan::MischiefManaged ();
 409
 410     return done;
 411
 412 }
 413