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