9da7bd0739
complex inlined examples.
StackFrame classes don't have a "GetPC" anymore, they have "GetFrameCodeAddress()".
This is because inlined frames will have a PC value that is the same as the
concrete frame that owns the inlined frame, yet the code locations for the
frame can be different. We also need to be able to get the real PC value for
a given frame so that variables evaluate correctly. To get the actual PC
value for a frame you can use:
addr_t pc = frame->GetRegisterContext()->GetPC();
Some issues with the StackFrame stomping on its own symbol context were
resolved which were causing the information to change for a frame when the
stack ID was calculated. Also the StackFrame will now correctly store the
symbol context resolve flags for any extra bits of information that were
looked up (if you ask for a block only and you find one, you will alwasy have
the compile unit and function).
llvm-svn: 111964
244 lines
8.0 KiB
C++
244 lines
8.0 KiB
C++
//===-- UnwindMacOSXFrameBackchain.cpp --------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
#include "RegisterContextMacOSXFrameBackchain.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
UnwindMacOSXFrameBackchain::UnwindMacOSXFrameBackchain (Thread &thread) :
|
|
Unwind (thread),
|
|
m_cursors()
|
|
{
|
|
}
|
|
|
|
uint32_t
|
|
UnwindMacOSXFrameBackchain::GetFrameCount()
|
|
{
|
|
if (m_cursors.empty())
|
|
{
|
|
const ArchSpec target_arch (m_thread.GetProcess().GetTarget().GetArchitecture ());
|
|
// Frame zero should always be supplied by the thread...
|
|
StackFrameSP frame_sp (m_thread.GetStackFrameAtIndex (0));
|
|
if (target_arch == ArchSpec("x86_64"))
|
|
GetStackFrameData_x86_64 (frame_sp.get());
|
|
else if (target_arch == ArchSpec("i386"))
|
|
GetStackFrameData_i386 (frame_sp.get());
|
|
|
|
}
|
|
return m_cursors.size();
|
|
}
|
|
|
|
bool
|
|
UnwindMacOSXFrameBackchain::GetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc)
|
|
{
|
|
const uint32_t frame_count = GetFrameCount();
|
|
if (idx < frame_count)
|
|
{
|
|
if (m_cursors[idx].pc == LLDB_INVALID_ADDRESS)
|
|
return false;
|
|
if (m_cursors[idx].fp == LLDB_INVALID_ADDRESS)
|
|
return false;
|
|
|
|
pc = m_cursors[idx].pc;
|
|
cfa = m_cursors[idx].fp;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
RegisterContext *
|
|
UnwindMacOSXFrameBackchain::CreateRegisterContextForFrame (StackFrame *frame)
|
|
{
|
|
uint32_t idx = frame->GetConcreteFrameIndex ();
|
|
const uint32_t frame_count = GetFrameCount();
|
|
if (idx < frame_count)
|
|
return new RegisterContextMacOSXFrameBackchain (m_thread, frame, m_cursors[idx]);
|
|
return NULL;
|
|
}
|
|
|
|
size_t
|
|
UnwindMacOSXFrameBackchain::GetStackFrameData_i386 (StackFrame *first_frame)
|
|
{
|
|
m_cursors.clear();
|
|
|
|
std::pair<lldb::addr_t, lldb::addr_t> fp_pc_pair;
|
|
|
|
struct Frame_i386
|
|
{
|
|
uint32_t fp;
|
|
uint32_t pc;
|
|
};
|
|
|
|
RegisterContext *reg_ctx = m_thread.GetRegisterContext();
|
|
assert (reg_ctx);
|
|
|
|
Cursor cursor;
|
|
cursor.pc = reg_ctx->GetPC (LLDB_INVALID_ADDRESS);
|
|
cursor.fp = reg_ctx->GetFP (0);
|
|
|
|
Frame_i386 frame = { cursor.fp, cursor.pc };
|
|
|
|
m_cursors.push_back(cursor);
|
|
|
|
const size_t k_frame_size = sizeof(frame);
|
|
Error error;
|
|
while (frame.fp != 0 && frame.pc != 0 && ((frame.fp & 7) == 0))
|
|
{
|
|
// Read both the FP and PC (8 bytes)
|
|
if (m_thread.GetProcess().ReadMemory (frame.fp, &frame.fp, k_frame_size, error) != k_frame_size)
|
|
break;
|
|
if (frame.pc >= 0x1000)
|
|
{
|
|
cursor.pc = frame.pc;
|
|
cursor.fp = frame.fp;
|
|
m_cursors.push_back (cursor);
|
|
}
|
|
}
|
|
if (!m_cursors.empty())
|
|
{
|
|
lldb::addr_t first_frame_pc = m_cursors.front().pc;
|
|
if (first_frame_pc != LLDB_INVALID_ADDRESS)
|
|
{
|
|
const uint32_t resolve_scope = eSymbolContextModule |
|
|
eSymbolContextCompUnit |
|
|
eSymbolContextFunction |
|
|
eSymbolContextSymbol;
|
|
|
|
SymbolContext first_frame_sc (first_frame->GetSymbolContext(resolve_scope));
|
|
const AddressRange *addr_range_ptr = NULL;
|
|
if (first_frame_sc.function)
|
|
addr_range_ptr = &first_frame_sc.function->GetAddressRange();
|
|
else if (first_frame_sc.symbol)
|
|
addr_range_ptr = first_frame_sc.symbol->GetAddressRangePtr();
|
|
|
|
if (addr_range_ptr)
|
|
{
|
|
if (first_frame->GetFrameCodeAddress() == addr_range_ptr->GetBaseAddress())
|
|
{
|
|
// We are at the first instruction, so we can recover the
|
|
// previous PC by dereferencing the SP
|
|
lldb::addr_t first_frame_sp = reg_ctx->GetSP (0);
|
|
// Read the real second frame return address into frame.pc
|
|
if (first_frame_sp && m_thread.GetProcess().ReadMemory (first_frame_sp, &frame.pc, sizeof(frame.pc), error) == sizeof(frame.pc))
|
|
{
|
|
cursor.fp = m_cursors.front().fp;
|
|
cursor.pc = frame.pc; // Set the new second frame PC
|
|
|
|
// Insert the second frame
|
|
m_cursors.insert(m_cursors.begin()+1, cursor);
|
|
|
|
m_cursors.front().fp = first_frame_sp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// uint32_t i=0;
|
|
// printf(" PC FP\n");
|
|
// printf(" ------------------ ------------------ \n");
|
|
// for (i=0; i<m_cursors.size(); ++i)
|
|
// {
|
|
// printf("[%3u] 0x%16.16llx 0x%16.16llx\n", i, m_cursors[i].pc, m_cursors[i].fp);
|
|
// }
|
|
return m_cursors.size();
|
|
}
|
|
|
|
|
|
size_t
|
|
UnwindMacOSXFrameBackchain::GetStackFrameData_x86_64 (StackFrame *first_frame)
|
|
{
|
|
m_cursors.clear();
|
|
|
|
std::pair<lldb::addr_t, lldb::addr_t> fp_pc_pair;
|
|
|
|
struct Frame_x86_64
|
|
{
|
|
uint64_t fp;
|
|
uint64_t pc;
|
|
};
|
|
|
|
RegisterContext *reg_ctx = m_thread.GetRegisterContext();
|
|
assert (reg_ctx);
|
|
|
|
Cursor cursor;
|
|
cursor.pc = reg_ctx->GetPC (LLDB_INVALID_ADDRESS);
|
|
cursor.fp = reg_ctx->GetFP (0);
|
|
|
|
Frame_x86_64 frame = { cursor.fp, cursor.pc };
|
|
|
|
m_cursors.push_back(cursor);
|
|
Error error;
|
|
const size_t k_frame_size = sizeof(frame);
|
|
while (frame.fp != 0 && frame.pc != 0 && ((frame.fp & 7) == 0))
|
|
{
|
|
// Read both the FP and PC (16 bytes)
|
|
if (m_thread.GetProcess().ReadMemory (frame.fp, &frame.fp, k_frame_size, error) != k_frame_size)
|
|
break;
|
|
|
|
if (frame.pc >= 0x1000)
|
|
{
|
|
cursor.pc = frame.pc;
|
|
cursor.fp = frame.fp;
|
|
m_cursors.push_back (cursor);
|
|
}
|
|
}
|
|
if (!m_cursors.empty())
|
|
{
|
|
lldb::addr_t first_frame_pc = m_cursors.front().pc;
|
|
if (first_frame_pc != LLDB_INVALID_ADDRESS)
|
|
{
|
|
const uint32_t resolve_scope = eSymbolContextModule |
|
|
eSymbolContextCompUnit |
|
|
eSymbolContextFunction |
|
|
eSymbolContextSymbol;
|
|
|
|
SymbolContext first_frame_sc(first_frame->GetSymbolContext(resolve_scope));
|
|
const AddressRange *addr_range_ptr = NULL;
|
|
if (first_frame_sc.function)
|
|
addr_range_ptr = &first_frame_sc.function->GetAddressRange();
|
|
else if (first_frame_sc.symbol)
|
|
addr_range_ptr = first_frame_sc.symbol->GetAddressRangePtr();
|
|
|
|
if (addr_range_ptr)
|
|
{
|
|
if (first_frame->GetFrameCodeAddress() == addr_range_ptr->GetBaseAddress())
|
|
{
|
|
// We are at the first instruction, so we can recover the
|
|
// previous PC by dereferencing the SP
|
|
lldb::addr_t first_frame_sp = reg_ctx->GetSP (0);
|
|
// Read the real second frame return address into frame.pc
|
|
if (m_thread.GetProcess().ReadMemory (first_frame_sp, &frame.pc, sizeof(frame.pc), error) == sizeof(frame.pc))
|
|
{
|
|
cursor.fp = m_cursors.front().fp;
|
|
cursor.pc = frame.pc; // Set the new second frame PC
|
|
|
|
// Insert the second frame
|
|
m_cursors.insert(m_cursors.begin()+1, cursor);
|
|
|
|
m_cursors.front().fp = first_frame_sp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return m_cursors.size();
|
|
}
|
|
|