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