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