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

   1 //===-- ThreadPlanStepInstruction.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/ThreadPlanStepInstruction.h"
  15 #include "lldb/Core/Log.h"
  16 #include "lldb/Core/Stream.h"
  17 #include "lldb/Target/Process.h"
  18 #include "lldb/Target/RegisterContext.h"
  19 #include "lldb/Target/RegisterContext.h"
  20 #include "lldb/Target/StopInfo.h"
  21 #include "lldb/Target/Target.h"
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 //----------------------------------------------------------------------
  27 // ThreadPlanStepInstruction: Step over the current instruction
  28 //----------------------------------------------------------------------
  29
  30 ThreadPlanStepInstruction::ThreadPlanStepInstruction
  31 (
  32     Thread &thread,
  33     bool step_over,
  34     bool stop_other_threads,
  35     Vote stop_vote,
  36     Vote run_vote
  37 ) :
  38     ThreadPlan (ThreadPlan::eKindStepInstruction, "Step over single instruction", thread, stop_vote, run_vote),
  39     m_instruction_addr (0),
  40     m_stop_other_threads (stop_other_threads),
  41     m_step_over (step_over)
  42 {
  43     m_takes_iteration_count = true;
  44     SetUpState();
  45 }
  46
  47 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
  48
  49 void
  50 ThreadPlanStepInstruction::SetUpState()
  51 {
  52     m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
  53     StackFrameSP start_frame_sp(m_thread.GetStackFrameAtIndex(0));
  54     m_stack_id = start_frame_sp->GetStackID();
  55
  56     m_start_has_symbol = start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
  57
  58     StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
  59     if (parent_frame_sp)
  60         m_parent_frame_id = parent_frame_sp->GetStackID();
  61 }
  62
  63 void
  64 ThreadPlanStepInstruction::GetDescription (Stream *s, lldb::DescriptionLevel level)
  65 {
  66     if (level == lldb::eDescriptionLevelBrief)
  67     {
  68         if (m_step_over)
  69             s->Printf ("instruction step over");
  70         else
  71             s->Printf ("instruction step into");
  72     }
  73     else
  74     {
  75         s->Printf ("Stepping one instruction past ");
  76         s->Address(m_instruction_addr, sizeof (addr_t));
  77         if (!m_start_has_symbol)
  78             s->Printf(" which has no symbol");
  79
  80         if (m_step_over)
  81             s->Printf(" stepping over calls");
  82         else
  83             s->Printf(" stepping into calls");
  84     }
  85 }
  86
  87 bool
  88 ThreadPlanStepInstruction::ValidatePlan (Stream *error)
  89 {
  90     // Since we read the instruction we're stepping over from the thread,
  91     // this plan will always work.
  92     return true;
  93 }
  94
  95 bool
  96 ThreadPlanStepInstruction::DoPlanExplainsStop (Event *event_ptr)
  97 {
  98     StopInfoSP stop_info_sp = GetPrivateStopInfo ();
  99     if (stop_info_sp)
 100     {
 101         StopReason reason = stop_info_sp->GetStopReason();
 102         return (reason == eStopReasonTrace || reason == eStopReasonNone);
 103     }
 104     return false;
 105 }
 106
 107 bool
 108 ThreadPlanStepInstruction::IsPlanStale ()
 109 {
 110     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 111     StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
 112     if (cur_frame_id == m_stack_id)
 113     {
 114         return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
 115     }
 116     else if (cur_frame_id < m_stack_id)
 117     {
 118         // If the current frame is younger than the start frame and we are stepping over, then we need to continue,
 119         // but if we are doing just one step, we're done.
 120         return !m_step_over;
 121     }
 122     else
 123     {
 124         if (log)
 125         {
 126             log->Printf ("ThreadPlanStepInstruction::IsPlanStale - Current frame is older than start frame, plan is stale.");
 127         }
 128         return true;
 129     }
 130 }
 131
 132 bool
 133 ThreadPlanStepInstruction::ShouldStop (Event *event_ptr)
 134 {
 135     if (m_step_over)
 136     {
 137         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 138
 139         StackFrameSP cur_frame_sp = m_thread.GetStackFrameAtIndex(0);
 140         if (!cur_frame_sp)
 141         {
 142             if (log)
 143                 log->Printf ("ThreadPlanStepInstruction couldn't get the 0th frame, stopping.");
 144             SetPlanComplete();
 145             return true;
 146         }
 147
 148         StackID cur_frame_zero_id = cur_frame_sp->GetStackID();
 149
 150         if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id)
 151         {
 152             if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr)
 153             {
 154                 if (--m_iteration_count <= 0)
 155                 {
 156                     SetPlanComplete();
 157                     return true;
 158                 }
 159                 else
 160                 {
 161                     // We are still stepping, reset the start pc, and in case we've stepped out,
 162                     // reset the current stack id.
 163                     SetUpState();
 164                     return false;
 165                 }
 166             }
 167             else
 168                 return false;
 169         }
 170         else
 171         {
 172             // We've stepped in, step back out again:
 173             StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
 174             if (return_frame)
 175             {
 176                 if (return_frame->GetStackID() != m_parent_frame_id || m_start_has_symbol)
 177                 {
 178                     // next-instruction shouldn't step out of inlined functions.  But we may have stepped into a
 179                     // real function that starts with an inlined function, and we do want to step out of that...
 180
 181                     if (cur_frame_sp->IsInlined())
 182                     {
 183                         StackFrameSP parent_frame_sp = m_thread.GetFrameWithStackID(m_stack_id);
 184
 185                         if(parent_frame_sp && parent_frame_sp->GetConcreteFrameIndex() == cur_frame_sp->GetConcreteFrameIndex())
 186                         {
 187                             SetPlanComplete();
 188                             if (log)
 189                             {
 190                                 log->Printf("Frame we stepped into is inlined into the frame we were stepping from, stopping.");
 191                             }
 192                             return true;
 193                         }
 194                     }
 195
 196                     if (log)
 197                     {
 198                         StreamString s;
 199                         s.PutCString ("Stepped in to: ");
 200                         addr_t stop_addr = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
 201                         s.Address (stop_addr, m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
 202                         s.PutCString (" stepping out to: ");
 203                         addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
 204                         s.Address (return_addr, m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
 205                         log->Printf("%s.", s.GetData());
 206                     }
 207
 208                     // StepInstruction should probably have the tri-state RunMode, but for now it is safer to
 209                     // run others.
 210                     const bool stop_others = false;
 211                     m_thread.QueueThreadPlanForStepOutNoShouldStop(false,
 212                                                                    nullptr,
 213                                                                    true,
 214                                                                    stop_others,
 215                                                                    eVoteNo,
 216                                                                    eVoteNoOpinion,
 217                                                                    0);
 218                     return false;
 219                 }
 220                 else
 221                 {
 222                     if (log)
 223                     {
 224                         log->PutCString("The stack id we are stepping in changed, but our parent frame did not when stepping from code with no symbols.  "
 225                         "We are probably just confused about where we are, stopping.");
 226                     }
 227                     SetPlanComplete();
 228                     return true;
 229                 }
 230             }
 231             else
 232             {
 233                 if (log)
 234                     log->Printf("Could not find previous frame, stopping.");
 235                 SetPlanComplete();
 236                 return true;
 237             }
 238         }
 239     }
 240     else
 241     {
 242         lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC(0);
 243         if (pc_addr != m_instruction_addr)
 244         {
 245             if (--m_iteration_count <= 0)
 246             {
 247                 SetPlanComplete();
 248                 return true;
 249             }
 250             else
 251             {
 252                 // We are still stepping, reset the start pc, and in case we've stepped in or out,
 253                 // reset the current stack id.
 254                 SetUpState();
 255                 return false;
 256             }
 257         }
 258         else
 259             return false;
 260     }
 261 }
 262
 263 bool
 264 ThreadPlanStepInstruction::StopOthers ()
 265 {
 266     return m_stop_other_threads;
 267 }
 268
 269 StateType
 270 ThreadPlanStepInstruction::GetPlanRunState ()
 271 {
 272     return eStateStepping;
 273 }
 274
 275 bool
 276 ThreadPlanStepInstruction::WillStop ()
 277 {
 278     return true;
 279 }
 280
 281 bool
 282 ThreadPlanStepInstruction::MischiefManaged ()
 283 {
 284     if (IsPlanComplete())
 285     {
 286         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 287         if (log)
 288             log->Printf("Completed single instruction step plan.");
 289         ThreadPlan::MischiefManaged ();
 290         return true;
 291     }
 292     else
 293     {
 294         return false;
 295     }
 296 }