diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Target/ThreadPlanStepInstruction.cpp')
| -rw-r--r-- | contrib/llvm/tools/lldb/source/Target/ThreadPlanStepInstruction.cpp | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/contrib/llvm/tools/lldb/source/Target/ThreadPlanStepInstruction.cpp b/contrib/llvm/tools/lldb/source/Target/ThreadPlanStepInstruction.cpp new file mode 100644 index 0000000..9d7d521 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Target/ThreadPlanStepInstruction.cpp @@ -0,0 +1,295 @@ +//===-- ThreadPlanStepInstruction.cpp ---------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/Target/ThreadPlanStepInstruction.h" +#include "lldb/Core/Log.h" +#include "lldb/Core/Stream.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/StopInfo.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; + +//---------------------------------------------------------------------- +// ThreadPlanStepInstruction: Step over the current instruction +//---------------------------------------------------------------------- + +ThreadPlanStepInstruction::ThreadPlanStepInstruction +( + Thread &thread, + bool step_over, + bool stop_other_threads, + Vote stop_vote, + Vote run_vote +) : + ThreadPlan (ThreadPlan::eKindStepInstruction, "Step over single instruction", thread, stop_vote, run_vote), + m_instruction_addr (0), + m_stop_other_threads (stop_other_threads), + m_step_over (step_over) +{ + m_takes_iteration_count = true; + SetUpState(); +} + +ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default; + +void +ThreadPlanStepInstruction::SetUpState() +{ + m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0); + StackFrameSP start_frame_sp(m_thread.GetStackFrameAtIndex(0)); + m_stack_id = start_frame_sp->GetStackID(); + + m_start_has_symbol = start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr; + + StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1); + if (parent_frame_sp) + m_parent_frame_id = parent_frame_sp->GetStackID(); +} + +void +ThreadPlanStepInstruction::GetDescription (Stream *s, lldb::DescriptionLevel level) +{ + if (level == lldb::eDescriptionLevelBrief) + { + if (m_step_over) + s->Printf ("instruction step over"); + else + s->Printf ("instruction step into"); + } + else + { + s->Printf ("Stepping one instruction past "); + s->Address(m_instruction_addr, sizeof (addr_t)); + if (!m_start_has_symbol) + s->Printf(" which has no symbol"); + + if (m_step_over) + s->Printf(" stepping over calls"); + else + s->Printf(" stepping into calls"); + } +} + +bool +ThreadPlanStepInstruction::ValidatePlan (Stream *error) +{ + // Since we read the instruction we're stepping over from the thread, + // this plan will always work. + return true; +} + +bool +ThreadPlanStepInstruction::DoPlanExplainsStop (Event *event_ptr) +{ + StopInfoSP stop_info_sp = GetPrivateStopInfo (); + if (stop_info_sp) + { + StopReason reason = stop_info_sp->GetStopReason(); + return (reason == eStopReasonTrace || reason == eStopReasonNone); + } + return false; +} + +bool +ThreadPlanStepInstruction::IsPlanStale () +{ + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); + StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID(); + if (cur_frame_id == m_stack_id) + { + return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr); + } + else if (cur_frame_id < m_stack_id) + { + // If the current frame is younger than the start frame and we are stepping over, then we need to continue, + // but if we are doing just one step, we're done. + return !m_step_over; + } + else + { + if (log) + { + log->Printf ("ThreadPlanStepInstruction::IsPlanStale - Current frame is older than start frame, plan is stale."); + } + return true; + } +} + +bool +ThreadPlanStepInstruction::ShouldStop (Event *event_ptr) +{ + if (m_step_over) + { + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); + + StackFrameSP cur_frame_sp = m_thread.GetStackFrameAtIndex(0); + if (!cur_frame_sp) + { + if (log) + log->Printf ("ThreadPlanStepInstruction couldn't get the 0th frame, stopping."); + SetPlanComplete(); + return true; + } + + StackID cur_frame_zero_id = cur_frame_sp->GetStackID(); + + if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) + { + if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) + { + if (--m_iteration_count <= 0) + { + SetPlanComplete(); + return true; + } + else + { + // We are still stepping, reset the start pc, and in case we've stepped out, + // reset the current stack id. + SetUpState(); + return false; + } + } + else + return false; + } + else + { + // We've stepped in, step back out again: + StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get(); + if (return_frame) + { + if (return_frame->GetStackID() != m_parent_frame_id || m_start_has_symbol) + { + // next-instruction shouldn't step out of inlined functions. But we may have stepped into a + // real function that starts with an inlined function, and we do want to step out of that... + + if (cur_frame_sp->IsInlined()) + { + StackFrameSP parent_frame_sp = m_thread.GetFrameWithStackID(m_stack_id); + + if(parent_frame_sp && parent_frame_sp->GetConcreteFrameIndex() == cur_frame_sp->GetConcreteFrameIndex()) + { + SetPlanComplete(); + if (log) + { + log->Printf("Frame we stepped into is inlined into the frame we were stepping from, stopping."); + } + return true; + } + } + + if (log) + { + StreamString s; + s.PutCString ("Stepped in to: "); + addr_t stop_addr = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC(); + s.Address (stop_addr, m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize()); + s.PutCString (" stepping out to: "); + addr_t return_addr = return_frame->GetRegisterContext()->GetPC(); + s.Address (return_addr, m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize()); + log->Printf("%s.", s.GetData()); + } + + // StepInstruction should probably have the tri-state RunMode, but for now it is safer to + // run others. + const bool stop_others = false; + m_thread.QueueThreadPlanForStepOutNoShouldStop(false, + nullptr, + true, + stop_others, + eVoteNo, + eVoteNoOpinion, + 0); + return false; + } + else + { + if (log) + { + log->PutCString("The stack id we are stepping in changed, but our parent frame did not when stepping from code with no symbols. " + "We are probably just confused about where we are, stopping."); + } + SetPlanComplete(); + return true; + } + } + else + { + if (log) + log->Printf("Could not find previous frame, stopping."); + SetPlanComplete(); + return true; + } + } + } + else + { + if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) + { + if (--m_iteration_count <= 0) + { + SetPlanComplete(); + return true; + } + else + { + // We are still stepping, reset the start pc, and in case we've stepped in or out, + // reset the current stack id. + SetUpState(); + return false; + } + } + else + return false; + } +} + +bool +ThreadPlanStepInstruction::StopOthers () +{ + return m_stop_other_threads; +} + +StateType +ThreadPlanStepInstruction::GetPlanRunState () +{ + return eStateStepping; +} + +bool +ThreadPlanStepInstruction::WillStop () +{ + return true; +} + +bool +ThreadPlanStepInstruction::MischiefManaged () +{ + if (IsPlanComplete()) + { + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); + if (log) + log->Printf("Completed single instruction step plan."); + ThreadPlan::MischiefManaged (); + return true; + } + else + { + return false; + } +} |
