1 //===-- ThreadPlanStepRange.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Target/ThreadPlanStepRange.h" 10 #include "lldb/Breakpoint/BreakpointLocation.h" 11 #include "lldb/Breakpoint/BreakpointSite.h" 12 #include "lldb/Core/Disassembler.h" 13 #include "lldb/Symbol/Function.h" 14 #include "lldb/Symbol/Symbol.h" 15 #include "lldb/Target/ExecutionContext.h" 16 #include "lldb/Target/Process.h" 17 #include "lldb/Target/RegisterContext.h" 18 #include "lldb/Target/StopInfo.h" 19 #include "lldb/Target/Target.h" 20 #include "lldb/Target/Thread.h" 21 #include "lldb/Target/ThreadPlanRunToAddress.h" 22 #include "lldb/Utility/LLDBLog.h" 23 #include "lldb/Utility/Log.h" 24 #include "lldb/Utility/Stream.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 29 // ThreadPlanStepRange: Step through a stack range, either stepping over or 30 // into based on the value of \a type. 31 32 ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name, 33 Thread &thread, 34 const AddressRange &range, 35 const SymbolContext &addr_context, 36 lldb::RunMode stop_others, 37 bool given_ranges_only) 38 : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion), 39 m_addr_context(addr_context), m_address_ranges(), 40 m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(), 41 m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false), 42 m_given_ranges_only(given_ranges_only) { 43 m_use_fast_step = GetTarget().GetUseFastStepping(); 44 AddRange(range); 45 m_stack_id = thread.GetStackFrameAtIndex(0)->GetStackID(); 46 StackFrameSP parent_stack = thread.GetStackFrameAtIndex(1); 47 if (parent_stack) 48 m_parent_stack_id = parent_stack->GetStackID(); 49 } 50 51 ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); } 52 53 void ThreadPlanStepRange::DidPush() { 54 // See if we can find a "next range" breakpoint: 55 SetNextBranchBreakpoint(); 56 } 57 58 bool ThreadPlanStepRange::ValidatePlan(Stream *error) { 59 if (m_could_not_resolve_hw_bp) { 60 if (error) 61 error->PutCString( 62 "Could not create hardware breakpoint for thread plan."); 63 return false; 64 } 65 return true; 66 } 67 68 Vote ThreadPlanStepRange::ShouldReportStop(Event *event_ptr) { 69 Log *log = GetLog(LLDBLog::Step); 70 71 const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo; 72 LLDB_LOGF(log, "ThreadPlanStepRange::ShouldReportStop() returning vote %i\n", 73 vote); 74 return vote; 75 } 76 77 void ThreadPlanStepRange::AddRange(const AddressRange &new_range) { 78 // For now I'm just adding the ranges. At some point we may want to condense 79 // the ranges if they overlap, though I don't think it is likely to be very 80 // important. 81 m_address_ranges.push_back(new_range); 82 83 // Fill the slot for this address range with an empty DisassemblerSP in the 84 // instruction ranges. I want the indices to match, but I don't want to do 85 // the work to disassemble this range if I don't step into it. 86 m_instruction_ranges.push_back(DisassemblerSP()); 87 } 88 89 void ThreadPlanStepRange::DumpRanges(Stream *s) { 90 size_t num_ranges = m_address_ranges.size(); 91 if (num_ranges == 1) { 92 m_address_ranges[0].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress); 93 } else { 94 for (size_t i = 0; i < num_ranges; i++) { 95 s->Printf(" %" PRIu64 ": ", uint64_t(i)); 96 m_address_ranges[i].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress); 97 } 98 } 99 } 100 101 bool ThreadPlanStepRange::InRange() { 102 Log *log = GetLog(LLDBLog::Step); 103 bool ret_value = false; 104 Thread &thread = GetThread(); 105 lldb::addr_t pc_load_addr = thread.GetRegisterContext()->GetPC(); 106 107 size_t num_ranges = m_address_ranges.size(); 108 for (size_t i = 0; i < num_ranges; i++) { 109 ret_value = 110 m_address_ranges[i].ContainsLoadAddress(pc_load_addr, &GetTarget()); 111 if (ret_value) 112 break; 113 } 114 115 if (!ret_value && !m_given_ranges_only) { 116 // See if we've just stepped to another part of the same line number... 117 StackFrame *frame = thread.GetStackFrameAtIndex(0).get(); 118 119 SymbolContext new_context( 120 frame->GetSymbolContext(eSymbolContextEverything)); 121 if (m_addr_context.line_entry.IsValid() && 122 new_context.line_entry.IsValid()) { 123 if (m_addr_context.line_entry.original_file == 124 new_context.line_entry.original_file) { 125 if (m_addr_context.line_entry.line == new_context.line_entry.line) { 126 m_addr_context = new_context; 127 const bool include_inlined_functions = 128 GetKind() == eKindStepOverRange; 129 AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange( 130 include_inlined_functions)); 131 ret_value = true; 132 if (log) { 133 StreamString s; 134 m_addr_context.line_entry.Dump(&s, &GetTarget(), true, 135 Address::DumpStyleLoadAddress, 136 Address::DumpStyleLoadAddress, true); 137 138 LLDB_LOGF( 139 log, 140 "Step range plan stepped to another range of same line: %s", 141 s.GetData()); 142 } 143 } else if (new_context.line_entry.line == 0) { 144 new_context.line_entry.line = m_addr_context.line_entry.line; 145 m_addr_context = new_context; 146 const bool include_inlined_functions = 147 GetKind() == eKindStepOverRange; 148 AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange( 149 include_inlined_functions)); 150 ret_value = true; 151 if (log) { 152 StreamString s; 153 m_addr_context.line_entry.Dump(&s, &GetTarget(), true, 154 Address::DumpStyleLoadAddress, 155 Address::DumpStyleLoadAddress, true); 156 157 LLDB_LOGF(log, 158 "Step range plan stepped to a range at linenumber 0 " 159 "stepping through that range: %s", 160 s.GetData()); 161 } 162 } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress( 163 &GetTarget()) != pc_load_addr) { 164 // Another thing that sometimes happens here is that we step out of 165 // one line into the MIDDLE of another line. So far I mostly see 166 // this due to bugs in the debug information. But we probably don't 167 // want to be in the middle of a line range, so in that case reset 168 // the stepping range to the line we've stepped into the middle of 169 // and continue. 170 m_addr_context = new_context; 171 m_address_ranges.clear(); 172 AddRange(m_addr_context.line_entry.range); 173 ret_value = true; 174 if (log) { 175 StreamString s; 176 m_addr_context.line_entry.Dump(&s, &GetTarget(), true, 177 Address::DumpStyleLoadAddress, 178 Address::DumpStyleLoadAddress, true); 179 180 LLDB_LOGF(log, 181 "Step range plan stepped to the middle of new " 182 "line(%d): %s, continuing to clear this line.", 183 new_context.line_entry.line, s.GetData()); 184 } 185 } 186 } 187 } 188 } 189 190 if (!ret_value && log) 191 LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr); 192 193 return ret_value; 194 } 195 196 bool ThreadPlanStepRange::InSymbol() { 197 lldb::addr_t cur_pc = GetThread().GetRegisterContext()->GetPC(); 198 if (m_addr_context.function != nullptr) { 199 return m_addr_context.function->GetAddressRange().ContainsLoadAddress( 200 cur_pc, &GetTarget()); 201 } else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) { 202 AddressRange range(m_addr_context.symbol->GetAddressRef(), 203 m_addr_context.symbol->GetByteSize()); 204 return range.ContainsLoadAddress(cur_pc, &GetTarget()); 205 } 206 return false; 207 } 208 209 // FIXME: This should also handle inlining if we aren't going to do inlining in 210 // the 211 // main stack. 212 // 213 // Ideally we should remember the whole stack frame list, and then compare that 214 // to the current list. 215 216 lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() { 217 FrameComparison frame_order; 218 Thread &thread = GetThread(); 219 StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID(); 220 221 if (cur_frame_id == m_stack_id) { 222 frame_order = eFrameCompareEqual; 223 } else if (cur_frame_id < m_stack_id) { 224 frame_order = eFrameCompareYounger; 225 } else { 226 StackFrameSP cur_parent_frame = thread.GetStackFrameAtIndex(1); 227 StackID cur_parent_id; 228 if (cur_parent_frame) 229 cur_parent_id = cur_parent_frame->GetStackID(); 230 if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() && 231 m_parent_stack_id == cur_parent_id) 232 frame_order = eFrameCompareSameParent; 233 else 234 frame_order = eFrameCompareOlder; 235 } 236 return frame_order; 237 } 238 239 bool ThreadPlanStepRange::StopOthers() { 240 switch (m_stop_others) { 241 case lldb::eOnlyThisThread: 242 return true; 243 case lldb::eOnlyDuringStepping: 244 // If there is a call in the range of the next branch breakpoint, 245 // then we should always run all threads, since a call can execute 246 // arbitrary code which might for instance take a lock that's held 247 // by another thread. 248 return !m_found_calls; 249 case lldb::eAllThreads: 250 return false; 251 } 252 llvm_unreachable("Unhandled run mode!"); 253 } 254 255 InstructionList *ThreadPlanStepRange::GetInstructionsForAddress( 256 lldb::addr_t addr, size_t &range_index, size_t &insn_offset) { 257 size_t num_ranges = m_address_ranges.size(); 258 for (size_t i = 0; i < num_ranges; i++) { 259 if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) { 260 // Some joker added a zero size range to the stepping range... 261 if (m_address_ranges[i].GetByteSize() == 0) 262 return nullptr; 263 264 if (!m_instruction_ranges[i]) { 265 // Disassemble the address range given: 266 const char *plugin_name = nullptr; 267 const char *flavor = nullptr; 268 m_instruction_ranges[i] = Disassembler::DisassembleRange( 269 GetTarget().GetArchitecture(), plugin_name, flavor, GetTarget(), 270 m_address_ranges[i]); 271 } 272 if (!m_instruction_ranges[i]) 273 return nullptr; 274 else { 275 // Find where we are in the instruction list as well. If we aren't at 276 // an instruction, return nullptr. In this case, we're probably lost, 277 // and shouldn't try to do anything fancy. 278 279 insn_offset = 280 m_instruction_ranges[i] 281 ->GetInstructionList() 282 .GetIndexOfInstructionAtLoadAddress(addr, GetTarget()); 283 if (insn_offset == UINT32_MAX) 284 return nullptr; 285 else { 286 range_index = i; 287 return &m_instruction_ranges[i]->GetInstructionList(); 288 } 289 } 290 } 291 } 292 return nullptr; 293 } 294 295 void ThreadPlanStepRange::ClearNextBranchBreakpoint() { 296 if (m_next_branch_bp_sp) { 297 Log *log = GetLog(LLDBLog::Step); 298 LLDB_LOGF(log, "Removing next branch breakpoint: %d.", 299 m_next_branch_bp_sp->GetID()); 300 GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID()); 301 m_next_branch_bp_sp.reset(); 302 m_could_not_resolve_hw_bp = false; 303 m_found_calls = false; 304 } 305 } 306 307 bool ThreadPlanStepRange::SetNextBranchBreakpoint() { 308 if (m_next_branch_bp_sp) 309 return true; 310 311 Log *log = GetLog(LLDBLog::Step); 312 // Stepping through ranges using breakpoints doesn't work yet, but with this 313 // off we fall back to instruction single stepping. 314 if (!m_use_fast_step) 315 return false; 316 317 // clear the m_found_calls, we'll rediscover it for this range. 318 m_found_calls = false; 319 320 lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC(); 321 // Find the current address in our address ranges, and fetch the disassembly 322 // if we haven't already: 323 size_t pc_index; 324 size_t range_index; 325 InstructionList *instructions = 326 GetInstructionsForAddress(cur_addr, range_index, pc_index); 327 if (instructions == nullptr) 328 return false; 329 else { 330 const bool ignore_calls = GetKind() == eKindStepOverRange; 331 uint32_t branch_index = instructions->GetIndexOfNextBranchInstruction( 332 pc_index, ignore_calls, &m_found_calls); 333 Address run_to_address; 334 335 // If we didn't find a branch, run to the end of the range. 336 if (branch_index == UINT32_MAX) { 337 uint32_t last_index = instructions->GetSize() - 1; 338 if (last_index - pc_index > 1) { 339 InstructionSP last_inst = 340 instructions->GetInstructionAtIndex(last_index); 341 size_t last_inst_size = last_inst->GetOpcode().GetByteSize(); 342 run_to_address = last_inst->GetAddress(); 343 run_to_address.Slide(last_inst_size); 344 } 345 } else if (branch_index - pc_index > 1) { 346 run_to_address = 347 instructions->GetInstructionAtIndex(branch_index)->GetAddress(); 348 } 349 350 if (run_to_address.IsValid()) { 351 const bool is_internal = true; 352 m_next_branch_bp_sp = 353 GetTarget().CreateBreakpoint(run_to_address, is_internal, false); 354 if (m_next_branch_bp_sp) { 355 356 if (m_next_branch_bp_sp->IsHardware() && 357 !m_next_branch_bp_sp->HasResolvedLocations()) 358 m_could_not_resolve_hw_bp = true; 359 360 if (log) { 361 lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID; 362 BreakpointLocationSP bp_loc = 363 m_next_branch_bp_sp->GetLocationAtIndex(0); 364 if (bp_loc) { 365 BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite(); 366 if (bp_site) { 367 bp_site_id = bp_site->GetID(); 368 } 369 } 370 LLDB_LOGF(log, 371 "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting " 372 "breakpoint %d (site %d) to run to address 0x%" PRIx64, 373 m_next_branch_bp_sp->GetID(), bp_site_id, 374 run_to_address.GetLoadAddress(&m_process.GetTarget())); 375 } 376 377 m_next_branch_bp_sp->SetThreadID(m_tid); 378 m_next_branch_bp_sp->SetBreakpointKind("next-branch-location"); 379 380 return true; 381 } else 382 return false; 383 } 384 } 385 return false; 386 } 387 388 bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop( 389 lldb::StopInfoSP stop_info_sp) { 390 Log *log = GetLog(LLDBLog::Step); 391 if (!m_next_branch_bp_sp) 392 return false; 393 394 break_id_t bp_site_id = stop_info_sp->GetValue(); 395 BreakpointSiteSP bp_site_sp = 396 m_process.GetBreakpointSiteList().FindByID(bp_site_id); 397 if (!bp_site_sp) 398 return false; 399 else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID())) 400 return false; 401 else { 402 // If we've hit the next branch breakpoint, then clear it. 403 size_t num_owners = bp_site_sp->GetNumberOfOwners(); 404 bool explains_stop = true; 405 // If all the owners are internal, then we are probably just stepping over 406 // this range from multiple threads, or multiple frames, so we want to 407 // continue. If one is not internal, then we should not explain the stop, 408 // and let the user breakpoint handle the stop. 409 for (size_t i = 0; i < num_owners; i++) { 410 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) { 411 explains_stop = false; 412 break; 413 } 414 } 415 LLDB_LOGF(log, 416 "ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit " 417 "next range breakpoint which has %" PRIu64 418 " owners - explains stop: %u.", 419 (uint64_t)num_owners, explains_stop); 420 ClearNextBranchBreakpoint(); 421 return explains_stop; 422 } 423 } 424 425 bool ThreadPlanStepRange::WillStop() { return true; } 426 427 StateType ThreadPlanStepRange::GetPlanRunState() { 428 if (m_next_branch_bp_sp) 429 return eStateRunning; 430 else 431 return eStateStepping; 432 } 433 434 bool ThreadPlanStepRange::MischiefManaged() { 435 // If we have pushed some plans between ShouldStop & MischiefManaged, then 436 // we're not done... 437 // I do this check first because we might have stepped somewhere that will 438 // fool InRange into 439 // thinking it needs to step past the end of that line. This happens, for 440 // instance, when stepping over inlined code that is in the middle of the 441 // current line. 442 443 if (!m_no_more_plans) 444 return false; 445 446 bool done = true; 447 if (!IsPlanComplete()) { 448 if (InRange()) { 449 done = false; 450 } else { 451 FrameComparison frame_order = CompareCurrentFrameToStartFrame(); 452 done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true; 453 } 454 } 455 456 if (done) { 457 Log *log = GetLog(LLDBLog::Step); 458 LLDB_LOGF(log, "Completed step through range plan."); 459 ClearNextBranchBreakpoint(); 460 ThreadPlan::MischiefManaged(); 461 return true; 462 } else { 463 return false; 464 } 465 } 466 467 bool ThreadPlanStepRange::IsPlanStale() { 468 Log *log = GetLog(LLDBLog::Step); 469 FrameComparison frame_order = CompareCurrentFrameToStartFrame(); 470 471 if (frame_order == eFrameCompareOlder) { 472 if (log) { 473 LLDB_LOGF(log, "ThreadPlanStepRange::IsPlanStale returning true, we've " 474 "stepped out."); 475 } 476 return true; 477 } else if (frame_order == eFrameCompareEqual && InSymbol()) { 478 // If we are not in a place we should step through, we've gotten stale. One 479 // tricky bit here is that some stubs don't push a frame, so we should. 480 // check that we are in the same symbol. 481 if (!InRange()) { 482 // Set plan Complete when we reach next instruction just after the range 483 lldb::addr_t addr = GetThread().GetRegisterContext()->GetPC() - 1; 484 size_t num_ranges = m_address_ranges.size(); 485 for (size_t i = 0; i < num_ranges; i++) { 486 bool in_range = 487 m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget()); 488 if (in_range) { 489 SetPlanComplete(); 490 } 491 } 492 return true; 493 } 494 } 495 return false; 496 } 497