1 //===-- ThreadPlanStepInRange.cpp -------------------------------*- C++ -*-===// 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/ThreadPlanStepInRange.h" 10 #include "lldb/Core/Architecture.h" 11 #include "lldb/Core/Module.h" 12 #include "lldb/Symbol/Function.h" 13 #include "lldb/Symbol/Symbol.h" 14 #include "lldb/Target/Process.h" 15 #include "lldb/Target/RegisterContext.h" 16 #include "lldb/Target/SectionLoadList.h" 17 #include "lldb/Target/Target.h" 18 #include "lldb/Target/Thread.h" 19 #include "lldb/Target/ThreadPlanStepOut.h" 20 #include "lldb/Target/ThreadPlanStepThrough.h" 21 #include "lldb/Utility/Log.h" 22 #include "lldb/Utility/RegularExpression.h" 23 #include "lldb/Utility/Stream.h" 24 25 using namespace lldb; 26 using namespace lldb_private; 27 28 uint32_t ThreadPlanStepInRange::s_default_flag_values = 29 ThreadPlanShouldStopHere::eStepInAvoidNoDebug; 30 31 // ThreadPlanStepInRange: Step through a stack range, either stepping over or 32 // into based on the value of \a type. 33 34 ThreadPlanStepInRange::ThreadPlanStepInRange( 35 Thread &thread, const AddressRange &range, 36 const SymbolContext &addr_context, lldb::RunMode stop_others, 37 LazyBool step_in_avoids_code_without_debug_info, 38 LazyBool step_out_avoids_code_without_debug_info) 39 : ThreadPlanStepRange(ThreadPlan::eKindStepInRange, 40 "Step Range stepping in", thread, range, addr_context, 41 stop_others), 42 ThreadPlanShouldStopHere(this), m_step_past_prologue(true), 43 m_virtual_step(false) { 44 SetCallbacks(); 45 SetFlagsToDefault(); 46 SetupAvoidNoDebug(step_in_avoids_code_without_debug_info, 47 step_out_avoids_code_without_debug_info); 48 } 49 50 ThreadPlanStepInRange::ThreadPlanStepInRange( 51 Thread &thread, const AddressRange &range, 52 const SymbolContext &addr_context, const char *step_into_target, 53 lldb::RunMode stop_others, LazyBool step_in_avoids_code_without_debug_info, 54 LazyBool step_out_avoids_code_without_debug_info) 55 : ThreadPlanStepRange(ThreadPlan::eKindStepInRange, 56 "Step Range stepping in", thread, range, addr_context, 57 stop_others), 58 ThreadPlanShouldStopHere(this), m_step_past_prologue(true), 59 m_virtual_step(false), m_step_into_target(step_into_target) { 60 SetCallbacks(); 61 SetFlagsToDefault(); 62 SetupAvoidNoDebug(step_in_avoids_code_without_debug_info, 63 step_out_avoids_code_without_debug_info); 64 } 65 66 ThreadPlanStepInRange::~ThreadPlanStepInRange() = default; 67 68 void ThreadPlanStepInRange::SetupAvoidNoDebug( 69 LazyBool step_in_avoids_code_without_debug_info, 70 LazyBool step_out_avoids_code_without_debug_info) { 71 bool avoid_nodebug = true; 72 73 switch (step_in_avoids_code_without_debug_info) { 74 case eLazyBoolYes: 75 avoid_nodebug = true; 76 break; 77 case eLazyBoolNo: 78 avoid_nodebug = false; 79 break; 80 case eLazyBoolCalculate: 81 avoid_nodebug = m_thread.GetStepInAvoidsNoDebug(); 82 break; 83 } 84 if (avoid_nodebug) 85 GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug); 86 else 87 GetFlags().Clear(ThreadPlanShouldStopHere::eStepInAvoidNoDebug); 88 89 switch (step_out_avoids_code_without_debug_info) { 90 case eLazyBoolYes: 91 avoid_nodebug = true; 92 break; 93 case eLazyBoolNo: 94 avoid_nodebug = false; 95 break; 96 case eLazyBoolCalculate: 97 avoid_nodebug = m_thread.GetStepOutAvoidsNoDebug(); 98 break; 99 } 100 if (avoid_nodebug) 101 GetFlags().Set(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug); 102 else 103 GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug); 104 } 105 106 void ThreadPlanStepInRange::GetDescription(Stream *s, 107 lldb::DescriptionLevel level) { 108 109 auto PrintFailureIfAny = [&]() { 110 if (m_status.Success()) 111 return; 112 s->Printf(" failed (%s)", m_status.AsCString()); 113 }; 114 115 if (level == lldb::eDescriptionLevelBrief) { 116 s->Printf("step in"); 117 PrintFailureIfAny(); 118 return; 119 } 120 121 s->Printf("Stepping in"); 122 bool printed_line_info = false; 123 if (m_addr_context.line_entry.IsValid()) { 124 s->Printf(" through line "); 125 m_addr_context.line_entry.DumpStopContext(s, false); 126 printed_line_info = true; 127 } 128 129 const char *step_into_target = m_step_into_target.AsCString(); 130 if (step_into_target && step_into_target[0] != '\0') 131 s->Printf(" targeting %s", m_step_into_target.AsCString()); 132 133 if (!printed_line_info || level == eDescriptionLevelVerbose) { 134 s->Printf(" using ranges:"); 135 DumpRanges(s); 136 } 137 138 PrintFailureIfAny(); 139 140 s->PutChar('.'); 141 } 142 143 bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) { 144 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 145 146 if (log) { 147 StreamString s; 148 s.Address( 149 m_thread.GetRegisterContext()->GetPC(), 150 m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize()); 151 log->Printf("ThreadPlanStepInRange reached %s.", s.GetData()); 152 } 153 154 if (IsPlanComplete()) 155 return true; 156 157 m_no_more_plans = false; 158 if (m_sub_plan_sp && m_sub_plan_sp->IsPlanComplete()) { 159 if (!m_sub_plan_sp->PlanSucceeded()) { 160 SetPlanComplete(); 161 m_no_more_plans = true; 162 return true; 163 } else 164 m_sub_plan_sp.reset(); 165 } 166 167 if (m_virtual_step) { 168 // If we've just completed a virtual step, all we need to do is check for a 169 // ShouldStopHere plan, and otherwise we're done. 170 // FIXME - This can be both a step in and a step out. Probably should 171 // record which in the m_virtual_step. 172 m_sub_plan_sp = 173 CheckShouldStopHereAndQueueStepOut(eFrameCompareYounger, m_status); 174 } else { 175 // Stepping through should be done running other threads in general, since 176 // we're setting a breakpoint and continuing. So only stop others if we 177 // are explicitly told to do so. 178 179 bool stop_others = (m_stop_others == lldb::eOnlyThisThread); 180 181 FrameComparison frame_order = CompareCurrentFrameToStartFrame(); 182 183 if (frame_order == eFrameCompareOlder || 184 frame_order == eFrameCompareSameParent) { 185 // If we're in an older frame then we should stop. 186 // 187 // A caveat to this is if we think the frame is older but we're actually 188 // in a trampoline. 189 // I'm going to make the assumption that you wouldn't RETURN to a 190 // trampoline. So if we are in a trampoline we think the frame is older 191 // because the trampoline confused the backtracer. 192 m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough( 193 m_stack_id, false, stop_others, m_status); 194 if (!m_sub_plan_sp) { 195 // Otherwise check the ShouldStopHere for step out: 196 m_sub_plan_sp = 197 CheckShouldStopHereAndQueueStepOut(frame_order, m_status); 198 if (log) { 199 if (m_sub_plan_sp) 200 log->Printf("ShouldStopHere found plan to step out of this frame."); 201 else 202 log->Printf("ShouldStopHere no plan to step out of this frame."); 203 } 204 } else if (log) { 205 log->Printf( 206 "Thought I stepped out, but in fact arrived at a trampoline."); 207 } 208 } else if (frame_order == eFrameCompareEqual && InSymbol()) { 209 // If we are not in a place we should step through, we're done. One 210 // tricky bit here is that some stubs don't push a frame, so we have to 211 // check both the case of a frame that is younger, or the same as this 212 // frame. However, if the frame is the same, and we are still in the 213 // symbol we started in, the we don't need to do this. This first check 214 // isn't strictly necessary, but it is more efficient. 215 216 // If we're still in the range, keep going, either by running to the next 217 // branch breakpoint, or by stepping. 218 if (InRange()) { 219 SetNextBranchBreakpoint(); 220 return false; 221 } 222 223 SetPlanComplete(); 224 m_no_more_plans = true; 225 return true; 226 } 227 228 // If we get to this point, we're not going to use a previously set "next 229 // branch" breakpoint, so delete it: 230 ClearNextBranchBreakpoint(); 231 232 // We may have set the plan up above in the FrameIsOlder section: 233 234 if (!m_sub_plan_sp) 235 m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough( 236 m_stack_id, false, stop_others, m_status); 237 238 if (log) { 239 if (m_sub_plan_sp) 240 log->Printf("Found a step through plan: %s", m_sub_plan_sp->GetName()); 241 else 242 log->Printf("No step through plan found."); 243 } 244 245 // If not, give the "should_stop" callback a chance to push a plan to get 246 // us out of here. But only do that if we actually have stepped in. 247 if (!m_sub_plan_sp && frame_order == eFrameCompareYounger) 248 m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order, m_status); 249 250 // If we've stepped in and we are going to stop here, check to see if we 251 // were asked to run past the prologue, and if so do that. 252 253 if (!m_sub_plan_sp && frame_order == eFrameCompareYounger && 254 m_step_past_prologue) { 255 lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0); 256 if (curr_frame) { 257 size_t bytes_to_skip = 0; 258 lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC(); 259 Address func_start_address; 260 261 SymbolContext sc = curr_frame->GetSymbolContext(eSymbolContextFunction | 262 eSymbolContextSymbol); 263 264 if (sc.function) { 265 func_start_address = sc.function->GetAddressRange().GetBaseAddress(); 266 if (curr_addr == 267 func_start_address.GetLoadAddress( 268 m_thread.CalculateTarget().get())) 269 bytes_to_skip = sc.function->GetPrologueByteSize(); 270 } else if (sc.symbol) { 271 func_start_address = sc.symbol->GetAddress(); 272 if (curr_addr == 273 func_start_address.GetLoadAddress( 274 m_thread.CalculateTarget().get())) 275 bytes_to_skip = sc.symbol->GetPrologueByteSize(); 276 } 277 278 if (bytes_to_skip == 0 && sc.symbol) { 279 TargetSP target = m_thread.CalculateTarget(); 280 const Architecture *arch = target->GetArchitecturePlugin(); 281 if (arch) { 282 Address curr_sec_addr; 283 target->GetSectionLoadList().ResolveLoadAddress(curr_addr, 284 curr_sec_addr); 285 bytes_to_skip = arch->GetBytesToSkip(*sc.symbol, curr_sec_addr); 286 } 287 } 288 289 if (bytes_to_skip != 0) { 290 func_start_address.Slide(bytes_to_skip); 291 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP); 292 if (log) 293 log->Printf("Pushing past prologue "); 294 295 m_sub_plan_sp = m_thread.QueueThreadPlanForRunToAddress( 296 false, func_start_address, true, m_status); 297 } 298 } 299 } 300 } 301 302 if (!m_sub_plan_sp) { 303 m_no_more_plans = true; 304 SetPlanComplete(); 305 return true; 306 } else { 307 m_no_more_plans = false; 308 m_sub_plan_sp->SetPrivate(true); 309 return false; 310 } 311 } 312 313 void ThreadPlanStepInRange::SetAvoidRegexp(const char *name) { 314 auto name_ref = llvm::StringRef::withNullAsEmpty(name); 315 if (!m_avoid_regexp_up) 316 m_avoid_regexp_up.reset(new RegularExpression(name_ref)); 317 318 m_avoid_regexp_up->Compile(name_ref); 319 } 320 321 void ThreadPlanStepInRange::SetDefaultFlagValue(uint32_t new_value) { 322 // TODO: Should we test this for sanity? 323 ThreadPlanStepInRange::s_default_flag_values = new_value; 324 } 325 326 bool ThreadPlanStepInRange::FrameMatchesAvoidCriteria() { 327 StackFrame *frame = GetThread().GetStackFrameAtIndex(0).get(); 328 329 // Check the library list first, as that's cheapest: 330 bool libraries_say_avoid = false; 331 332 FileSpecList libraries_to_avoid(GetThread().GetLibrariesToAvoid()); 333 size_t num_libraries = libraries_to_avoid.GetSize(); 334 if (num_libraries > 0) { 335 SymbolContext sc(frame->GetSymbolContext(eSymbolContextModule)); 336 FileSpec frame_library(sc.module_sp->GetFileSpec()); 337 338 if (frame_library) { 339 for (size_t i = 0; i < num_libraries; i++) { 340 const FileSpec &file_spec(libraries_to_avoid.GetFileSpecAtIndex(i)); 341 if (FileSpec::Equal(file_spec, frame_library, false)) { 342 libraries_say_avoid = true; 343 break; 344 } 345 } 346 } 347 } 348 if (libraries_say_avoid) 349 return true; 350 351 const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_up.get(); 352 if (avoid_regexp_to_use == nullptr) 353 avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp(); 354 355 if (avoid_regexp_to_use != nullptr) { 356 SymbolContext sc = frame->GetSymbolContext( 357 eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol); 358 if (sc.symbol != nullptr) { 359 const char *frame_function_name = 360 sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments) 361 .GetCString(); 362 if (frame_function_name) { 363 size_t num_matches = 0; 364 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 365 if (log) 366 num_matches = 1; 367 368 RegularExpression::Match regex_match(num_matches); 369 370 bool return_value = 371 avoid_regexp_to_use->Execute(frame_function_name, ®ex_match); 372 if (return_value) { 373 if (log) { 374 std::string match; 375 regex_match.GetMatchAtIndex(frame_function_name, 0, match); 376 log->Printf("Stepping out of function \"%s\" because it matches " 377 "the avoid regexp \"%s\" - match substring: \"%s\".", 378 frame_function_name, 379 avoid_regexp_to_use->GetText().str().c_str(), 380 match.c_str()); 381 } 382 } 383 return return_value; 384 } 385 } 386 } 387 return false; 388 } 389 390 bool ThreadPlanStepInRange::DefaultShouldStopHereCallback( 391 ThreadPlan *current_plan, Flags &flags, FrameComparison operation, 392 Status &status, void *baton) { 393 bool should_stop_here = true; 394 StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get(); 395 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 396 397 // First see if the ThreadPlanShouldStopHere default implementation thinks we 398 // should get out of here: 399 should_stop_here = ThreadPlanShouldStopHere::DefaultShouldStopHereCallback( 400 current_plan, flags, operation, status, baton); 401 if (!should_stop_here) 402 return should_stop_here; 403 404 if (should_stop_here && current_plan->GetKind() == eKindStepInRange && 405 operation == eFrameCompareYounger) { 406 ThreadPlanStepInRange *step_in_range_plan = 407 static_cast<ThreadPlanStepInRange *>(current_plan); 408 if (step_in_range_plan->m_step_into_target) { 409 SymbolContext sc = frame->GetSymbolContext( 410 eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol); 411 if (sc.symbol != nullptr) { 412 // First try an exact match, since that's cheap with ConstStrings. 413 // Then do a strstr compare. 414 if (step_in_range_plan->m_step_into_target == sc.GetFunctionName()) { 415 should_stop_here = true; 416 } else { 417 const char *target_name = 418 step_in_range_plan->m_step_into_target.AsCString(); 419 const char *function_name = sc.GetFunctionName().AsCString(); 420 421 if (function_name == nullptr) 422 should_stop_here = false; 423 else if (strstr(function_name, target_name) == nullptr) 424 should_stop_here = false; 425 } 426 if (log && !should_stop_here) 427 log->Printf("Stepping out of frame %s which did not match step into " 428 "target %s.", 429 sc.GetFunctionName().AsCString(), 430 step_in_range_plan->m_step_into_target.AsCString()); 431 } 432 } 433 434 if (should_stop_here) { 435 ThreadPlanStepInRange *step_in_range_plan = 436 static_cast<ThreadPlanStepInRange *>(current_plan); 437 // Don't log the should_step_out here, it's easier to do it in 438 // FrameMatchesAvoidCriteria. 439 should_stop_here = !step_in_range_plan->FrameMatchesAvoidCriteria(); 440 } 441 } 442 443 return should_stop_here; 444 } 445 446 bool ThreadPlanStepInRange::DoPlanExplainsStop(Event *event_ptr) { 447 // We always explain a stop. Either we've just done a single step, in which 448 // case we'll do our ordinary processing, or we stopped for some reason that 449 // isn't handled by our sub-plans, in which case we want to just stop right 450 // away. In general, we don't want to mark the plan as complete for 451 // unexplained stops. For instance, if you step in to some code with no debug 452 // info, so you step out and in the course of that hit a breakpoint, then you 453 // want to stop & show the user the breakpoint, but not unship the step in 454 // plan, since you still may want to complete that plan when you continue. 455 // This is particularly true when doing "step in to target function." 456 // stepping. 457 // 458 // The only variation is that if we are doing "step by running to next 459 // branch" in which case if we hit our branch breakpoint we don't set the 460 // plan to complete. 461 462 bool return_value = false; 463 464 if (m_virtual_step) { 465 return_value = true; 466 } else { 467 StopInfoSP stop_info_sp = GetPrivateStopInfo(); 468 if (stop_info_sp) { 469 StopReason reason = stop_info_sp->GetStopReason(); 470 471 if (reason == eStopReasonBreakpoint) { 472 if (NextRangeBreakpointExplainsStop(stop_info_sp)) { 473 return_value = true; 474 } 475 } else if (IsUsuallyUnexplainedStopReason(reason)) { 476 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 477 if (log) 478 log->PutCString("ThreadPlanStepInRange got asked if it explains the " 479 "stop for some reason other than step."); 480 return_value = false; 481 } else { 482 return_value = true; 483 } 484 } else 485 return_value = true; 486 } 487 488 return return_value; 489 } 490 491 bool ThreadPlanStepInRange::DoWillResume(lldb::StateType resume_state, 492 bool current_plan) { 493 m_virtual_step = false; 494 if (resume_state == eStateStepping && current_plan) { 495 // See if we are about to step over a virtual inlined call. 496 bool step_without_resume = m_thread.DecrementCurrentInlinedDepth(); 497 if (step_without_resume) { 498 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 499 if (log) 500 log->Printf("ThreadPlanStepInRange::DoWillResume: returning false, " 501 "inline_depth: %d", 502 m_thread.GetCurrentInlinedDepth()); 503 SetStopInfo(StopInfo::CreateStopReasonToTrace(m_thread)); 504 505 // FIXME: Maybe it would be better to create a InlineStep stop reason, but 506 // then 507 // the whole rest of the world would have to handle that stop reason. 508 m_virtual_step = true; 509 } 510 return !step_without_resume; 511 } 512 return true; 513 } 514 515 bool ThreadPlanStepInRange::IsVirtualStep() { return m_virtual_step; } 516