1 //===-- RegisterContextUnwind.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/RegisterContextUnwind.h" 10 #include "lldb/Core/Address.h" 11 #include "lldb/Core/AddressRange.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/Value.h" 14 #include "lldb/Expression/DWARFExpressionList.h" 15 #include "lldb/Symbol/ArmUnwindInfo.h" 16 #include "lldb/Symbol/CallFrameInfo.h" 17 #include "lldb/Symbol/DWARFCallFrameInfo.h" 18 #include "lldb/Symbol/FuncUnwinders.h" 19 #include "lldb/Symbol/Function.h" 20 #include "lldb/Symbol/ObjectFile.h" 21 #include "lldb/Symbol/Symbol.h" 22 #include "lldb/Symbol/SymbolContext.h" 23 #include "lldb/Symbol/SymbolFile.h" 24 #include "lldb/Target/ABI.h" 25 #include "lldb/Target/DynamicLoader.h" 26 #include "lldb/Target/ExecutionContext.h" 27 #include "lldb/Target/LanguageRuntime.h" 28 #include "lldb/Target/Platform.h" 29 #include "lldb/Target/Process.h" 30 #include "lldb/Target/SectionLoadList.h" 31 #include "lldb/Target/StackFrame.h" 32 #include "lldb/Target/Target.h" 33 #include "lldb/Target/Thread.h" 34 #include "lldb/Utility/DataBufferHeap.h" 35 #include "lldb/Utility/LLDBLog.h" 36 #include "lldb/Utility/Log.h" 37 #include "lldb/Utility/RegisterValue.h" 38 #include "lldb/Utility/VASPrintf.h" 39 #include "lldb/lldb-private.h" 40 41 #include <cassert> 42 #include <memory> 43 44 using namespace lldb; 45 using namespace lldb_private; 46 47 static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) { 48 if (sym_ctx.symbol) 49 return sym_ctx.symbol->GetName(); 50 else if (sym_ctx.function) 51 return sym_ctx.function->GetName(); 52 return ConstString(); 53 } 54 55 RegisterContextUnwind::RegisterContextUnwind(Thread &thread, 56 const SharedPtr &next_frame, 57 SymbolContext &sym_ctx, 58 uint32_t frame_number, 59 UnwindLLDB &unwind_lldb) 60 : RegisterContext(thread, frame_number), m_thread(thread), 61 m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(), 62 m_fallback_unwind_plan_sp(), m_all_registers_available(false), 63 m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS), 64 m_afa(LLDB_INVALID_ADDRESS), m_start_pc(), m_current_pc(), 65 m_current_offset(0), m_current_offset_backed_up_one(0), 66 m_behaves_like_zeroth_frame(false), m_sym_ctx(sym_ctx), 67 m_sym_ctx_valid(false), m_frame_number(frame_number), m_registers(), 68 m_parent_unwind(unwind_lldb) { 69 m_sym_ctx.Clear(false); 70 m_sym_ctx_valid = false; 71 72 if (IsFrameZero()) { 73 InitializeZerothFrame(); 74 } else { 75 InitializeNonZerothFrame(); 76 } 77 78 // This same code exists over in the GetFullUnwindPlanForFrame() but it may 79 // not have been executed yet 80 if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame || 81 next_frame->m_frame_type == eDebuggerFrame) { 82 m_all_registers_available = true; 83 } 84 } 85 86 bool RegisterContextUnwind::IsUnwindPlanValidForCurrentPC( 87 lldb::UnwindPlanSP unwind_plan_sp) { 88 if (!unwind_plan_sp) 89 return false; 90 91 // check if m_current_pc is valid 92 if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 93 // yes - current offset can be used as is 94 return true; 95 } 96 97 // if m_current_offset <= 0, we've got nothing else to try 98 if (m_current_offset <= 0) 99 return false; 100 101 // check pc - 1 to see if it's valid 102 Address pc_minus_one(m_current_pc); 103 pc_minus_one.SetOffset(m_current_pc.GetOffset() - 1); 104 if (unwind_plan_sp->PlanValidAtAddress(pc_minus_one)) { 105 return true; 106 } 107 108 return false; 109 } 110 111 // Initialize a RegisterContextUnwind which is the first frame of a stack -- the 112 // zeroth frame or currently executing frame. 113 114 void RegisterContextUnwind::InitializeZerothFrame() { 115 Log *log = GetLog(LLDBLog::Unwind); 116 ExecutionContext exe_ctx(m_thread.shared_from_this()); 117 RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext(); 118 119 if (reg_ctx_sp.get() == nullptr) { 120 m_frame_type = eNotAValidFrame; 121 UnwindLogMsg("frame does not have a register context"); 122 return; 123 } 124 125 addr_t current_pc = reg_ctx_sp->GetPC(); 126 127 if (current_pc == LLDB_INVALID_ADDRESS) { 128 m_frame_type = eNotAValidFrame; 129 UnwindLogMsg("frame does not have a pc"); 130 return; 131 } 132 133 Process *process = exe_ctx.GetProcessPtr(); 134 135 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs 136 // this will strip bit zero in case we read a PC from memory or from the LR. 137 // (which would be a no-op in frame 0 where we get it from the register set, 138 // but still a good idea to make the call here for other ABIs that may 139 // exist.) 140 if (ABISP abi_sp = process->GetABI()) 141 current_pc = abi_sp->FixCodeAddress(current_pc); 142 143 UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan( 144 m_thread, this, m_behaves_like_zeroth_frame); 145 if (lang_runtime_plan_sp.get()) { 146 UnwindLogMsg("This is an async frame"); 147 } 148 149 // Initialize m_current_pc, an Address object, based on current_pc, an 150 // addr_t. 151 m_current_pc.SetLoadAddress(current_pc, &process->GetTarget()); 152 153 // If we don't have a Module for some reason, we're not going to find 154 // symbol/function information - just stick in some reasonable defaults and 155 // hope we can unwind past this frame. 156 ModuleSP pc_module_sp(m_current_pc.GetModule()); 157 if (!m_current_pc.IsValid() || !pc_module_sp) { 158 UnwindLogMsg("using architectural default unwind method"); 159 } 160 161 AddressRange addr_range; 162 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range); 163 164 if (m_sym_ctx.symbol) { 165 UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'", 166 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 167 } else if (m_sym_ctx.function) { 168 UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'", 169 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 170 } else { 171 UnwindLogMsg("with pc value of 0x%" PRIx64 172 ", no symbol/function name is known.", 173 current_pc); 174 } 175 176 if (IsTrapHandlerSymbol(process, m_sym_ctx)) { 177 m_frame_type = eTrapHandlerFrame; 178 } else { 179 // FIXME: Detect eDebuggerFrame here. 180 m_frame_type = eNormalFrame; 181 } 182 183 // If we were able to find a symbol/function, set addr_range to the bounds of 184 // that symbol/function. else treat the current pc value as the start_pc and 185 // record no offset. 186 if (addr_range.GetBaseAddress().IsValid()) { 187 m_start_pc = addr_range.GetBaseAddress(); 188 if (m_current_pc.GetSection() == m_start_pc.GetSection()) { 189 m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset(); 190 } else if (m_current_pc.GetModule() == m_start_pc.GetModule()) { 191 // This means that whatever symbol we kicked up isn't really correct --- 192 // we should not cross section boundaries ... We really should NULL out 193 // the function/symbol in this case unless there is a bad assumption here 194 // due to inlined functions? 195 m_current_offset = 196 m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress(); 197 } 198 m_current_offset_backed_up_one = m_current_offset; 199 } else { 200 m_start_pc = m_current_pc; 201 m_current_offset = -1; 202 m_current_offset_backed_up_one = -1; 203 } 204 205 // We've set m_frame_type and m_sym_ctx before these calls. 206 207 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame(); 208 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame(); 209 210 UnwindPlan::RowSP active_row; 211 lldb::RegisterKind row_register_kind = eRegisterKindGeneric; 212 213 // If we have LanguageRuntime UnwindPlan for this unwind, use those 214 // rules to find the caller frame instead of the function's normal 215 // UnwindPlans. The full unwind plan for this frame will be 216 // the LanguageRuntime-provided unwind plan, and there will not be a 217 // fast unwind plan. 218 if (lang_runtime_plan_sp.get()) { 219 active_row = 220 lang_runtime_plan_sp->GetRowForFunctionOffset(m_current_offset); 221 row_register_kind = lang_runtime_plan_sp->GetRegisterKind(); 222 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), 223 m_cfa)) { 224 UnwindLogMsg("Cannot set cfa"); 225 } else { 226 m_full_unwind_plan_sp = lang_runtime_plan_sp; 227 if (log) { 228 StreamString active_row_strm; 229 active_row->Dump(active_row_strm, lang_runtime_plan_sp.get(), &m_thread, 230 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 231 UnwindLogMsg("async active row: %s", active_row_strm.GetData()); 232 } 233 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa); 234 UnwindLogMsg( 235 "initialized async frame current pc is 0x%" PRIx64 236 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64, 237 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()), 238 (uint64_t)m_cfa, (uint64_t)m_afa); 239 240 return; 241 } 242 } 243 244 if (m_full_unwind_plan_sp && 245 m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 246 active_row = 247 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); 248 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind(); 249 if (active_row.get() && log) { 250 StreamString active_row_strm; 251 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread, 252 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 253 UnwindLogMsg("%s", active_row_strm.GetData()); 254 } 255 } 256 257 if (!active_row.get()) { 258 UnwindLogMsg("could not find an unwindplan row for this frame's pc"); 259 m_frame_type = eNotAValidFrame; 260 return; 261 } 262 263 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) { 264 // Try the fall back unwind plan since the 265 // full unwind plan failed. 266 FuncUnwindersSP func_unwinders_sp; 267 UnwindPlanSP call_site_unwind_plan; 268 bool cfa_status = false; 269 270 if (m_sym_ctx_valid) { 271 func_unwinders_sp = 272 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress( 273 m_current_pc, m_sym_ctx); 274 } 275 276 if (func_unwinders_sp.get() != nullptr) 277 call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite( 278 process->GetTarget(), m_thread); 279 280 if (call_site_unwind_plan.get() != nullptr) { 281 m_fallback_unwind_plan_sp = call_site_unwind_plan; 282 if (TryFallbackUnwindPlan()) 283 cfa_status = true; 284 } 285 if (!cfa_status) { 286 UnwindLogMsg("could not read CFA value for first frame."); 287 m_frame_type = eNotAValidFrame; 288 return; 289 } 290 } else 291 ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa); 292 293 if (m_cfa == LLDB_INVALID_ADDRESS && m_afa == LLDB_INVALID_ADDRESS) { 294 UnwindLogMsg( 295 "could not read CFA or AFA values for first frame, not valid."); 296 m_frame_type = eNotAValidFrame; 297 return; 298 } 299 300 UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64 301 " afa is 0x%" PRIx64 " using %s UnwindPlan", 302 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()), 303 (uint64_t)m_cfa, 304 (uint64_t)m_afa, 305 m_full_unwind_plan_sp->GetSourceName().GetCString()); 306 } 307 308 // Initialize a RegisterContextUnwind for the non-zeroth frame -- rely on the 309 // RegisterContextUnwind "below" it to provide things like its current pc value. 310 311 void RegisterContextUnwind::InitializeNonZerothFrame() { 312 Log *log = GetLog(LLDBLog::Unwind); 313 if (IsFrameZero()) { 314 m_frame_type = eNotAValidFrame; 315 UnwindLogMsg("non-zeroth frame tests positive for IsFrameZero -- that " 316 "shouldn't happen."); 317 return; 318 } 319 320 if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) { 321 m_frame_type = eNotAValidFrame; 322 UnwindLogMsg("Could not get next frame, marking this frame as invalid."); 323 return; 324 } 325 if (!m_thread.GetRegisterContext()) { 326 m_frame_type = eNotAValidFrame; 327 UnwindLogMsg("Could not get register context for this thread, marking this " 328 "frame as invalid."); 329 return; 330 } 331 332 ExecutionContext exe_ctx(m_thread.shared_from_this()); 333 Process *process = exe_ctx.GetProcessPtr(); 334 335 // Some languages may have a logical parent stack frame which is 336 // not a real stack frame, but the programmer would consider it to 337 // be the caller of the frame, e.g. Swift asynchronous frames. 338 // 339 // A LanguageRuntime may provide an UnwindPlan that is used in this 340 // stack trace base on the RegisterContext contents, intsead 341 // of the normal UnwindPlans we would use for the return-pc. 342 UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan( 343 m_thread, this, m_behaves_like_zeroth_frame); 344 if (lang_runtime_plan_sp.get()) { 345 UnwindLogMsg("This is an async frame"); 346 } 347 348 addr_t pc; 349 if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) { 350 UnwindLogMsg("could not get pc value"); 351 m_frame_type = eNotAValidFrame; 352 return; 353 } 354 355 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs 356 // this will strip bit zero in case we read a PC from memory or from the LR. 357 ABISP abi_sp = process->GetABI(); 358 if (abi_sp) 359 pc = abi_sp->FixCodeAddress(pc); 360 361 if (log) { 362 UnwindLogMsg("pc = 0x%" PRIx64, pc); 363 addr_t reg_val; 364 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP, reg_val)) { 365 if (abi_sp) 366 reg_val = abi_sp->FixDataAddress(reg_val); 367 UnwindLogMsg("fp = 0x%" PRIx64, reg_val); 368 } 369 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, reg_val)) { 370 if (abi_sp) 371 reg_val = abi_sp->FixDataAddress(reg_val); 372 UnwindLogMsg("sp = 0x%" PRIx64, reg_val); 373 } 374 } 375 376 // A pc of 0x0 means it's the end of the stack crawl unless we're above a trap 377 // handler function 378 bool above_trap_handler = false; 379 if (GetNextFrame().get() && GetNextFrame()->IsValid() && 380 GetNextFrame()->IsTrapHandlerFrame()) 381 above_trap_handler = true; 382 383 if (pc == 0 || pc == 0x1) { 384 if (!above_trap_handler) { 385 m_frame_type = eNotAValidFrame; 386 UnwindLogMsg("this frame has a pc of 0x0"); 387 return; 388 } 389 } 390 391 const bool allow_section_end = true; 392 m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end); 393 394 // If we don't have a Module for some reason, we're not going to find 395 // symbol/function information - just stick in some reasonable defaults and 396 // hope we can unwind past this frame. If we're above a trap handler, 397 // we may be at a bogus address because we jumped through a bogus function 398 // pointer and trapped, so don't force the arch default unwind plan in that 399 // case. 400 ModuleSP pc_module_sp(m_current_pc.GetModule()); 401 if ((!m_current_pc.IsValid() || !pc_module_sp) && 402 above_trap_handler == false) { 403 UnwindLogMsg("using architectural default unwind method"); 404 405 // Test the pc value to see if we know it's in an unmapped/non-executable 406 // region of memory. 407 uint32_t permissions; 408 if (process->GetLoadAddressPermissions(pc, permissions) && 409 (permissions & ePermissionsExecutable) == 0) { 410 // If this is the second frame off the stack, we may have unwound the 411 // first frame incorrectly. But using the architecture default unwind 412 // plan may get us back on track -- albeit possibly skipping a real 413 // frame. Give this frame a clearly-invalid pc and see if we can get any 414 // further. 415 if (GetNextFrame().get() && GetNextFrame()->IsValid() && 416 GetNextFrame()->IsFrameZero()) { 417 UnwindLogMsg("had a pc of 0x%" PRIx64 " which is not in executable " 418 "memory but on frame 1 -- " 419 "allowing it once.", 420 (uint64_t)pc); 421 m_frame_type = eSkipFrame; 422 } else { 423 // anywhere other than the second frame, a non-executable pc means 424 // we're off in the weeds -- stop now. 425 m_frame_type = eNotAValidFrame; 426 UnwindLogMsg("pc is in a non-executable section of memory and this " 427 "isn't the 2nd frame in the stack walk."); 428 return; 429 } 430 } 431 432 if (abi_sp) { 433 m_fast_unwind_plan_sp.reset(); 434 m_full_unwind_plan_sp = 435 std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 436 abi_sp->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp); 437 if (m_frame_type != eSkipFrame) // don't override eSkipFrame 438 { 439 m_frame_type = eNormalFrame; 440 } 441 m_all_registers_available = false; 442 m_current_offset = -1; 443 m_current_offset_backed_up_one = -1; 444 RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind(); 445 UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0); 446 if (row.get()) { 447 if (!ReadFrameAddress(row_register_kind, row->GetCFAValue(), m_cfa)) { 448 UnwindLogMsg("failed to get cfa value"); 449 if (m_frame_type != eSkipFrame) // don't override eSkipFrame 450 { 451 m_frame_type = eNotAValidFrame; 452 } 453 return; 454 } 455 456 ReadFrameAddress(row_register_kind, row->GetAFAValue(), m_afa); 457 458 // A couple of sanity checks.. 459 if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1) { 460 UnwindLogMsg("could not find a valid cfa address"); 461 m_frame_type = eNotAValidFrame; 462 return; 463 } 464 465 // m_cfa should point into the stack memory; if we can query memory 466 // region permissions, see if the memory is allocated & readable. 467 if (process->GetLoadAddressPermissions(m_cfa, permissions) && 468 (permissions & ePermissionsReadable) == 0) { 469 m_frame_type = eNotAValidFrame; 470 UnwindLogMsg( 471 "the CFA points to a region of memory that is not readable"); 472 return; 473 } 474 } else { 475 UnwindLogMsg("could not find a row for function offset zero"); 476 m_frame_type = eNotAValidFrame; 477 return; 478 } 479 480 if (CheckIfLoopingStack()) { 481 TryFallbackUnwindPlan(); 482 if (CheckIfLoopingStack()) { 483 UnwindLogMsg("same CFA address as next frame, assuming the unwind is " 484 "looping - stopping"); 485 m_frame_type = eNotAValidFrame; 486 return; 487 } 488 } 489 490 UnwindLogMsg("initialized frame cfa is 0x%" PRIx64 " afa is 0x%" PRIx64, 491 (uint64_t)m_cfa, (uint64_t)m_afa); 492 return; 493 } 494 m_frame_type = eNotAValidFrame; 495 UnwindLogMsg("could not find any symbol for this pc, or a default unwind " 496 "plan, to continue unwind."); 497 return; 498 } 499 500 AddressRange addr_range; 501 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range); 502 503 if (m_sym_ctx.symbol) { 504 UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'", pc, 505 GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 506 } else if (m_sym_ctx.function) { 507 UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'", pc, 508 GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 509 } else { 510 UnwindLogMsg("with pc value of 0x%" PRIx64 511 ", no symbol/function name is known.", 512 pc); 513 } 514 515 bool decr_pc_and_recompute_addr_range; 516 517 if (!m_sym_ctx_valid) { 518 // Always decrement and recompute if the symbol lookup failed 519 decr_pc_and_recompute_addr_range = true; 520 } else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame || 521 GetNextFrame()->m_frame_type == eDebuggerFrame) { 522 // Don't decrement if we're "above" an asynchronous event like 523 // sigtramp. 524 decr_pc_and_recompute_addr_range = false; 525 } else if (!addr_range.GetBaseAddress().IsValid() || 526 addr_range.GetBaseAddress().GetSection() != m_current_pc.GetSection() || 527 addr_range.GetBaseAddress().GetOffset() != m_current_pc.GetOffset()) { 528 // If our "current" pc isn't the start of a function, decrement the pc 529 // if we're up the stack. 530 if (m_behaves_like_zeroth_frame) 531 decr_pc_and_recompute_addr_range = false; 532 else 533 decr_pc_and_recompute_addr_range = true; 534 } else if (IsTrapHandlerSymbol(process, m_sym_ctx)) { 535 // Signal dispatch may set the return address of the handler it calls to 536 // point to the first byte of a return trampoline (like __kernel_rt_sigreturn), 537 // so do not decrement and recompute if the symbol we already found is a trap 538 // handler. 539 decr_pc_and_recompute_addr_range = false; 540 } else if (m_behaves_like_zeroth_frame) { 541 decr_pc_and_recompute_addr_range = false; 542 } else { 543 // Decrement to find the function containing the call. 544 decr_pc_and_recompute_addr_range = true; 545 } 546 547 // We need to back up the pc by 1 byte and re-search for the Symbol to handle 548 // the case where the "saved pc" value is pointing to the next function, e.g. 549 // if a function ends with a CALL instruction. 550 // FIXME this may need to be an architectural-dependent behavior; if so we'll 551 // need to add a member function 552 // to the ABI plugin and consult that. 553 if (decr_pc_and_recompute_addr_range) { 554 UnwindLogMsg("Backing up the pc value of 0x%" PRIx64 555 " by 1 and re-doing symbol lookup; old symbol was %s", 556 pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 557 Address temporary_pc; 558 temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget()); 559 m_sym_ctx.Clear(false); 560 m_sym_ctx_valid = temporary_pc.ResolveFunctionScope(m_sym_ctx, &addr_range); 561 562 UnwindLogMsg("Symbol is now %s", 563 GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 564 } 565 566 // If we were able to find a symbol/function, set addr_range_ptr to the 567 // bounds of that symbol/function. else treat the current pc value as the 568 // start_pc and record no offset. 569 if (addr_range.GetBaseAddress().IsValid()) { 570 m_start_pc = addr_range.GetBaseAddress(); 571 m_current_offset = pc - m_start_pc.GetLoadAddress(&process->GetTarget()); 572 m_current_offset_backed_up_one = m_current_offset; 573 if (decr_pc_and_recompute_addr_range && 574 m_current_offset_backed_up_one > 0) { 575 m_current_offset_backed_up_one--; 576 if (m_sym_ctx_valid) { 577 m_current_pc.SetLoadAddress(pc - 1, &process->GetTarget()); 578 } 579 } 580 } else { 581 m_start_pc = m_current_pc; 582 m_current_offset = -1; 583 m_current_offset_backed_up_one = -1; 584 } 585 586 if (IsTrapHandlerSymbol(process, m_sym_ctx)) { 587 m_frame_type = eTrapHandlerFrame; 588 } else { 589 // FIXME: Detect eDebuggerFrame here. 590 if (m_frame_type != eSkipFrame) // don't override eSkipFrame 591 { 592 m_frame_type = eNormalFrame; 593 } 594 } 595 596 UnwindPlan::RowSP active_row; 597 RegisterKind row_register_kind = eRegisterKindGeneric; 598 599 // If we have LanguageRuntime UnwindPlan for this unwind, use those 600 // rules to find the caller frame instead of the function's normal 601 // UnwindPlans. The full unwind plan for this frame will be 602 // the LanguageRuntime-provided unwind plan, and there will not be a 603 // fast unwind plan. 604 if (lang_runtime_plan_sp.get()) { 605 active_row = 606 lang_runtime_plan_sp->GetRowForFunctionOffset(m_current_offset); 607 row_register_kind = lang_runtime_plan_sp->GetRegisterKind(); 608 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), 609 m_cfa)) { 610 UnwindLogMsg("Cannot set cfa"); 611 } else { 612 m_full_unwind_plan_sp = lang_runtime_plan_sp; 613 if (log) { 614 StreamString active_row_strm; 615 active_row->Dump(active_row_strm, lang_runtime_plan_sp.get(), &m_thread, 616 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 617 UnwindLogMsg("async active row: %s", active_row_strm.GetData()); 618 } 619 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa); 620 UnwindLogMsg( 621 "initialized async frame current pc is 0x%" PRIx64 622 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64, 623 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()), 624 (uint64_t)m_cfa, (uint64_t)m_afa); 625 626 return; 627 } 628 } 629 630 // We've set m_frame_type and m_sym_ctx before this call. 631 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame(); 632 633 // Try to get by with just the fast UnwindPlan if possible - the full 634 // UnwindPlan may be expensive to get (e.g. if we have to parse the entire 635 // eh_frame section of an ObjectFile for the first time.) 636 637 if (m_fast_unwind_plan_sp && 638 m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 639 active_row = 640 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); 641 row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind(); 642 PropagateTrapHandlerFlagFromUnwindPlan(m_fast_unwind_plan_sp); 643 if (active_row.get() && log) { 644 StreamString active_row_strm; 645 active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread, 646 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 647 UnwindLogMsg("Using fast unwind plan '%s'", 648 m_fast_unwind_plan_sp->GetSourceName().AsCString()); 649 UnwindLogMsg("active row: %s", active_row_strm.GetData()); 650 } 651 } else { 652 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame(); 653 if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp)) { 654 active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset( 655 m_current_offset_backed_up_one); 656 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind(); 657 PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp); 658 if (active_row.get() && log) { 659 StreamString active_row_strm; 660 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), 661 &m_thread, 662 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 663 UnwindLogMsg("Using full unwind plan '%s'", 664 m_full_unwind_plan_sp->GetSourceName().AsCString()); 665 UnwindLogMsg("active row: %s", active_row_strm.GetData()); 666 } 667 } 668 } 669 670 if (!active_row.get()) { 671 m_frame_type = eNotAValidFrame; 672 UnwindLogMsg("could not find unwind row for this pc"); 673 return; 674 } 675 676 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) { 677 UnwindLogMsg("failed to get cfa"); 678 m_frame_type = eNotAValidFrame; 679 return; 680 } 681 682 ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa); 683 684 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa); 685 686 if (CheckIfLoopingStack()) { 687 TryFallbackUnwindPlan(); 688 if (CheckIfLoopingStack()) { 689 UnwindLogMsg("same CFA address as next frame, assuming the unwind is " 690 "looping - stopping"); 691 m_frame_type = eNotAValidFrame; 692 return; 693 } 694 } 695 696 UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 697 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64, 698 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()), 699 (uint64_t)m_cfa, 700 (uint64_t)m_afa); 701 } 702 703 bool RegisterContextUnwind::CheckIfLoopingStack() { 704 // If we have a bad stack setup, we can get the same CFA value multiple times 705 // -- or even more devious, we can actually oscillate between two CFA values. 706 // Detect that here and break out to avoid a possible infinite loop in lldb 707 // trying to unwind the stack. To detect when we have the same CFA value 708 // multiple times, we compare the 709 // CFA of the current 710 // frame with the 2nd next frame because in some specail case (e.g. signal 711 // hanlders, hand written assembly without ABI compliance) we can have 2 712 // frames with the same 713 // CFA (in theory we 714 // can have arbitrary number of frames with the same CFA, but more then 2 is 715 // very very unlikely) 716 717 RegisterContextUnwind::SharedPtr next_frame = GetNextFrame(); 718 if (next_frame) { 719 RegisterContextUnwind::SharedPtr next_next_frame = 720 next_frame->GetNextFrame(); 721 addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS; 722 if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa)) { 723 if (next_next_frame_cfa == m_cfa) { 724 // We have a loop in the stack unwind 725 return true; 726 } 727 } 728 } 729 return false; 730 } 731 732 bool RegisterContextUnwind::IsFrameZero() const { return m_frame_number == 0; } 733 734 bool RegisterContextUnwind::BehavesLikeZerothFrame() const { 735 if (m_frame_number == 0) 736 return true; 737 if (m_behaves_like_zeroth_frame) 738 return true; 739 return false; 740 } 741 742 // Find a fast unwind plan for this frame, if possible. 743 // 744 // On entry to this method, 745 // 746 // 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame 747 // if either of those are correct, 748 // 2. m_sym_ctx should already be filled in, and 749 // 3. m_current_pc should have the current pc value for this frame 750 // 4. m_current_offset_backed_up_one should have the current byte offset into 751 // the function, maybe backed up by 1, -1 if unknown 752 753 UnwindPlanSP RegisterContextUnwind::GetFastUnwindPlanForFrame() { 754 UnwindPlanSP unwind_plan_sp; 755 ModuleSP pc_module_sp(m_current_pc.GetModule()); 756 757 if (!m_current_pc.IsValid() || !pc_module_sp || 758 pc_module_sp->GetObjectFile() == nullptr) 759 return unwind_plan_sp; 760 761 if (IsFrameZero()) 762 return unwind_plan_sp; 763 764 FuncUnwindersSP func_unwinders_sp( 765 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress( 766 m_current_pc, m_sym_ctx)); 767 if (!func_unwinders_sp) 768 return unwind_plan_sp; 769 770 // If we're in _sigtramp(), unwinding past this frame requires special 771 // knowledge. 772 if (m_frame_type == eTrapHandlerFrame || m_frame_type == eDebuggerFrame) 773 return unwind_plan_sp; 774 775 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind( 776 *m_thread.CalculateTarget(), m_thread); 777 if (unwind_plan_sp) { 778 if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 779 m_frame_type = eNormalFrame; 780 return unwind_plan_sp; 781 } else { 782 unwind_plan_sp.reset(); 783 } 784 } 785 return unwind_plan_sp; 786 } 787 788 // On entry to this method, 789 // 790 // 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame 791 // if either of those are correct, 792 // 2. m_sym_ctx should already be filled in, and 793 // 3. m_current_pc should have the current pc value for this frame 794 // 4. m_current_offset_backed_up_one should have the current byte offset into 795 // the function, maybe backed up by 1, -1 if unknown 796 797 UnwindPlanSP RegisterContextUnwind::GetFullUnwindPlanForFrame() { 798 UnwindPlanSP unwind_plan_sp; 799 UnwindPlanSP arch_default_unwind_plan_sp; 800 ExecutionContext exe_ctx(m_thread.shared_from_this()); 801 Process *process = exe_ctx.GetProcessPtr(); 802 ABI *abi = process ? process->GetABI().get() : nullptr; 803 if (abi) { 804 arch_default_unwind_plan_sp = 805 std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 806 abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp); 807 } else { 808 UnwindLogMsg( 809 "unable to get architectural default UnwindPlan from ABI plugin"); 810 } 811 812 if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame || 813 GetNextFrame()->m_frame_type == eDebuggerFrame) { 814 m_behaves_like_zeroth_frame = true; 815 // If this frame behaves like a 0th frame (currently executing or 816 // interrupted asynchronously), all registers can be retrieved. 817 m_all_registers_available = true; 818 } 819 820 // If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer) 821 // so the pc is 0x0 in the zeroth frame, we need to use the "unwind at first 822 // instruction" arch default UnwindPlan Also, if this Process can report on 823 // memory region attributes, any non-executable region means we jumped 824 // through a bad function pointer - handle the same way as 0x0. Note, if we 825 // have a symbol context & a symbol, we don't want to follow this code path. 826 // This is for jumping to memory regions without any information available. 827 828 if ((!m_sym_ctx_valid || 829 (m_sym_ctx.function == nullptr && m_sym_ctx.symbol == nullptr)) && 830 m_behaves_like_zeroth_frame && m_current_pc.IsValid()) { 831 uint32_t permissions; 832 addr_t current_pc_addr = 833 m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()); 834 if (current_pc_addr == 0 || 835 (process && 836 process->GetLoadAddressPermissions(current_pc_addr, permissions) && 837 (permissions & ePermissionsExecutable) == 0)) { 838 if (abi) { 839 unwind_plan_sp = 840 std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 841 abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp); 842 m_frame_type = eNormalFrame; 843 return unwind_plan_sp; 844 } 845 } 846 } 847 848 // No Module for the current pc, try using the architecture default unwind. 849 ModuleSP pc_module_sp(m_current_pc.GetModule()); 850 if (!m_current_pc.IsValid() || !pc_module_sp || 851 pc_module_sp->GetObjectFile() == nullptr) { 852 m_frame_type = eNormalFrame; 853 return arch_default_unwind_plan_sp; 854 } 855 856 FuncUnwindersSP func_unwinders_sp; 857 if (m_sym_ctx_valid) { 858 func_unwinders_sp = 859 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress( 860 m_current_pc, m_sym_ctx); 861 } 862 863 // No FuncUnwinders available for this pc (stripped function symbols, lldb 864 // could not augment its function table with another source, like 865 // LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO). See if eh_frame or the 866 // .ARM.exidx tables have unwind information for this address, else fall back 867 // to the architectural default unwind. 868 if (!func_unwinders_sp) { 869 m_frame_type = eNormalFrame; 870 871 if (!pc_module_sp || !pc_module_sp->GetObjectFile() || 872 !m_current_pc.IsValid()) 873 return arch_default_unwind_plan_sp; 874 875 // Even with -fomit-frame-pointer, we can try eh_frame to get back on 876 // track. 877 DWARFCallFrameInfo *eh_frame = 878 pc_module_sp->GetUnwindTable().GetEHFrameInfo(); 879 if (eh_frame) { 880 unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 881 if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp)) 882 return unwind_plan_sp; 883 else 884 unwind_plan_sp.reset(); 885 } 886 887 ArmUnwindInfo *arm_exidx = 888 pc_module_sp->GetUnwindTable().GetArmUnwindInfo(); 889 if (arm_exidx) { 890 unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 891 if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc, 892 *unwind_plan_sp)) 893 return unwind_plan_sp; 894 else 895 unwind_plan_sp.reset(); 896 } 897 898 CallFrameInfo *object_file_unwind = 899 pc_module_sp->GetUnwindTable().GetObjectFileUnwindInfo(); 900 if (object_file_unwind) { 901 unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); 902 if (object_file_unwind->GetUnwindPlan(m_current_pc, *unwind_plan_sp)) 903 return unwind_plan_sp; 904 else 905 unwind_plan_sp.reset(); 906 } 907 908 return arch_default_unwind_plan_sp; 909 } 910 911 if (m_frame_type == eTrapHandlerFrame && process) { 912 m_fast_unwind_plan_sp.reset(); 913 914 // On some platforms the unwind information for signal handlers is not 915 // present or correct. Give the platform plugins a chance to provide 916 // substitute plan. Otherwise, use eh_frame. 917 if (m_sym_ctx_valid) { 918 lldb::PlatformSP platform = process->GetTarget().GetPlatform(); 919 unwind_plan_sp = platform->GetTrapHandlerUnwindPlan( 920 process->GetTarget().GetArchitecture().GetTriple(), 921 GetSymbolOrFunctionName(m_sym_ctx)); 922 923 if (unwind_plan_sp) 924 return unwind_plan_sp; 925 } 926 927 unwind_plan_sp = 928 func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget()); 929 if (!unwind_plan_sp) 930 unwind_plan_sp = 931 func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget()); 932 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) && 933 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) { 934 return unwind_plan_sp; 935 } 936 } 937 938 // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame 939 // even when it's frame zero This comes up if we have hand-written functions 940 // in a Module and hand-written eh_frame. The assembly instruction 941 // inspection may fail and the eh_frame CFI were probably written with some 942 // care to do the right thing. It'd be nice if there was a way to ask the 943 // eh_frame directly if it is asynchronous (can be trusted at every 944 // instruction point) or synchronous (the normal case - only at call sites). 945 // But there is not. 946 if (process && process->GetDynamicLoader() && 947 process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(m_sym_ctx)) { 948 // We must specifically call the GetEHFrameUnwindPlan() method here -- 949 // normally we would call GetUnwindPlanAtCallSite() -- because CallSite may 950 // return an unwind plan sourced from either eh_frame (that's what we 951 // intend) or compact unwind (this won't work) 952 unwind_plan_sp = 953 func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget()); 954 if (!unwind_plan_sp) 955 unwind_plan_sp = 956 func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget()); 957 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 958 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because the " 959 "DynamicLoader suggested we prefer it", 960 unwind_plan_sp->GetSourceName().GetCString()); 961 return unwind_plan_sp; 962 } 963 } 964 965 // Typically the NonCallSite UnwindPlan is the unwind created by inspecting 966 // the assembly language instructions 967 if (m_behaves_like_zeroth_frame && process) { 968 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite( 969 process->GetTarget(), m_thread); 970 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { 971 if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) { 972 // We probably have an UnwindPlan created by inspecting assembly 973 // instructions. The assembly profilers work really well with compiler- 974 // generated functions but hand- written assembly can be problematic. 975 // We set the eh_frame based unwind plan as our fallback unwind plan if 976 // instruction emulation doesn't work out even for non call sites if it 977 // is available and use the architecture default unwind plan if it is 978 // not available. The eh_frame unwind plan is more reliable even on non 979 // call sites then the architecture default plan and for hand written 980 // assembly code it is often written in a way that it valid at all 981 // location what helps in the most common cases when the instruction 982 // emulation fails. 983 UnwindPlanSP call_site_unwind_plan = 984 func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(), 985 m_thread); 986 if (call_site_unwind_plan && 987 call_site_unwind_plan.get() != unwind_plan_sp.get() && 988 call_site_unwind_plan->GetSourceName() != 989 unwind_plan_sp->GetSourceName()) { 990 m_fallback_unwind_plan_sp = call_site_unwind_plan; 991 } else { 992 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp; 993 } 994 } 995 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this " 996 "is the non-call site unwind plan and this is a " 997 "zeroth frame", 998 unwind_plan_sp->GetSourceName().GetCString()); 999 return unwind_plan_sp; 1000 } 1001 1002 // If we're on the first instruction of a function, and we have an 1003 // architectural default UnwindPlan for the initial instruction of a 1004 // function, use that. 1005 if (m_current_offset == 0) { 1006 unwind_plan_sp = 1007 func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry( 1008 m_thread); 1009 if (unwind_plan_sp) { 1010 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we are at " 1011 "the first instruction of a function", 1012 unwind_plan_sp->GetSourceName().GetCString()); 1013 return unwind_plan_sp; 1014 } 1015 } 1016 } 1017 1018 // Typically this is unwind info from an eh_frame section intended for 1019 // exception handling; only valid at call sites 1020 if (process) { 1021 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite( 1022 process->GetTarget(), m_thread); 1023 } 1024 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) { 1025 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this " 1026 "is the call-site unwind plan", 1027 unwind_plan_sp->GetSourceName().GetCString()); 1028 return unwind_plan_sp; 1029 } 1030 1031 // We'd prefer to use an UnwindPlan intended for call sites when we're at a 1032 // call site but if we've struck out on that, fall back to using the non- 1033 // call-site assembly inspection UnwindPlan if possible. 1034 if (process) { 1035 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite( 1036 process->GetTarget(), m_thread); 1037 } 1038 if (unwind_plan_sp && 1039 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) { 1040 // We probably have an UnwindPlan created by inspecting assembly 1041 // instructions. The assembly profilers work really well with compiler- 1042 // generated functions but hand- written assembly can be problematic. We 1043 // set the eh_frame based unwind plan as our fallback unwind plan if 1044 // instruction emulation doesn't work out even for non call sites if it is 1045 // available and use the architecture default unwind plan if it is not 1046 // available. The eh_frame unwind plan is more reliable even on non call 1047 // sites then the architecture default plan and for hand written assembly 1048 // code it is often written in a way that it valid at all location what 1049 // helps in the most common cases when the instruction emulation fails. 1050 UnwindPlanSP call_site_unwind_plan = 1051 func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(), 1052 m_thread); 1053 if (call_site_unwind_plan && 1054 call_site_unwind_plan.get() != unwind_plan_sp.get() && 1055 call_site_unwind_plan->GetSourceName() != 1056 unwind_plan_sp->GetSourceName()) { 1057 m_fallback_unwind_plan_sp = call_site_unwind_plan; 1058 } else { 1059 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp; 1060 } 1061 } 1062 1063 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) { 1064 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we " 1065 "failed to find a call-site unwind plan that would work", 1066 unwind_plan_sp->GetSourceName().GetCString()); 1067 return unwind_plan_sp; 1068 } 1069 1070 // If nothing else, use the architectural default UnwindPlan and hope that 1071 // does the job. 1072 if (arch_default_unwind_plan_sp) 1073 UnwindLogMsgVerbose( 1074 "frame uses %s for full UnwindPlan because we are falling back " 1075 "to the arch default plan", 1076 arch_default_unwind_plan_sp->GetSourceName().GetCString()); 1077 else 1078 UnwindLogMsg( 1079 "Unable to find any UnwindPlan for full unwind of this frame."); 1080 1081 return arch_default_unwind_plan_sp; 1082 } 1083 1084 void RegisterContextUnwind::InvalidateAllRegisters() { 1085 m_frame_type = eNotAValidFrame; 1086 } 1087 1088 size_t RegisterContextUnwind::GetRegisterCount() { 1089 return m_thread.GetRegisterContext()->GetRegisterCount(); 1090 } 1091 1092 const RegisterInfo *RegisterContextUnwind::GetRegisterInfoAtIndex(size_t reg) { 1093 return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg); 1094 } 1095 1096 size_t RegisterContextUnwind::GetRegisterSetCount() { 1097 return m_thread.GetRegisterContext()->GetRegisterSetCount(); 1098 } 1099 1100 const RegisterSet *RegisterContextUnwind::GetRegisterSet(size_t reg_set) { 1101 return m_thread.GetRegisterContext()->GetRegisterSet(reg_set); 1102 } 1103 1104 uint32_t RegisterContextUnwind::ConvertRegisterKindToRegisterNumber( 1105 lldb::RegisterKind kind, uint32_t num) { 1106 return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber( 1107 kind, num); 1108 } 1109 1110 bool RegisterContextUnwind::ReadRegisterValueFromRegisterLocation( 1111 lldb_private::UnwindLLDB::RegisterLocation regloc, 1112 const RegisterInfo *reg_info, RegisterValue &value) { 1113 if (!IsValid()) 1114 return false; 1115 bool success = false; 1116 1117 switch (regloc.type) { 1118 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: { 1119 const RegisterInfo *other_reg_info = 1120 GetRegisterInfoAtIndex(regloc.location.register_number); 1121 1122 if (!other_reg_info) 1123 return false; 1124 1125 success = 1126 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value); 1127 } break; 1128 case UnwindLLDB::RegisterLocation::eRegisterInRegister: { 1129 const RegisterInfo *other_reg_info = 1130 GetRegisterInfoAtIndex(regloc.location.register_number); 1131 1132 if (!other_reg_info) 1133 return false; 1134 1135 if (IsFrameZero()) { 1136 success = 1137 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value); 1138 } else { 1139 success = GetNextFrame()->ReadRegister(other_reg_info, value); 1140 } 1141 } break; 1142 case UnwindLLDB::RegisterLocation::eRegisterValueInferred: 1143 success = 1144 value.SetUInt(regloc.location.inferred_value, reg_info->byte_size); 1145 break; 1146 1147 case UnwindLLDB::RegisterLocation::eRegisterNotSaved: 1148 break; 1149 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation: 1150 llvm_unreachable("FIXME debugger inferior function call unwind"); 1151 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: { 1152 Status error(ReadRegisterValueFromMemory( 1153 reg_info, regloc.location.target_memory_location, reg_info->byte_size, 1154 value)); 1155 success = error.Success(); 1156 } break; 1157 default: 1158 llvm_unreachable("Unknown RegisterLocation type."); 1159 } 1160 return success; 1161 } 1162 1163 bool RegisterContextUnwind::WriteRegisterValueToRegisterLocation( 1164 lldb_private::UnwindLLDB::RegisterLocation regloc, 1165 const RegisterInfo *reg_info, const RegisterValue &value) { 1166 if (!IsValid()) 1167 return false; 1168 1169 bool success = false; 1170 1171 switch (regloc.type) { 1172 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: { 1173 const RegisterInfo *other_reg_info = 1174 GetRegisterInfoAtIndex(regloc.location.register_number); 1175 success = 1176 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value); 1177 } break; 1178 case UnwindLLDB::RegisterLocation::eRegisterInRegister: { 1179 const RegisterInfo *other_reg_info = 1180 GetRegisterInfoAtIndex(regloc.location.register_number); 1181 if (IsFrameZero()) { 1182 success = 1183 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value); 1184 } else { 1185 success = GetNextFrame()->WriteRegister(other_reg_info, value); 1186 } 1187 } break; 1188 case UnwindLLDB::RegisterLocation::eRegisterValueInferred: 1189 case UnwindLLDB::RegisterLocation::eRegisterNotSaved: 1190 break; 1191 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation: 1192 llvm_unreachable("FIXME debugger inferior function call unwind"); 1193 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: { 1194 Status error(WriteRegisterValueToMemory( 1195 reg_info, regloc.location.target_memory_location, reg_info->byte_size, 1196 value)); 1197 success = error.Success(); 1198 } break; 1199 default: 1200 llvm_unreachable("Unknown RegisterLocation type."); 1201 } 1202 return success; 1203 } 1204 1205 bool RegisterContextUnwind::IsValid() const { 1206 return m_frame_type != eNotAValidFrame; 1207 } 1208 1209 // After the final stack frame in a stack walk we'll get one invalid 1210 // (eNotAValidFrame) stack frame -- one past the end of the stack walk. But 1211 // higher-level code will need to tell the difference between "the unwind plan 1212 // below this frame failed" versus "we successfully completed the stack walk" 1213 // so this method helps to disambiguate that. 1214 1215 bool RegisterContextUnwind::IsTrapHandlerFrame() const { 1216 return m_frame_type == eTrapHandlerFrame; 1217 } 1218 1219 // A skip frame is a bogus frame on the stack -- but one where we're likely to 1220 // find a real frame farther 1221 // up the stack if we keep looking. It's always the second frame in an unwind 1222 // (i.e. the first frame after frame zero) where unwinding can be the 1223 // trickiest. Ideally we'll mark up this frame in some way so the user knows 1224 // we're displaying bad data and we may have skipped one frame of their real 1225 // program in the process of getting back on track. 1226 1227 bool RegisterContextUnwind::IsSkipFrame() const { 1228 return m_frame_type == eSkipFrame; 1229 } 1230 1231 bool RegisterContextUnwind::IsTrapHandlerSymbol( 1232 lldb_private::Process *process, 1233 const lldb_private::SymbolContext &m_sym_ctx) const { 1234 PlatformSP platform_sp(process->GetTarget().GetPlatform()); 1235 if (platform_sp) { 1236 const std::vector<ConstString> trap_handler_names( 1237 platform_sp->GetTrapHandlerSymbolNames()); 1238 for (ConstString name : trap_handler_names) { 1239 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) || 1240 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) { 1241 return true; 1242 } 1243 } 1244 } 1245 const std::vector<ConstString> user_specified_trap_handler_names( 1246 m_parent_unwind.GetUserSpecifiedTrapHandlerFunctionNames()); 1247 for (ConstString name : user_specified_trap_handler_names) { 1248 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) || 1249 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) { 1250 return true; 1251 } 1252 } 1253 1254 return false; 1255 } 1256 1257 // Answer the question: Where did THIS frame save the CALLER frame ("previous" 1258 // frame)'s register value? 1259 1260 enum UnwindLLDB::RegisterSearchResult 1261 RegisterContextUnwind::SavedLocationForRegister( 1262 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc) { 1263 RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum); 1264 Log *log = GetLog(LLDBLog::Unwind); 1265 1266 // Have we already found this register location? 1267 if (!m_registers.empty()) { 1268 std::map<uint32_t, 1269 lldb_private::UnwindLLDB::RegisterLocation>::const_iterator 1270 iterator; 1271 iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB)); 1272 if (iterator != m_registers.end()) { 1273 regloc = iterator->second; 1274 UnwindLogMsg("supplying caller's saved %s (%d)'s location, cached", 1275 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1276 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1277 } 1278 } 1279 1280 // Look through the available UnwindPlans for the register location. 1281 1282 UnwindPlan::Row::RegisterLocation unwindplan_regloc; 1283 bool have_unwindplan_regloc = false; 1284 RegisterKind unwindplan_registerkind = kNumRegisterKinds; 1285 1286 if (m_fast_unwind_plan_sp) { 1287 UnwindPlan::RowSP active_row = 1288 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); 1289 unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind(); 1290 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) { 1291 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind " 1292 "reg numbering scheme", 1293 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), 1294 (int)unwindplan_registerkind); 1295 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1296 } 1297 // The architecture default unwind plan marks unknown registers as 1298 // Undefined so that we don't forward them up the stack when a 1299 // jitted stack frame may have overwritten them. But when the 1300 // arch default unwind plan is used as the Fast Unwind Plan, we 1301 // need to recognize this & switch over to the Full Unwind Plan 1302 // to see what unwind rule that (more knoweldgeable, probably) 1303 // UnwindPlan has. If the full UnwindPlan says the register 1304 // location is Undefined, then it really is. 1305 if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind), 1306 unwindplan_regloc) && 1307 !unwindplan_regloc.IsUndefined()) { 1308 UnwindLogMsg( 1309 "supplying caller's saved %s (%d)'s location using FastUnwindPlan", 1310 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1311 have_unwindplan_regloc = true; 1312 } 1313 } 1314 1315 if (!have_unwindplan_regloc) { 1316 // m_full_unwind_plan_sp being NULL means that we haven't tried to find a 1317 // full UnwindPlan yet 1318 bool got_new_full_unwindplan = false; 1319 if (!m_full_unwind_plan_sp) { 1320 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame(); 1321 got_new_full_unwindplan = true; 1322 } 1323 1324 if (m_full_unwind_plan_sp) { 1325 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric, 1326 LLDB_REGNUM_GENERIC_PC); 1327 1328 UnwindPlan::RowSP active_row = 1329 m_full_unwind_plan_sp->GetRowForFunctionOffset( 1330 m_current_offset_backed_up_one); 1331 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind(); 1332 1333 if (got_new_full_unwindplan && active_row.get() && log) { 1334 StreamString active_row_strm; 1335 ExecutionContext exe_ctx(m_thread.shared_from_this()); 1336 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), 1337 &m_thread, 1338 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); 1339 UnwindLogMsg("Using full unwind plan '%s'", 1340 m_full_unwind_plan_sp->GetSourceName().AsCString()); 1341 UnwindLogMsg("active row: %s", active_row_strm.GetData()); 1342 } 1343 RegisterNumber return_address_reg; 1344 1345 // If we're fetching the saved pc and this UnwindPlan defines a 1346 // ReturnAddress register (e.g. lr on arm), look for the return address 1347 // register number in the UnwindPlan's row. 1348 if (pc_regnum.IsValid() && pc_regnum == regnum && 1349 m_full_unwind_plan_sp->GetReturnAddressRegister() != 1350 LLDB_INVALID_REGNUM) { 1351 // If this is a trap handler frame, we should have access to 1352 // the complete register context when the interrupt/async 1353 // signal was received, we should fetch the actual saved $pc 1354 // value instead of the Return Address register. 1355 // If $pc is not available, fall back to the RA reg. 1356 UnwindPlan::Row::RegisterLocation scratch; 1357 if (m_frame_type == eTrapHandlerFrame && 1358 active_row->GetRegisterInfo 1359 (pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) { 1360 UnwindLogMsg("Providing pc register instead of rewriting to " 1361 "RA reg because this is a trap handler and there is " 1362 "a location for the saved pc register value."); 1363 } else { 1364 return_address_reg.init( 1365 m_thread, m_full_unwind_plan_sp->GetRegisterKind(), 1366 m_full_unwind_plan_sp->GetReturnAddressRegister()); 1367 regnum = return_address_reg; 1368 UnwindLogMsg("requested caller's saved PC but this UnwindPlan uses a " 1369 "RA reg; getting %s (%d) instead", 1370 return_address_reg.GetName(), 1371 return_address_reg.GetAsKind(eRegisterKindLLDB)); 1372 } 1373 } else { 1374 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) { 1375 if (unwindplan_registerkind == eRegisterKindGeneric) { 1376 UnwindLogMsg("could not convert lldb regnum %s (%d) into " 1377 "eRegisterKindGeneric reg numbering scheme", 1378 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1379 } else { 1380 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d " 1381 "RegisterKind reg numbering scheme", 1382 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), 1383 (int)unwindplan_registerkind); 1384 } 1385 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1386 } 1387 } 1388 1389 if (regnum.IsValid() && 1390 active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind), 1391 unwindplan_regloc)) { 1392 have_unwindplan_regloc = true; 1393 UnwindLogMsg( 1394 "supplying caller's saved %s (%d)'s location using %s UnwindPlan", 1395 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), 1396 m_full_unwind_plan_sp->GetSourceName().GetCString()); 1397 } 1398 1399 // This is frame 0 and we're retrieving the PC and it's saved in a Return 1400 // Address register and it hasn't been saved anywhere yet -- that is, 1401 // it's still live in the actual register. Handle this specially. 1402 1403 if (!have_unwindplan_regloc && return_address_reg.IsValid() && 1404 IsFrameZero()) { 1405 if (return_address_reg.GetAsKind(eRegisterKindLLDB) != 1406 LLDB_INVALID_REGNUM) { 1407 lldb_private::UnwindLLDB::RegisterLocation new_regloc; 1408 new_regloc.type = 1409 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext; 1410 new_regloc.location.register_number = 1411 return_address_reg.GetAsKind(eRegisterKindLLDB); 1412 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc; 1413 regloc = new_regloc; 1414 UnwindLogMsg("supplying caller's register %s (%d) from the live " 1415 "RegisterContext at frame 0, saved in %d", 1416 return_address_reg.GetName(), 1417 return_address_reg.GetAsKind(eRegisterKindLLDB), 1418 return_address_reg.GetAsKind(eRegisterKindLLDB)); 1419 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1420 } 1421 } 1422 1423 // If this architecture stores the return address in a register (it 1424 // defines a Return Address register) and we're on a non-zero stack frame 1425 // and the Full UnwindPlan says that the pc is stored in the 1426 // RA registers (e.g. lr on arm), then we know that the full unwindplan is 1427 // not trustworthy -- this 1428 // is an impossible situation and the instruction emulation code has 1429 // likely been misled. If this stack frame meets those criteria, we need 1430 // to throw away the Full UnwindPlan that the instruction emulation came 1431 // up with and fall back to the architecture's Default UnwindPlan so the 1432 // stack walk can get past this point. 1433 1434 // Special note: If the Full UnwindPlan was generated from the compiler, 1435 // don't second-guess it when we're at a call site location. 1436 1437 // arch_default_ra_regnum is the return address register # in the Full 1438 // UnwindPlan register numbering 1439 RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric, 1440 LLDB_REGNUM_GENERIC_RA); 1441 1442 if (arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) != 1443 LLDB_INVALID_REGNUM && 1444 pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() && 1445 unwindplan_regloc.GetRegisterNumber() == 1446 arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) && 1447 m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes && 1448 !m_all_registers_available) { 1449 UnwindLogMsg("%s UnwindPlan tried to restore the pc from the link " 1450 "register but this is a non-zero frame", 1451 m_full_unwind_plan_sp->GetSourceName().GetCString()); 1452 1453 // Throw away the full unwindplan; install the arch default unwindplan 1454 if (ForceSwitchToFallbackUnwindPlan()) { 1455 // Update for the possibly new unwind plan 1456 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind(); 1457 UnwindPlan::RowSP active_row = 1458 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); 1459 1460 // Sanity check: Verify that we can fetch a pc value and CFA value 1461 // with this unwind plan 1462 1463 RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric, 1464 LLDB_REGNUM_GENERIC_PC); 1465 bool can_fetch_pc_value = false; 1466 bool can_fetch_cfa = false; 1467 addr_t cfa_value; 1468 if (active_row) { 1469 if (arch_default_pc_reg.GetAsKind(unwindplan_registerkind) != 1470 LLDB_INVALID_REGNUM && 1471 active_row->GetRegisterInfo( 1472 arch_default_pc_reg.GetAsKind(unwindplan_registerkind), 1473 unwindplan_regloc)) { 1474 can_fetch_pc_value = true; 1475 } 1476 if (ReadFrameAddress(unwindplan_registerkind, 1477 active_row->GetCFAValue(), cfa_value)) { 1478 can_fetch_cfa = true; 1479 } 1480 } 1481 1482 have_unwindplan_regloc = can_fetch_pc_value && can_fetch_cfa; 1483 } else { 1484 // We were unable to fall back to another unwind plan 1485 have_unwindplan_regloc = false; 1486 } 1487 } 1488 } 1489 } 1490 1491 ExecutionContext exe_ctx(m_thread.shared_from_this()); 1492 Process *process = exe_ctx.GetProcessPtr(); 1493 if (!have_unwindplan_regloc) { 1494 // If the UnwindPlan failed to give us an unwind location for this 1495 // register, we may be able to fall back to some ABI-defined default. For 1496 // example, some ABIs allow to determine the caller's SP via the CFA. Also, 1497 // the ABI may set volatile registers to the undefined state. 1498 ABI *abi = process ? process->GetABI().get() : nullptr; 1499 if (abi) { 1500 const RegisterInfo *reg_info = 1501 GetRegisterInfoAtIndex(regnum.GetAsKind(eRegisterKindLLDB)); 1502 if (reg_info && 1503 abi->GetFallbackRegisterLocation(reg_info, unwindplan_regloc)) { 1504 UnwindLogMsg( 1505 "supplying caller's saved %s (%d)'s location using ABI default", 1506 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1507 have_unwindplan_regloc = true; 1508 } 1509 } 1510 } 1511 1512 if (!have_unwindplan_regloc) { 1513 if (IsFrameZero()) { 1514 // This is frame 0 - we should return the actual live register context 1515 // value 1516 lldb_private::UnwindLLDB::RegisterLocation new_regloc; 1517 new_regloc.type = 1518 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext; 1519 new_regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB); 1520 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc; 1521 regloc = new_regloc; 1522 UnwindLogMsg("supplying caller's register %s (%d) from the live " 1523 "RegisterContext at frame 0", 1524 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1525 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1526 } else { 1527 std::string unwindplan_name; 1528 if (m_full_unwind_plan_sp) { 1529 unwindplan_name += "via '"; 1530 unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString(); 1531 unwindplan_name += "'"; 1532 } 1533 UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(), 1534 regnum.GetAsKind(eRegisterKindLLDB), 1535 unwindplan_name.c_str()); 1536 } 1537 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1538 } 1539 1540 // unwindplan_regloc has valid contents about where to retrieve the register 1541 if (unwindplan_regloc.IsUnspecified()) { 1542 lldb_private::UnwindLLDB::RegisterLocation new_regloc = {}; 1543 new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved; 1544 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc; 1545 UnwindLogMsg("save location for %s (%d) is unspecified, continue searching", 1546 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1547 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1548 } 1549 1550 if (unwindplan_regloc.IsUndefined()) { 1551 UnwindLogMsg( 1552 "did not supply reg location for %s (%d) because it is volatile", 1553 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1554 return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile; 1555 } 1556 1557 if (unwindplan_regloc.IsSame()) { 1558 if (!IsFrameZero() && 1559 (regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC || 1560 regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA)) { 1561 UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or " 1562 "return address reg on a non-zero frame -- treat as if we " 1563 "have no information", 1564 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1565 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1566 } else { 1567 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister; 1568 regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB); 1569 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1570 UnwindLogMsg( 1571 "supplying caller's register %s (%d), saved in register %s (%d)", 1572 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), 1573 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1574 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1575 } 1576 } 1577 1578 if (unwindplan_regloc.IsCFAPlusOffset()) { 1579 int offset = unwindplan_regloc.GetOffset(); 1580 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred; 1581 regloc.location.inferred_value = m_cfa + offset; 1582 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1583 UnwindLogMsg("supplying caller's register %s (%d), value is CFA plus " 1584 "offset %d [value is 0x%" PRIx64 "]", 1585 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset, 1586 regloc.location.inferred_value); 1587 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1588 } 1589 1590 if (unwindplan_regloc.IsAtCFAPlusOffset()) { 1591 int offset = unwindplan_regloc.GetOffset(); 1592 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation; 1593 regloc.location.target_memory_location = m_cfa + offset; 1594 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1595 UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at " 1596 "CFA plus offset %d [saved at 0x%" PRIx64 "]", 1597 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset, 1598 regloc.location.target_memory_location); 1599 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1600 } 1601 1602 if (unwindplan_regloc.IsAFAPlusOffset()) { 1603 if (m_afa == LLDB_INVALID_ADDRESS) 1604 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1605 1606 int offset = unwindplan_regloc.GetOffset(); 1607 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred; 1608 regloc.location.inferred_value = m_afa + offset; 1609 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1610 UnwindLogMsg("supplying caller's register %s (%d), value is AFA plus " 1611 "offset %d [value is 0x%" PRIx64 "]", 1612 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset, 1613 regloc.location.inferred_value); 1614 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1615 } 1616 1617 if (unwindplan_regloc.IsAtAFAPlusOffset()) { 1618 if (m_afa == LLDB_INVALID_ADDRESS) 1619 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1620 1621 int offset = unwindplan_regloc.GetOffset(); 1622 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation; 1623 regloc.location.target_memory_location = m_afa + offset; 1624 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1625 UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at " 1626 "AFA plus offset %d [saved at 0x%" PRIx64 "]", 1627 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset, 1628 regloc.location.target_memory_location); 1629 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1630 } 1631 1632 if (unwindplan_regloc.IsInOtherRegister()) { 1633 uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber(); 1634 RegisterNumber row_regnum(m_thread, unwindplan_registerkind, 1635 unwindplan_regnum); 1636 if (row_regnum.GetAsKind(eRegisterKindLLDB) == LLDB_INVALID_REGNUM) { 1637 UnwindLogMsg("could not supply caller's %s (%d) location - was saved in " 1638 "another reg but couldn't convert that regnum", 1639 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1640 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1641 } 1642 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister; 1643 regloc.location.register_number = row_regnum.GetAsKind(eRegisterKindLLDB); 1644 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1645 UnwindLogMsg( 1646 "supplying caller's register %s (%d), saved in register %s (%d)", 1647 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), 1648 row_regnum.GetName(), row_regnum.GetAsKind(eRegisterKindLLDB)); 1649 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1650 } 1651 1652 if (unwindplan_regloc.IsDWARFExpression() || 1653 unwindplan_regloc.IsAtDWARFExpression()) { 1654 DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(), 1655 unwindplan_regloc.GetDWARFExpressionLength(), 1656 process->GetByteOrder(), 1657 process->GetAddressByteSize()); 1658 ModuleSP opcode_ctx; 1659 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr); 1660 dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind( 1661 unwindplan_registerkind); 1662 Value cfa_val = Scalar(m_cfa); 1663 cfa_val.SetValueType(Value::ValueType::LoadAddress); 1664 Value result; 1665 Status error; 1666 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result, 1667 &error)) { 1668 addr_t val; 1669 val = result.GetScalar().ULongLong(); 1670 if (unwindplan_regloc.IsDWARFExpression()) { 1671 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred; 1672 regloc.location.inferred_value = val; 1673 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1674 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression " 1675 "(IsDWARFExpression)", 1676 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1677 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1678 } else { 1679 regloc.type = 1680 UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation; 1681 regloc.location.target_memory_location = val; 1682 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc; 1683 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression " 1684 "(IsAtDWARFExpression)", 1685 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1686 return UnwindLLDB::RegisterSearchResult::eRegisterFound; 1687 } 1688 } 1689 UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s " 1690 "(%d) but failed", 1691 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1692 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1693 } 1694 1695 UnwindLogMsg("no save location for %s (%d) in this stack frame", 1696 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); 1697 1698 // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are 1699 // unsupported. 1700 1701 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 1702 } 1703 1704 // TryFallbackUnwindPlan() -- this method is a little tricky. 1705 // 1706 // When this is called, the frame above -- the caller frame, the "previous" 1707 // frame -- is invalid or bad. 1708 // 1709 // Instead of stopping the stack walk here, we'll try a different UnwindPlan 1710 // and see if we can get a valid frame above us. 1711 // 1712 // This most often happens when an unwind plan based on assembly instruction 1713 // inspection is not correct -- mostly with hand-written assembly functions or 1714 // functions where the stack frame is set up "out of band", e.g. the kernel 1715 // saved the register context and then called an asynchronous trap handler like 1716 // _sigtramp. 1717 // 1718 // Often in these cases, if we just do a dumb stack walk we'll get past this 1719 // tricky frame and our usual techniques can continue to be used. 1720 1721 bool RegisterContextUnwind::TryFallbackUnwindPlan() { 1722 if (m_fallback_unwind_plan_sp.get() == nullptr) 1723 return false; 1724 1725 if (m_full_unwind_plan_sp.get() == nullptr) 1726 return false; 1727 1728 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() || 1729 m_full_unwind_plan_sp->GetSourceName() == 1730 m_fallback_unwind_plan_sp->GetSourceName()) { 1731 return false; 1732 } 1733 1734 // If a compiler generated unwind plan failed, trying the arch default 1735 // unwindplan isn't going to do any better. 1736 if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) 1737 return false; 1738 1739 // Get the caller's pc value and our own CFA value. Swap in the fallback 1740 // unwind plan, re-fetch the caller's pc value and CFA value. If they're the 1741 // same, then the fallback unwind plan provides no benefit. 1742 1743 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric, 1744 LLDB_REGNUM_GENERIC_PC); 1745 1746 addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS; 1747 addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS; 1748 UnwindLLDB::RegisterLocation regloc = {}; 1749 if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB), 1750 regloc) == 1751 UnwindLLDB::RegisterSearchResult::eRegisterFound) { 1752 const RegisterInfo *reg_info = 1753 GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB)); 1754 if (reg_info) { 1755 RegisterValue reg_value; 1756 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) { 1757 old_caller_pc_value = reg_value.GetAsUInt64(); 1758 if (ProcessSP process_sp = m_thread.GetProcess()) { 1759 if (ABISP abi_sp = process_sp->GetABI()) 1760 old_caller_pc_value = abi_sp->FixCodeAddress(old_caller_pc_value); 1761 } 1762 } 1763 } 1764 } 1765 1766 // This is a tricky wrinkle! If SavedLocationForRegister() detects a really 1767 // impossible register location for the full unwind plan, it may call 1768 // ForceSwitchToFallbackUnwindPlan() which in turn replaces the full 1769 // unwindplan with the fallback... in short, we're done, we're using the 1770 // fallback UnwindPlan. We checked if m_fallback_unwind_plan_sp was nullptr 1771 // at the top -- the only way it became nullptr since then is via 1772 // SavedLocationForRegister(). 1773 if (m_fallback_unwind_plan_sp.get() == nullptr) 1774 return true; 1775 1776 // Switch the full UnwindPlan to be the fallback UnwindPlan. If we decide 1777 // this isn't working, we need to restore. We'll also need to save & restore 1778 // the value of the m_cfa ivar. Save is down below a bit in 'old_cfa'. 1779 UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp; 1780 addr_t old_cfa = m_cfa; 1781 addr_t old_afa = m_afa; 1782 1783 m_registers.clear(); 1784 1785 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp; 1786 1787 UnwindPlan::RowSP active_row = 1788 m_fallback_unwind_plan_sp->GetRowForFunctionOffset( 1789 m_current_offset_backed_up_one); 1790 1791 if (active_row && 1792 active_row->GetCFAValue().GetValueType() != 1793 UnwindPlan::Row::FAValue::unspecified) { 1794 addr_t new_cfa; 1795 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(), 1796 active_row->GetCFAValue(), new_cfa) || 1797 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) { 1798 UnwindLogMsg("failed to get cfa with fallback unwindplan"); 1799 m_fallback_unwind_plan_sp.reset(); 1800 m_full_unwind_plan_sp = original_full_unwind_plan_sp; 1801 return false; 1802 } 1803 m_cfa = new_cfa; 1804 1805 ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(), 1806 active_row->GetAFAValue(), m_afa); 1807 1808 if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB), 1809 regloc) == 1810 UnwindLLDB::RegisterSearchResult::eRegisterFound) { 1811 const RegisterInfo *reg_info = 1812 GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB)); 1813 if (reg_info) { 1814 RegisterValue reg_value; 1815 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, 1816 reg_value)) { 1817 new_caller_pc_value = reg_value.GetAsUInt64(); 1818 if (ProcessSP process_sp = m_thread.GetProcess()) { 1819 if (ABISP abi_sp = process_sp->GetABI()) 1820 new_caller_pc_value = abi_sp->FixCodeAddress(new_caller_pc_value); 1821 } 1822 } 1823 } 1824 } 1825 1826 if (new_caller_pc_value == LLDB_INVALID_ADDRESS) { 1827 UnwindLogMsg("failed to get a pc value for the caller frame with the " 1828 "fallback unwind plan"); 1829 m_fallback_unwind_plan_sp.reset(); 1830 m_full_unwind_plan_sp = original_full_unwind_plan_sp; 1831 m_cfa = old_cfa; 1832 m_afa = old_afa; 1833 return false; 1834 } 1835 1836 if (old_caller_pc_value == new_caller_pc_value && 1837 m_cfa == old_cfa && 1838 m_afa == old_afa) { 1839 UnwindLogMsg("fallback unwind plan got the same values for this frame " 1840 "CFA and caller frame pc, not using"); 1841 m_fallback_unwind_plan_sp.reset(); 1842 m_full_unwind_plan_sp = original_full_unwind_plan_sp; 1843 return false; 1844 } 1845 1846 UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' " 1847 "because UnwindPlan '%s' failed.", 1848 m_fallback_unwind_plan_sp->GetSourceName().GetCString(), 1849 original_full_unwind_plan_sp->GetSourceName().GetCString()); 1850 1851 // We've copied the fallback unwind plan into the full - now clear the 1852 // fallback. 1853 m_fallback_unwind_plan_sp.reset(); 1854 PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp); 1855 } 1856 1857 return true; 1858 } 1859 1860 bool RegisterContextUnwind::ForceSwitchToFallbackUnwindPlan() { 1861 if (m_fallback_unwind_plan_sp.get() == nullptr) 1862 return false; 1863 1864 if (m_full_unwind_plan_sp.get() == nullptr) 1865 return false; 1866 1867 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() || 1868 m_full_unwind_plan_sp->GetSourceName() == 1869 m_fallback_unwind_plan_sp->GetSourceName()) { 1870 return false; 1871 } 1872 1873 UnwindPlan::RowSP active_row = 1874 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); 1875 1876 if (active_row && 1877 active_row->GetCFAValue().GetValueType() != 1878 UnwindPlan::Row::FAValue::unspecified) { 1879 addr_t new_cfa; 1880 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(), 1881 active_row->GetCFAValue(), new_cfa) || 1882 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) { 1883 UnwindLogMsg("failed to get cfa with fallback unwindplan"); 1884 m_fallback_unwind_plan_sp.reset(); 1885 return false; 1886 } 1887 1888 ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(), 1889 active_row->GetAFAValue(), m_afa); 1890 1891 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp; 1892 m_fallback_unwind_plan_sp.reset(); 1893 1894 m_registers.clear(); 1895 1896 m_cfa = new_cfa; 1897 1898 PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp); 1899 1900 UnwindLogMsg("switched unconditionally to the fallback unwindplan %s", 1901 m_full_unwind_plan_sp->GetSourceName().GetCString()); 1902 return true; 1903 } 1904 return false; 1905 } 1906 1907 void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan( 1908 lldb::UnwindPlanSP unwind_plan) { 1909 if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) { 1910 // Unwind plan does not indicate trap handler. Do nothing. We may 1911 // already be flagged as trap handler flag due to the symbol being 1912 // in the trap handler symbol list, and that should take precedence. 1913 return; 1914 } else if (m_frame_type != eNormalFrame) { 1915 // If this is already a trap handler frame, nothing to do. 1916 // If this is a skip or debug or invalid frame, don't override that. 1917 return; 1918 } 1919 1920 m_frame_type = eTrapHandlerFrame; 1921 1922 if (m_current_offset_backed_up_one != m_current_offset) { 1923 // We backed up the pc by 1 to compute the symbol context, but 1924 // now need to undo that because the pc of the trap handler 1925 // frame may in fact be the first instruction of a signal return 1926 // trampoline, rather than the instruction after a call. This 1927 // happens on systems where the signal handler dispatch code, rather 1928 // than calling the handler and being returned to, jumps to the 1929 // handler after pushing the address of a return trampoline on the 1930 // stack -- on these systems, when the handler returns, control will 1931 // be transferred to the return trampoline, so that's the best 1932 // symbol we can present in the callstack. 1933 UnwindLogMsg("Resetting current offset and re-doing symbol lookup; " 1934 "old symbol was %s", 1935 GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 1936 m_current_offset_backed_up_one = m_current_offset; 1937 1938 AddressRange addr_range; 1939 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range); 1940 1941 UnwindLogMsg("Symbol is now %s", 1942 GetSymbolOrFunctionName(m_sym_ctx).AsCString("")); 1943 1944 ExecutionContext exe_ctx(m_thread.shared_from_this()); 1945 Process *process = exe_ctx.GetProcessPtr(); 1946 Target *target = &process->GetTarget(); 1947 1948 m_start_pc = addr_range.GetBaseAddress(); 1949 m_current_offset = 1950 m_current_pc.GetLoadAddress(target) - m_start_pc.GetLoadAddress(target); 1951 } 1952 } 1953 1954 bool RegisterContextUnwind::ReadFrameAddress( 1955 lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa, 1956 addr_t &address) { 1957 RegisterValue reg_value; 1958 1959 address = LLDB_INVALID_ADDRESS; 1960 addr_t cfa_reg_contents; 1961 ABISP abi_sp = m_thread.GetProcess()->GetABI(); 1962 1963 switch (fa.GetValueType()) { 1964 case UnwindPlan::Row::FAValue::isRegisterDereferenced: { 1965 RegisterNumber cfa_reg(m_thread, row_register_kind, 1966 fa.GetRegisterNumber()); 1967 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) { 1968 const RegisterInfo *reg_info = 1969 GetRegisterInfoAtIndex(cfa_reg.GetAsKind(eRegisterKindLLDB)); 1970 RegisterValue reg_value; 1971 if (reg_info) { 1972 if (abi_sp) 1973 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents); 1974 Status error = ReadRegisterValueFromMemory( 1975 reg_info, cfa_reg_contents, reg_info->byte_size, reg_value); 1976 if (error.Success()) { 1977 address = reg_value.GetAsUInt64(); 1978 if (abi_sp) 1979 address = abi_sp->FixCodeAddress(address); 1980 UnwindLogMsg( 1981 "CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64 1982 ", CFA value is 0x%" PRIx64, 1983 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB), 1984 cfa_reg_contents, address); 1985 return true; 1986 } else { 1987 UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64 1988 "] but memory read failed.", 1989 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB), 1990 cfa_reg_contents); 1991 } 1992 } 1993 } 1994 break; 1995 } 1996 case UnwindPlan::Row::FAValue::isRegisterPlusOffset: { 1997 RegisterNumber cfa_reg(m_thread, row_register_kind, 1998 fa.GetRegisterNumber()); 1999 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) { 2000 if (abi_sp) 2001 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents); 2002 if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 || 2003 cfa_reg_contents == 1) { 2004 UnwindLogMsg( 2005 "Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64, 2006 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB), 2007 cfa_reg_contents); 2008 cfa_reg_contents = LLDB_INVALID_ADDRESS; 2009 return false; 2010 } 2011 address = cfa_reg_contents + fa.GetOffset(); 2012 UnwindLogMsg( 2013 "CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64 2014 ", offset is %d", 2015 address, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB), 2016 cfa_reg_contents, fa.GetOffset()); 2017 return true; 2018 } 2019 break; 2020 } 2021 case UnwindPlan::Row::FAValue::isDWARFExpression: { 2022 ExecutionContext exe_ctx(m_thread.shared_from_this()); 2023 Process *process = exe_ctx.GetProcessPtr(); 2024 DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(), 2025 fa.GetDWARFExpressionLength(), 2026 process->GetByteOrder(), 2027 process->GetAddressByteSize()); 2028 ModuleSP opcode_ctx; 2029 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr); 2030 dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind( 2031 row_register_kind); 2032 Value result; 2033 Status error; 2034 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result, 2035 &error)) { 2036 address = result.GetScalar().ULongLong(); 2037 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) 2038 address = abi_sp->FixCodeAddress(address); 2039 2040 UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64, 2041 address); 2042 return true; 2043 } 2044 UnwindLogMsg("Failed to set CFA value via DWARF expression: %s", 2045 error.AsCString()); 2046 break; 2047 } 2048 case UnwindPlan::Row::FAValue::isRaSearch: { 2049 Process &process = *m_thread.GetProcess(); 2050 lldb::addr_t return_address_hint = GetReturnAddressHint(fa.GetOffset()); 2051 if (return_address_hint == LLDB_INVALID_ADDRESS) 2052 return false; 2053 const unsigned max_iterations = 256; 2054 for (unsigned i = 0; i < max_iterations; ++i) { 2055 Status st; 2056 lldb::addr_t candidate_addr = 2057 return_address_hint + i * process.GetAddressByteSize(); 2058 lldb::addr_t candidate = 2059 process.ReadPointerFromMemory(candidate_addr, st); 2060 if (st.Fail()) { 2061 UnwindLogMsg("Cannot read memory at 0x%" PRIx64 ": %s", candidate_addr, 2062 st.AsCString()); 2063 return false; 2064 } 2065 Address addr; 2066 uint32_t permissions; 2067 if (process.GetLoadAddressPermissions(candidate, permissions) && 2068 permissions & lldb::ePermissionsExecutable) { 2069 address = candidate_addr; 2070 UnwindLogMsg("Heuristically found CFA: 0x%" PRIx64, address); 2071 return true; 2072 } 2073 } 2074 UnwindLogMsg("No suitable CFA found"); 2075 break; 2076 } 2077 default: 2078 return false; 2079 } 2080 return false; 2081 } 2082 2083 lldb::addr_t RegisterContextUnwind::GetReturnAddressHint(int32_t plan_offset) { 2084 addr_t hint; 2085 if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, hint)) 2086 return LLDB_INVALID_ADDRESS; 2087 if (!m_sym_ctx.module_sp || !m_sym_ctx.symbol) 2088 return LLDB_INVALID_ADDRESS; 2089 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) 2090 hint = abi_sp->FixCodeAddress(hint); 2091 2092 hint += plan_offset; 2093 2094 if (auto next = GetNextFrame()) { 2095 if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol) 2096 return LLDB_INVALID_ADDRESS; 2097 if (auto expected_size = 2098 next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize( 2099 *next->m_sym_ctx.symbol)) 2100 hint += *expected_size; 2101 else { 2102 UnwindLogMsgVerbose("Could not retrieve parameter size: %s", 2103 llvm::toString(expected_size.takeError()).c_str()); 2104 return LLDB_INVALID_ADDRESS; 2105 } 2106 } 2107 return hint; 2108 } 2109 2110 // Retrieve a general purpose register value for THIS frame, as saved by the 2111 // NEXT frame, i.e. the frame that 2112 // this frame called. e.g. 2113 // 2114 // foo () { } 2115 // bar () { foo (); } 2116 // main () { bar (); } 2117 // 2118 // stopped in foo() so 2119 // frame 0 - foo 2120 // frame 1 - bar 2121 // frame 2 - main 2122 // and this RegisterContext is for frame 1 (bar) - if we want to get the pc 2123 // value for frame 1, we need to ask 2124 // where frame 0 (the "next" frame) saved that and retrieve the value. 2125 2126 bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind, 2127 uint32_t regnum, addr_t &value) { 2128 if (!IsValid()) 2129 return false; 2130 2131 uint32_t lldb_regnum; 2132 if (register_kind == eRegisterKindLLDB) { 2133 lldb_regnum = regnum; 2134 } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds( 2135 register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) { 2136 return false; 2137 } 2138 2139 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum); 2140 assert(reg_info); 2141 if (!reg_info) { 2142 UnwindLogMsg( 2143 "Could not find RegisterInfo definition for lldb register number %d", 2144 lldb_regnum); 2145 return false; 2146 } 2147 2148 uint32_t generic_regnum = LLDB_INVALID_REGNUM; 2149 if (register_kind == eRegisterKindGeneric) 2150 generic_regnum = regnum; 2151 else 2152 m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds( 2153 register_kind, regnum, eRegisterKindGeneric, generic_regnum); 2154 ABISP abi_sp = m_thread.GetProcess()->GetABI(); 2155 2156 RegisterValue reg_value; 2157 // if this is frame 0 (currently executing frame), get the requested reg 2158 // contents from the actual thread registers 2159 if (IsFrameZero()) { 2160 if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) { 2161 value = reg_value.GetAsUInt64(); 2162 if (abi_sp && generic_regnum != LLDB_INVALID_REGNUM) { 2163 if (generic_regnum == LLDB_REGNUM_GENERIC_PC || 2164 generic_regnum == LLDB_REGNUM_GENERIC_RA) 2165 value = abi_sp->FixCodeAddress(value); 2166 if (generic_regnum == LLDB_REGNUM_GENERIC_SP || 2167 generic_regnum == LLDB_REGNUM_GENERIC_FP) 2168 value = abi_sp->FixDataAddress(value); 2169 } 2170 return true; 2171 } 2172 return false; 2173 } 2174 2175 bool pc_register = false; 2176 if (generic_regnum != LLDB_INVALID_REGNUM && 2177 (generic_regnum == LLDB_REGNUM_GENERIC_PC || 2178 generic_regnum == LLDB_REGNUM_GENERIC_RA)) 2179 pc_register = true; 2180 2181 lldb_private::UnwindLLDB::RegisterLocation regloc; 2182 if (!m_parent_unwind.SearchForSavedLocationForRegister( 2183 lldb_regnum, regloc, m_frame_number - 1, pc_register)) { 2184 return false; 2185 } 2186 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) { 2187 value = reg_value.GetAsUInt64(); 2188 if (pc_register) { 2189 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) { 2190 value = abi_sp->FixCodeAddress(value); 2191 } 2192 } 2193 return true; 2194 } 2195 return false; 2196 } 2197 2198 bool RegisterContextUnwind::ReadGPRValue(const RegisterNumber ®num, 2199 addr_t &value) { 2200 return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(), 2201 value); 2202 } 2203 2204 // Find the value of a register in THIS frame 2205 2206 bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info, 2207 RegisterValue &value) { 2208 if (!IsValid()) 2209 return false; 2210 2211 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB]; 2212 UnwindLogMsgVerbose("looking for register saved location for reg %d", 2213 lldb_regnum); 2214 2215 // If this is the 0th frame, hand this over to the live register context 2216 if (IsFrameZero()) { 2217 UnwindLogMsgVerbose("passing along to the live register context for reg %d", 2218 lldb_regnum); 2219 return m_thread.GetRegisterContext()->ReadRegister(reg_info, value); 2220 } 2221 2222 bool is_pc_regnum = false; 2223 if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC || 2224 reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA) { 2225 is_pc_regnum = true; 2226 } 2227 2228 lldb_private::UnwindLLDB::RegisterLocation regloc; 2229 // Find out where the NEXT frame saved THIS frame's register contents 2230 if (!m_parent_unwind.SearchForSavedLocationForRegister( 2231 lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum)) 2232 return false; 2233 2234 bool result = ReadRegisterValueFromRegisterLocation(regloc, reg_info, value); 2235 if (result) { 2236 if (is_pc_regnum && value.GetType() == RegisterValue::eTypeUInt64) { 2237 addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS); 2238 if (reg_value != LLDB_INVALID_ADDRESS) { 2239 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) 2240 value = abi_sp->FixCodeAddress(reg_value); 2241 } 2242 } 2243 } 2244 return result; 2245 } 2246 2247 bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info, 2248 const RegisterValue &value) { 2249 if (!IsValid()) 2250 return false; 2251 2252 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB]; 2253 UnwindLogMsgVerbose("looking for register saved location for reg %d", 2254 lldb_regnum); 2255 2256 // If this is the 0th frame, hand this over to the live register context 2257 if (IsFrameZero()) { 2258 UnwindLogMsgVerbose("passing along to the live register context for reg %d", 2259 lldb_regnum); 2260 return m_thread.GetRegisterContext()->WriteRegister(reg_info, value); 2261 } 2262 2263 lldb_private::UnwindLLDB::RegisterLocation regloc; 2264 // Find out where the NEXT frame saved THIS frame's register contents 2265 if (!m_parent_unwind.SearchForSavedLocationForRegister( 2266 lldb_regnum, regloc, m_frame_number - 1, false)) 2267 return false; 2268 2269 return WriteRegisterValueToRegisterLocation(regloc, reg_info, value); 2270 } 2271 2272 // Don't need to implement this one 2273 bool RegisterContextUnwind::ReadAllRegisterValues( 2274 lldb::WritableDataBufferSP &data_sp) { 2275 return false; 2276 } 2277 2278 // Don't need to implement this one 2279 bool RegisterContextUnwind::WriteAllRegisterValues( 2280 const lldb::DataBufferSP &data_sp) { 2281 return false; 2282 } 2283 2284 // Retrieve the pc value for THIS from 2285 2286 bool RegisterContextUnwind::GetCFA(addr_t &cfa) { 2287 if (!IsValid()) { 2288 return false; 2289 } 2290 if (m_cfa == LLDB_INVALID_ADDRESS) { 2291 return false; 2292 } 2293 cfa = m_cfa; 2294 return true; 2295 } 2296 2297 RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetNextFrame() const { 2298 RegisterContextUnwind::SharedPtr regctx; 2299 if (m_frame_number == 0) 2300 return regctx; 2301 return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number - 1); 2302 } 2303 2304 RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetPrevFrame() const { 2305 RegisterContextUnwind::SharedPtr regctx; 2306 return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number + 1); 2307 } 2308 2309 // Retrieve the address of the start of the function of THIS frame 2310 2311 bool RegisterContextUnwind::GetStartPC(addr_t &start_pc) { 2312 if (!IsValid()) 2313 return false; 2314 2315 if (!m_start_pc.IsValid()) { 2316 bool read_successfully = ReadPC (start_pc); 2317 if (read_successfully) 2318 { 2319 ProcessSP process_sp (m_thread.GetProcess()); 2320 if (process_sp) 2321 { 2322 if (ABISP abi_sp = process_sp->GetABI()) 2323 start_pc = abi_sp->FixCodeAddress(start_pc); 2324 } 2325 } 2326 return read_successfully; 2327 } 2328 start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get()); 2329 return true; 2330 } 2331 2332 // Retrieve the current pc value for THIS frame, as saved by the NEXT frame. 2333 2334 bool RegisterContextUnwind::ReadPC(addr_t &pc) { 2335 if (!IsValid()) 2336 return false; 2337 2338 bool above_trap_handler = false; 2339 if (GetNextFrame().get() && GetNextFrame()->IsValid() && 2340 GetNextFrame()->IsTrapHandlerFrame()) 2341 above_trap_handler = true; 2342 2343 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) { 2344 // A pc value of 0 or 1 is impossible in the middle of the stack -- it 2345 // indicates the end of a stack walk. 2346 // On the currently executing frame (or such a frame interrupted 2347 // asynchronously by sigtramp et al) this may occur if code has jumped 2348 // through a NULL pointer -- we want to be able to unwind past that frame 2349 // to help find the bug. 2350 2351 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) 2352 pc = abi_sp->FixCodeAddress(pc); 2353 2354 return !(m_all_registers_available == false && 2355 above_trap_handler == false && (pc == 0 || pc == 1)); 2356 } else { 2357 return false; 2358 } 2359 } 2360 2361 void RegisterContextUnwind::UnwindLogMsg(const char *fmt, ...) { 2362 Log *log = GetLog(LLDBLog::Unwind); 2363 if (!log) 2364 return; 2365 2366 va_list args; 2367 va_start(args, fmt); 2368 2369 llvm::SmallString<0> logmsg; 2370 if (VASprintf(logmsg, fmt, args)) { 2371 LLDB_LOGF(log, "%*sth%d/fr%u %s", 2372 m_frame_number < 100 ? m_frame_number : 100, "", 2373 m_thread.GetIndexID(), m_frame_number, logmsg.c_str()); 2374 } 2375 va_end(args); 2376 } 2377 2378 void RegisterContextUnwind::UnwindLogMsgVerbose(const char *fmt, ...) { 2379 Log *log = GetLog(LLDBLog::Unwind); 2380 if (!log || !log->GetVerbose()) 2381 return; 2382 2383 va_list args; 2384 va_start(args, fmt); 2385 2386 llvm::SmallString<0> logmsg; 2387 if (VASprintf(logmsg, fmt, args)) { 2388 LLDB_LOGF(log, "%*sth%d/fr%u %s", 2389 m_frame_number < 100 ? m_frame_number : 100, "", 2390 m_thread.GetIndexID(), m_frame_number, logmsg.c_str()); 2391 } 2392 va_end(args); 2393 } 2394