3336d73126
lldb has two RegisterLocation classes that do slightly different things. UnwindPlan::Row::RegisterLocation (new: AbstractRegisterLocation) has a description of how to find a register's value or location, not specific to a particular stopping point. It may say that at a given offset into a function, the caller's register has been spilled to stack memory at CFA minus an offset. Or it may say that the caller's register is at a DWARF exprssion. UnwindLLDB::RegisterLocation (new: ConcreteRegisterLocation) is a specific address where the register is currently stored, or the register it has been copied into, or its value at this point in the current function execution. When lldb stops in a function, it interprets the AbstractRegisterLocation's instructions using the register context and stack memory, to create the ConcreteRegisterLocation at this point in time for this stack frame. I'm not thrilled with AbstractRegisterLocation and ConcreteRegisterLocation, but it's better than the same name and it will be easier to update them if someone suggests a better pair.
528 lines
19 KiB
C++
528 lines
19 KiB
C++
//===-- UnwindLLDB.cpp ----------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Target/UnwindLLDB.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Symbol/FuncUnwinders.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Symbol/UnwindPlan.h"
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/RegisterContextUnwind.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/Log.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
UnwindLLDB::UnwindLLDB(Thread &thread)
|
|
: Unwind(thread), m_frames(), m_unwind_complete(false),
|
|
m_user_supplied_trap_handler_functions() {
|
|
ProcessSP process_sp(thread.GetProcess());
|
|
if (process_sp) {
|
|
Args args;
|
|
process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames(args);
|
|
size_t count = args.GetArgumentCount();
|
|
for (size_t i = 0; i < count; i++) {
|
|
const char *func_name = args.GetArgumentAtIndex(i);
|
|
m_user_supplied_trap_handler_functions.push_back(ConstString(func_name));
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t UnwindLLDB::DoGetFrameCount() {
|
|
if (!m_unwind_complete) {
|
|
//#define DEBUG_FRAME_SPEED 1
|
|
#if DEBUG_FRAME_SPEED
|
|
#define FRAME_COUNT 10000
|
|
using namespace std::chrono;
|
|
auto time_value = steady_clock::now();
|
|
#endif
|
|
if (!AddFirstFrame())
|
|
return 0;
|
|
|
|
ProcessSP process_sp(m_thread.GetProcess());
|
|
ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
|
|
|
|
while (AddOneMoreFrame(abi)) {
|
|
#if DEBUG_FRAME_SPEED
|
|
if ((m_frames.size() % FRAME_COUNT) == 0) {
|
|
const auto now = steady_clock::now();
|
|
const auto delta_t = now - time_value;
|
|
printf("%u frames in %.9f ms (%g frames/sec)\n", FRAME_COUNT,
|
|
duration<double, std::milli>(delta_t).count(),
|
|
(float)FRAME_COUNT / duration<double>(delta_t).count());
|
|
time_value = now;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
return m_frames.size();
|
|
}
|
|
|
|
bool UnwindLLDB::AddFirstFrame() {
|
|
if (m_frames.size() > 0)
|
|
return true;
|
|
|
|
ProcessSP process_sp(m_thread.GetProcess());
|
|
ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
|
|
|
|
// First, set up the 0th (initial) frame
|
|
CursorSP first_cursor_sp(new Cursor());
|
|
RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
|
|
m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
|
|
if (reg_ctx_sp.get() == nullptr)
|
|
goto unwind_done;
|
|
|
|
if (!reg_ctx_sp->IsValid())
|
|
goto unwind_done;
|
|
|
|
if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
|
|
goto unwind_done;
|
|
|
|
if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
|
|
goto unwind_done;
|
|
|
|
// Everything checks out, so release the auto pointer value and let the
|
|
// cursor own it in its shared pointer
|
|
first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
|
|
m_frames.push_back(first_cursor_sp);
|
|
|
|
// Update the Full Unwind Plan for this frame if not valid
|
|
UpdateUnwindPlanForFirstFrameIfInvalid(abi);
|
|
|
|
return true;
|
|
|
|
unwind_done:
|
|
Log *log = GetLog(LLDBLog::Unwind);
|
|
if (log) {
|
|
LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
|
|
m_thread.GetIndexID());
|
|
}
|
|
m_unwind_complete = true;
|
|
return false;
|
|
}
|
|
|
|
UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) {
|
|
assert(m_frames.size() != 0 &&
|
|
"Get one more frame called with empty frame list");
|
|
|
|
// If we've already gotten to the end of the stack, don't bother to try
|
|
// again...
|
|
if (m_unwind_complete)
|
|
return nullptr;
|
|
|
|
Log *log = GetLog(LLDBLog::Unwind);
|
|
|
|
CursorSP prev_frame = m_frames.back();
|
|
uint32_t cur_idx = m_frames.size();
|
|
|
|
CursorSP cursor_sp(new Cursor());
|
|
RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
|
|
m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
|
|
|
|
uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth();
|
|
|
|
// We want to detect an unwind that cycles erroneously and stop backtracing.
|
|
// Don't want this maximum unwind limit to be too low -- if you have a
|
|
// backtrace with an "infinitely recursing" bug, it will crash when the stack
|
|
// blows out and the first 35,000 frames are uninteresting - it's the top
|
|
// most 5 frames that you actually care about. So you can't just cap the
|
|
// unwind at 10,000 or something. Realistically anything over around 200,000
|
|
// is going to blow out the stack space. If we're still unwinding at that
|
|
// point, we're probably never going to finish.
|
|
if (cur_idx >= max_stack_depth) {
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d unwound too many frames, assuming unwind has "
|
|
"gone astray, stopping.",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
|
|
if (reg_ctx_sp.get() == nullptr) {
|
|
// If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
|
|
// that and return true. Subsequent calls to TryFallbackUnwindPlan() will
|
|
// return false.
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
|
|
// still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log, "%*sFrame %d did not get a RegisterContext, stopping.",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
|
|
if (!reg_ctx_sp->IsValid()) {
|
|
// We failed to get a valid RegisterContext. See if the regctx below this
|
|
// on the stack has a fallback unwind plan it can use. Subsequent calls to
|
|
// TryFallbackUnwindPlan() will return false.
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
|
|
// still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d invalid RegisterContext for this frame, "
|
|
"stopping stack walk",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
|
|
// If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
|
|
// that and return true. Subsequent calls to TryFallbackUnwindPlan() will
|
|
// return false.
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
|
|
// still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d did not get CFA for this frame, stopping stack walk",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
|
|
// On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
|
|
// have its (constructed) CFA aligned correctly -- don't do the abi
|
|
// alignment check for these.
|
|
if (!reg_ctx_sp->IsTrapHandlerFrame()) {
|
|
// See if we can find a fallback unwind plan for THIS frame. It may be
|
|
// that the UnwindPlan we're using for THIS frame was bad and gave us a
|
|
// bad CFA. If that's not it, then see if we can change the UnwindPlan
|
|
// for the frame below us ("NEXT") -- see if using that other UnwindPlan
|
|
// gets us a better unwind state.
|
|
if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
|
|
!reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
|
|
!abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of
|
|
// prev_frame still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d did not get a valid CFA for this frame, "
|
|
"stopping stack walk",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
} else {
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d had a bad CFA value but we switched the "
|
|
"UnwindPlan being used and got one that looks more "
|
|
"realistic.",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
}
|
|
}
|
|
}
|
|
if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
|
|
// If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
|
|
// that and return true. Subsequent calls to TryFallbackUnwindPlan() will
|
|
// return false.
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
|
|
// still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log,
|
|
"%*sFrame %d did not get PC for this frame, stopping stack walk",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
|
|
// Invalid code addresses should not appear on the stack *unless* we're
|
|
// directly below a trap handler frame (in this case, the invalid address is
|
|
// likely the cause of the trap).
|
|
if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc) &&
|
|
!prev_frame->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
|
|
// If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
|
|
// that and return true. Subsequent calls to TryFallbackUnwindPlan() will
|
|
// return false.
|
|
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// TryFallbackUnwindPlan for prev_frame succeeded and updated
|
|
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
|
|
// still needs to be updated. Hence updating it.
|
|
if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
|
|
return nullptr;
|
|
|
|
return GetOneMoreFrame(abi);
|
|
}
|
|
|
|
LLDB_LOGF(log, "%*sFrame %d did not get a valid PC, stopping stack walk",
|
|
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
|
|
return nullptr;
|
|
}
|
|
// Infinite loop where the current cursor is the same as the previous one...
|
|
if (prev_frame->start_pc == cursor_sp->start_pc &&
|
|
prev_frame->cfa == cursor_sp->cfa) {
|
|
LLDB_LOGF(log,
|
|
"th%d pc of this frame is the same as the previous frame and "
|
|
"CFAs for both frames are identical -- stopping unwind",
|
|
m_thread.GetIndexID());
|
|
return nullptr;
|
|
}
|
|
|
|
cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
|
|
return cursor_sp;
|
|
}
|
|
|
|
void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) {
|
|
// This function is called for First Frame only.
|
|
assert(m_frames.size() == 1 && "No. of cursor frames are not 1");
|
|
|
|
bool old_m_unwind_complete = m_unwind_complete;
|
|
CursorSP old_m_candidate_frame = m_candidate_frame;
|
|
|
|
// Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
|
|
// and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update
|
|
// the cfa of Frame 0 (if required).
|
|
AddOneMoreFrame(abi);
|
|
|
|
// Remove all the frames added by above function as the purpose of using
|
|
// above function was just to check whether Unwinder of Frame 0 works or not.
|
|
for (uint32_t i = 1; i < m_frames.size(); i++)
|
|
m_frames.pop_back();
|
|
|
|
// Restore status after calling AddOneMoreFrame
|
|
m_unwind_complete = old_m_unwind_complete;
|
|
m_candidate_frame = old_m_candidate_frame;
|
|
}
|
|
|
|
bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
|
|
Log *log = GetLog(LLDBLog::Unwind);
|
|
|
|
// Frame zero is a little different
|
|
if (m_frames.empty())
|
|
return false;
|
|
|
|
// If we've already gotten to the end of the stack, don't bother to try
|
|
// again...
|
|
if (m_unwind_complete)
|
|
return false;
|
|
|
|
CursorSP new_frame = m_candidate_frame;
|
|
if (new_frame == nullptr)
|
|
new_frame = GetOneMoreFrame(abi);
|
|
|
|
if (new_frame == nullptr) {
|
|
LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
|
|
m_thread.GetIndexID());
|
|
m_unwind_complete = true;
|
|
return false;
|
|
}
|
|
|
|
m_frames.push_back(new_frame);
|
|
|
|
// If we can get one more frame further then accept that we get back a
|
|
// correct frame.
|
|
m_candidate_frame = GetOneMoreFrame(abi);
|
|
if (m_candidate_frame)
|
|
return true;
|
|
|
|
// We can't go further from the frame returned by GetOneMore frame. Lets try
|
|
// to get a different frame with using the fallback unwind plan.
|
|
if (!m_frames[m_frames.size() - 2]
|
|
->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
|
|
// We don't have a valid fallback unwind plan. Accept the frame as it is.
|
|
// This is a valid situation when we are at the bottom of the stack.
|
|
return true;
|
|
}
|
|
|
|
// Remove the possibly incorrect frame from the frame list and try to add a
|
|
// different one with the newly selected fallback unwind plan.
|
|
m_frames.pop_back();
|
|
CursorSP new_frame_v2 = GetOneMoreFrame(abi);
|
|
if (new_frame_v2 == nullptr) {
|
|
// We haven't got a new frame from the fallback unwind plan. Accept the
|
|
// frame from the original unwind plan. This is a valid situation when we
|
|
// are at the bottom of the stack.
|
|
m_frames.push_back(new_frame);
|
|
return true;
|
|
}
|
|
|
|
// Push the new frame to the list and try to continue from this frame. If we
|
|
// can get a new frame then accept it as the correct one.
|
|
m_frames.push_back(new_frame_v2);
|
|
m_candidate_frame = GetOneMoreFrame(abi);
|
|
if (m_candidate_frame) {
|
|
// If control reached here then TryFallbackUnwindPlan had succeeded for
|
|
// Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next
|
|
// 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For
|
|
// Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already
|
|
// updated during TryFallbackUnwindPlan call above. However, cfa field
|
|
// still needs to be updated. Hence updating it here and then returning.
|
|
return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
|
|
m_frames[m_frames.size() - 2]->cfa);
|
|
}
|
|
|
|
// The new frame hasn't helped in unwinding. Fall back to the original one as
|
|
// the default unwind plan is usually more reliable then the fallback one.
|
|
m_frames.pop_back();
|
|
m_frames.push_back(new_frame);
|
|
return true;
|
|
}
|
|
|
|
bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc,
|
|
bool &behaves_like_zeroth_frame) {
|
|
if (m_frames.size() == 0) {
|
|
if (!AddFirstFrame())
|
|
return false;
|
|
}
|
|
|
|
ProcessSP process_sp(m_thread.GetProcess());
|
|
ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
|
|
|
|
while (idx >= m_frames.size() && AddOneMoreFrame(abi))
|
|
;
|
|
|
|
if (idx < m_frames.size()) {
|
|
cfa = m_frames[idx]->cfa;
|
|
pc = m_frames[idx]->start_pc;
|
|
if (idx == 0) {
|
|
// Frame zero always behaves like it.
|
|
behaves_like_zeroth_frame = true;
|
|
} else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
|
|
// This could be an asynchronous signal, thus the
|
|
// pc might point to the interrupted instruction rather
|
|
// than a post-call instruction
|
|
behaves_like_zeroth_frame = true;
|
|
} else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
|
|
// This frame may result from signal processing installing
|
|
// a pointer to the first byte of a signal-return trampoline
|
|
// in the return address slot of the frame below, so this
|
|
// too behaves like the zeroth frame (i.e. the pc might not
|
|
// be pointing just past a call in it)
|
|
behaves_like_zeroth_frame = true;
|
|
} else if (m_frames[idx]->reg_ctx_lldb_sp->BehavesLikeZerothFrame()) {
|
|
behaves_like_zeroth_frame = true;
|
|
} else {
|
|
behaves_like_zeroth_frame = false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::RegisterContextSP
|
|
UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
|
|
lldb::RegisterContextSP reg_ctx_sp;
|
|
uint32_t idx = frame->GetConcreteFrameIndex();
|
|
|
|
if (idx == 0) {
|
|
return m_thread.GetRegisterContext();
|
|
}
|
|
|
|
if (m_frames.size() == 0) {
|
|
if (!AddFirstFrame())
|
|
return reg_ctx_sp;
|
|
}
|
|
|
|
ProcessSP process_sp(m_thread.GetProcess());
|
|
ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
|
|
|
|
while (idx >= m_frames.size()) {
|
|
if (!AddOneMoreFrame(abi))
|
|
break;
|
|
}
|
|
|
|
const uint32_t num_frames = m_frames.size();
|
|
if (idx < num_frames) {
|
|
Cursor *frame_cursor = m_frames[idx].get();
|
|
reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
|
|
}
|
|
return reg_ctx_sp;
|
|
}
|
|
|
|
UnwindLLDB::RegisterContextLLDBSP
|
|
UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) {
|
|
RegisterContextLLDBSP reg_ctx_sp;
|
|
if (frame_num < m_frames.size())
|
|
reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
|
|
return reg_ctx_sp;
|
|
}
|
|
|
|
bool UnwindLLDB::SearchForSavedLocationForRegister(
|
|
uint32_t lldb_regnum,
|
|
lldb_private::UnwindLLDB::ConcreteRegisterLocation ®loc,
|
|
uint32_t starting_frame_num, bool pc_reg) {
|
|
int64_t frame_num = starting_frame_num;
|
|
if (static_cast<size_t>(frame_num) >= m_frames.size())
|
|
return false;
|
|
|
|
// Never interrogate more than one level while looking for the saved pc
|
|
// value. If the value isn't saved by frame_num, none of the frames lower on
|
|
// the stack will have a useful value.
|
|
if (pc_reg) {
|
|
UnwindLLDB::RegisterSearchResult result;
|
|
result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
|
|
lldb_regnum, regloc);
|
|
return result == UnwindLLDB::RegisterSearchResult::eRegisterFound;
|
|
}
|
|
while (frame_num >= 0) {
|
|
UnwindLLDB::RegisterSearchResult result;
|
|
result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
|
|
lldb_regnum, regloc);
|
|
|
|
// We descended down to the live register context aka stack frame 0 and are
|
|
// reading the value out of a live register.
|
|
if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
|
|
regloc.type == UnwindLLDB::ConcreteRegisterLocation::
|
|
eRegisterInLiveRegisterContext) {
|
|
return true;
|
|
}
|
|
|
|
// If we have unwind instructions saying that register N is saved in
|
|
// register M in the middle of the stack (and N can equal M here, meaning
|
|
// the register was not used in this function), then change the register
|
|
// number we're looking for to M and keep looking for a concrete location
|
|
// down the stack, or an actual value from a live RegisterContext at frame
|
|
// 0.
|
|
if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
|
|
regloc.type ==
|
|
UnwindLLDB::ConcreteRegisterLocation::eRegisterInRegister &&
|
|
frame_num > 0) {
|
|
result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
|
|
lldb_regnum = regloc.location.register_number;
|
|
}
|
|
|
|
if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
|
|
return true;
|
|
if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)
|
|
return false;
|
|
frame_num--;
|
|
}
|
|
return false;
|
|
}
|