shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
Kate Stone b9c1b51e45 *** This commit represents a complete reformatting of the LLDB source code 
*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751
2016-09-06 20:57:50 +00:00

255 lines
8.0 KiB
C++
Raw Blame History

//===-- 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/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "RegisterContextMacOSXFrameBackchain.h"
using namespace lldb;
using namespace lldb_private;
UnwindMacOSXFrameBackchain::UnwindMacOSXFrameBackchain(Thread &thread)
: Unwind(thread), m_cursors() {}
uint32_t UnwindMacOSXFrameBackchain::DoGetFrameCount() {
if (m_cursors.empty()) {
ExecutionContext exe_ctx(m_thread.shared_from_this());
Target *target = exe_ctx.GetTargetPtr();
if (target) {
const ArchSpec &target_arch = target->GetArchitecture();
// Frame zero should always be supplied by the thread...
exe_ctx.SetFrameSP(m_thread.GetStackFrameAtIndex(0));
if (target_arch.GetAddressByteSize() == 8)
GetStackFrameData_x86_64(exe_ctx);
else
GetStackFrameData_i386(exe_ctx);
}
}
return m_cursors.size();
}
bool UnwindMacOSXFrameBackchain::DoGetFrameInfoAtIndex(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;
}
lldb::RegisterContextSP
UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame(StackFrame *frame) {
lldb::RegisterContextSP reg_ctx_sp;
uint32_t concrete_idx = frame->GetConcreteFrameIndex();
const uint32_t frame_count = GetFrameCount();
if (concrete_idx < frame_count)
reg_ctx_sp.reset(new RegisterContextMacOSXFrameBackchain(
m_thread, concrete_idx, m_cursors[concrete_idx]));
return reg_ctx_sp;
}
size_t UnwindMacOSXFrameBackchain::GetStackFrameData_i386(
const ExecutionContext &exe_ctx) {
m_cursors.clear();
StackFrame *first_frame = exe_ctx.GetFramePtr();
Process *process = exe_ctx.GetProcessPtr();
if (process == NULL)
return 0;
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().get();
assert(reg_ctx);
Cursor cursor;
cursor.pc = reg_ctx->GetPC(LLDB_INVALID_ADDRESS);
cursor.fp = reg_ctx->GetFP(0);
Frame_i386 frame = {static_cast<uint32_t>(cursor.fp),
static_cast<uint32_t>(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 (process->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;
AddressRange range;
if (first_frame_sc.function)
addr_range_ptr = &first_frame_sc.function->GetAddressRange();
else if (first_frame_sc.symbol) {
range.GetBaseAddress() = first_frame_sc.symbol->GetAddress();
range.SetByteSize(first_frame_sc.symbol->GetByteSize());
addr_range_ptr = &range;
}
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 &&
process->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.16" PRIx64 " 0x%16.16" PRIx64 "\n", i,
// m_cursors[i].pc, m_cursors[i].fp);
// }
return m_cursors.size();
}
size_t UnwindMacOSXFrameBackchain::GetStackFrameData_x86_64(
const ExecutionContext &exe_ctx) {
m_cursors.clear();
Process *process = exe_ctx.GetProcessPtr();
if (process == NULL)
return 0;
StackFrame *first_frame = exe_ctx.GetFramePtr();
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().get();
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 (process->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;
AddressRange range;
if (first_frame_sc.function)
addr_range_ptr = &first_frame_sc.function->GetAddressRange();
else if (first_frame_sc.symbol) {
range.GetBaseAddress() = first_frame_sc.symbol->GetAddress();
range.SetByteSize(first_frame_sc.symbol->GetByteSize());
addr_range_ptr = &range;
}
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 (process->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();
}
Reference in New Issue View Git Blame Copy Permalink