1628 lines
55 KiB
C++
1628 lines
55 KiB
C++
//===-- CompactUnwindInfo.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
|
|
#include <algorithm>
|
|
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/DataBufferHeap.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Symbol/CompactUnwindInfo.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/UnwindPlan.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
namespace lldb_private {
|
|
|
|
// Constants from <mach-o/compact_unwind_encoding.h>
|
|
|
|
FLAGS_ANONYMOUS_ENUM(){
|
|
UNWIND_IS_NOT_FUNCTION_START = 0x80000000, UNWIND_HAS_LSDA = 0x40000000,
|
|
UNWIND_PERSONALITY_MASK = 0x30000000,
|
|
};
|
|
|
|
FLAGS_ANONYMOUS_ENUM(){
|
|
UNWIND_X86_MODE_MASK = 0x0F000000,
|
|
UNWIND_X86_MODE_EBP_FRAME = 0x01000000,
|
|
UNWIND_X86_MODE_STACK_IMMD = 0x02000000,
|
|
UNWIND_X86_MODE_STACK_IND = 0x03000000,
|
|
UNWIND_X86_MODE_DWARF = 0x04000000,
|
|
|
|
UNWIND_X86_EBP_FRAME_REGISTERS = 0x00007FFF,
|
|
UNWIND_X86_EBP_FRAME_OFFSET = 0x00FF0000,
|
|
|
|
UNWIND_X86_FRAMELESS_STACK_SIZE = 0x00FF0000,
|
|
UNWIND_X86_FRAMELESS_STACK_ADJUST = 0x0000E000,
|
|
UNWIND_X86_FRAMELESS_STACK_REG_COUNT = 0x00001C00,
|
|
UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION = 0x000003FF,
|
|
|
|
UNWIND_X86_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
|
|
enum {
|
|
UNWIND_X86_REG_NONE = 0,
|
|
UNWIND_X86_REG_EBX = 1,
|
|
UNWIND_X86_REG_ECX = 2,
|
|
UNWIND_X86_REG_EDX = 3,
|
|
UNWIND_X86_REG_EDI = 4,
|
|
UNWIND_X86_REG_ESI = 5,
|
|
UNWIND_X86_REG_EBP = 6,
|
|
};
|
|
|
|
FLAGS_ANONYMOUS_ENUM(){
|
|
UNWIND_X86_64_MODE_MASK = 0x0F000000,
|
|
UNWIND_X86_64_MODE_RBP_FRAME = 0x01000000,
|
|
UNWIND_X86_64_MODE_STACK_IMMD = 0x02000000,
|
|
UNWIND_X86_64_MODE_STACK_IND = 0x03000000,
|
|
UNWIND_X86_64_MODE_DWARF = 0x04000000,
|
|
|
|
UNWIND_X86_64_RBP_FRAME_REGISTERS = 0x00007FFF,
|
|
UNWIND_X86_64_RBP_FRAME_OFFSET = 0x00FF0000,
|
|
|
|
UNWIND_X86_64_FRAMELESS_STACK_SIZE = 0x00FF0000,
|
|
UNWIND_X86_64_FRAMELESS_STACK_ADJUST = 0x0000E000,
|
|
UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT = 0x00001C00,
|
|
UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION = 0x000003FF,
|
|
|
|
UNWIND_X86_64_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
|
|
enum {
|
|
UNWIND_X86_64_REG_NONE = 0,
|
|
UNWIND_X86_64_REG_RBX = 1,
|
|
UNWIND_X86_64_REG_R12 = 2,
|
|
UNWIND_X86_64_REG_R13 = 3,
|
|
UNWIND_X86_64_REG_R14 = 4,
|
|
UNWIND_X86_64_REG_R15 = 5,
|
|
UNWIND_X86_64_REG_RBP = 6,
|
|
};
|
|
|
|
FLAGS_ANONYMOUS_ENUM(){
|
|
UNWIND_ARM64_MODE_MASK = 0x0F000000,
|
|
UNWIND_ARM64_MODE_FRAMELESS = 0x02000000,
|
|
UNWIND_ARM64_MODE_DWARF = 0x03000000,
|
|
UNWIND_ARM64_MODE_FRAME = 0x04000000,
|
|
|
|
UNWIND_ARM64_FRAME_X19_X20_PAIR = 0x00000001,
|
|
UNWIND_ARM64_FRAME_X21_X22_PAIR = 0x00000002,
|
|
UNWIND_ARM64_FRAME_X23_X24_PAIR = 0x00000004,
|
|
UNWIND_ARM64_FRAME_X25_X26_PAIR = 0x00000008,
|
|
UNWIND_ARM64_FRAME_X27_X28_PAIR = 0x00000010,
|
|
UNWIND_ARM64_FRAME_D8_D9_PAIR = 0x00000100,
|
|
UNWIND_ARM64_FRAME_D10_D11_PAIR = 0x00000200,
|
|
UNWIND_ARM64_FRAME_D12_D13_PAIR = 0x00000400,
|
|
UNWIND_ARM64_FRAME_D14_D15_PAIR = 0x00000800,
|
|
|
|
UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK = 0x00FFF000,
|
|
UNWIND_ARM64_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
|
|
FLAGS_ANONYMOUS_ENUM(){
|
|
UNWIND_ARM_MODE_MASK = 0x0F000000,
|
|
UNWIND_ARM_MODE_FRAME = 0x01000000,
|
|
UNWIND_ARM_MODE_FRAME_D = 0x02000000,
|
|
UNWIND_ARM_MODE_DWARF = 0x04000000,
|
|
|
|
UNWIND_ARM_FRAME_STACK_ADJUST_MASK = 0x00C00000,
|
|
|
|
UNWIND_ARM_FRAME_FIRST_PUSH_R4 = 0x00000001,
|
|
UNWIND_ARM_FRAME_FIRST_PUSH_R5 = 0x00000002,
|
|
UNWIND_ARM_FRAME_FIRST_PUSH_R6 = 0x00000004,
|
|
|
|
UNWIND_ARM_FRAME_SECOND_PUSH_R8 = 0x00000008,
|
|
UNWIND_ARM_FRAME_SECOND_PUSH_R9 = 0x00000010,
|
|
UNWIND_ARM_FRAME_SECOND_PUSH_R10 = 0x00000020,
|
|
UNWIND_ARM_FRAME_SECOND_PUSH_R11 = 0x00000040,
|
|
UNWIND_ARM_FRAME_SECOND_PUSH_R12 = 0x00000080,
|
|
|
|
UNWIND_ARM_FRAME_D_REG_COUNT_MASK = 0x00000700,
|
|
|
|
UNWIND_ARM_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
}
|
|
|
|
#ifndef UNWIND_SECOND_LEVEL_REGULAR
|
|
#define UNWIND_SECOND_LEVEL_REGULAR 2
|
|
#endif
|
|
|
|
#ifndef UNWIND_SECOND_LEVEL_COMPRESSED
|
|
#define UNWIND_SECOND_LEVEL_COMPRESSED 3
|
|
#endif
|
|
|
|
#ifndef UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET
|
|
#define UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry) (entry & 0x00FFFFFF)
|
|
#endif
|
|
|
|
#ifndef UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX
|
|
#define UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry) \
|
|
((entry >> 24) & 0xFF)
|
|
#endif
|
|
|
|
#define EXTRACT_BITS(value, mask) \
|
|
((value >> \
|
|
llvm::countTrailingZeros(static_cast<uint32_t>(mask), llvm::ZB_Width)) & \
|
|
(((1 << llvm::countPopulation(static_cast<uint32_t>(mask)))) - 1))
|
|
|
|
//----------------------
|
|
// constructor
|
|
//----------------------
|
|
|
|
CompactUnwindInfo::CompactUnwindInfo(ObjectFile &objfile, SectionSP §ion_sp)
|
|
: m_objfile(objfile), m_section_sp(section_sp),
|
|
m_section_contents_if_encrypted(), m_mutex(), m_indexes(),
|
|
m_indexes_computed(eLazyBoolCalculate), m_unwindinfo_data(),
|
|
m_unwindinfo_data_computed(false), m_unwind_header() {}
|
|
|
|
//----------------------
|
|
// destructor
|
|
//----------------------
|
|
|
|
CompactUnwindInfo::~CompactUnwindInfo() {}
|
|
|
|
bool CompactUnwindInfo::GetUnwindPlan(Target &target, Address addr,
|
|
UnwindPlan &unwind_plan) {
|
|
if (!IsValid(target.GetProcessSP())) {
|
|
return false;
|
|
}
|
|
FunctionInfo function_info;
|
|
if (GetCompactUnwindInfoForFunction(target, addr, function_info)) {
|
|
// shortcut return for functions that have no compact unwind
|
|
if (function_info.encoding == 0)
|
|
return false;
|
|
|
|
ArchSpec arch;
|
|
if (m_objfile.GetArchitecture(arch)) {
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
|
|
if (log && log->GetVerbose()) {
|
|
StreamString strm;
|
|
addr.Dump(
|
|
&strm, NULL,
|
|
Address::DumpStyle::DumpStyleResolvedDescriptionNoFunctionArguments,
|
|
Address::DumpStyle::DumpStyleFileAddress,
|
|
arch.GetAddressByteSize());
|
|
log->Printf("Got compact unwind encoding 0x%x for function %s",
|
|
function_info.encoding, strm.GetData());
|
|
}
|
|
|
|
if (function_info.valid_range_offset_start != 0 &&
|
|
function_info.valid_range_offset_end != 0) {
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
addr_t func_range_start_file_addr =
|
|
function_info.valid_range_offset_start +
|
|
m_objfile.GetHeaderAddress().GetFileAddress();
|
|
AddressRange func_range(func_range_start_file_addr,
|
|
function_info.valid_range_offset_end -
|
|
function_info.valid_range_offset_start,
|
|
sl);
|
|
unwind_plan.SetPlanValidAddressRange(func_range);
|
|
}
|
|
}
|
|
|
|
if (arch.GetTriple().getArch() == llvm::Triple::x86_64) {
|
|
return CreateUnwindPlan_x86_64(target, function_info, unwind_plan,
|
|
addr);
|
|
}
|
|
if (arch.GetTriple().getArch() == llvm::Triple::aarch64) {
|
|
return CreateUnwindPlan_arm64(target, function_info, unwind_plan, addr);
|
|
}
|
|
if (arch.GetTriple().getArch() == llvm::Triple::x86) {
|
|
return CreateUnwindPlan_i386(target, function_info, unwind_plan, addr);
|
|
}
|
|
if (arch.GetTriple().getArch() == llvm::Triple::arm ||
|
|
arch.GetTriple().getArch() == llvm::Triple::thumb) {
|
|
return CreateUnwindPlan_armv7(target, function_info, unwind_plan, addr);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CompactUnwindInfo::IsValid(const ProcessSP &process_sp) {
|
|
if (m_section_sp.get() == nullptr)
|
|
return false;
|
|
|
|
if (m_indexes_computed == eLazyBoolYes && m_unwindinfo_data_computed)
|
|
return true;
|
|
|
|
ScanIndex(process_sp);
|
|
|
|
return m_indexes_computed == eLazyBoolYes && m_unwindinfo_data_computed;
|
|
}
|
|
|
|
void CompactUnwindInfo::ScanIndex(const ProcessSP &process_sp) {
|
|
std::lock_guard<std::mutex> guard(m_mutex);
|
|
if (m_indexes_computed == eLazyBoolYes && m_unwindinfo_data_computed)
|
|
return;
|
|
|
|
// We can't read the index for some reason.
|
|
if (m_indexes_computed == eLazyBoolNo) {
|
|
return;
|
|
}
|
|
|
|
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
|
|
if (log)
|
|
m_objfile.GetModule()->LogMessage(
|
|
log, "Reading compact unwind first-level indexes");
|
|
|
|
if (m_unwindinfo_data_computed == false) {
|
|
if (m_section_sp->IsEncrypted()) {
|
|
// Can't get section contents of a protected/encrypted section until we
|
|
// have a live
|
|
// process and can read them out of memory.
|
|
if (process_sp.get() == nullptr)
|
|
return;
|
|
m_section_contents_if_encrypted.reset(
|
|
new DataBufferHeap(m_section_sp->GetByteSize(), 0));
|
|
Error error;
|
|
if (process_sp->ReadMemory(
|
|
m_section_sp->GetLoadBaseAddress(&process_sp->GetTarget()),
|
|
m_section_contents_if_encrypted->GetBytes(),
|
|
m_section_sp->GetByteSize(),
|
|
error) == m_section_sp->GetByteSize() &&
|
|
error.Success()) {
|
|
m_unwindinfo_data.SetAddressByteSize(
|
|
process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
|
|
m_unwindinfo_data.SetByteOrder(
|
|
process_sp->GetTarget().GetArchitecture().GetByteOrder());
|
|
m_unwindinfo_data.SetData(m_section_contents_if_encrypted, 0);
|
|
}
|
|
} else {
|
|
m_objfile.ReadSectionData(m_section_sp.get(), m_unwindinfo_data);
|
|
}
|
|
if (m_unwindinfo_data.GetByteSize() != m_section_sp->GetByteSize())
|
|
return;
|
|
m_unwindinfo_data_computed = true;
|
|
}
|
|
|
|
if (m_unwindinfo_data.GetByteSize() > 0) {
|
|
offset_t offset = 0;
|
|
|
|
// struct unwind_info_section_header
|
|
// {
|
|
// uint32_t version; // UNWIND_SECTION_VERSION
|
|
// uint32_t commonEncodingsArraySectionOffset;
|
|
// uint32_t commonEncodingsArrayCount;
|
|
// uint32_t personalityArraySectionOffset;
|
|
// uint32_t personalityArrayCount;
|
|
// uint32_t indexSectionOffset;
|
|
// uint32_t indexCount;
|
|
|
|
m_unwind_header.version = m_unwindinfo_data.GetU32(&offset);
|
|
m_unwind_header.common_encodings_array_offset =
|
|
m_unwindinfo_data.GetU32(&offset);
|
|
m_unwind_header.common_encodings_array_count =
|
|
m_unwindinfo_data.GetU32(&offset);
|
|
m_unwind_header.personality_array_offset =
|
|
m_unwindinfo_data.GetU32(&offset);
|
|
m_unwind_header.personality_array_count = m_unwindinfo_data.GetU32(&offset);
|
|
uint32_t indexSectionOffset = m_unwindinfo_data.GetU32(&offset);
|
|
|
|
uint32_t indexCount = m_unwindinfo_data.GetU32(&offset);
|
|
|
|
if (m_unwind_header.common_encodings_array_offset >
|
|
m_unwindinfo_data.GetByteSize() ||
|
|
m_unwind_header.personality_array_offset >
|
|
m_unwindinfo_data.GetByteSize() ||
|
|
indexSectionOffset > m_unwindinfo_data.GetByteSize() ||
|
|
offset > m_unwindinfo_data.GetByteSize()) {
|
|
Host::SystemLog(Host::eSystemLogError, "error: Invalid offset "
|
|
"encountered in compact unwind "
|
|
"info, skipping\n");
|
|
// don't trust anything from this compact_unwind section if it looks
|
|
// blatantly invalid data in the header.
|
|
m_indexes_computed = eLazyBoolNo;
|
|
return;
|
|
}
|
|
|
|
// Parse the basic information from the indexes
|
|
// We wait to scan the second level page info until it's needed
|
|
|
|
// struct unwind_info_section_header_index_entry
|
|
// {
|
|
// uint32_t functionOffset;
|
|
// uint32_t secondLevelPagesSectionOffset;
|
|
// uint32_t lsdaIndexArraySectionOffset;
|
|
// };
|
|
|
|
bool clear_address_zeroth_bit = false;
|
|
ArchSpec arch;
|
|
if (m_objfile.GetArchitecture(arch)) {
|
|
if (arch.GetTriple().getArch() == llvm::Triple::arm ||
|
|
arch.GetTriple().getArch() == llvm::Triple::thumb)
|
|
clear_address_zeroth_bit = true;
|
|
}
|
|
|
|
offset = indexSectionOffset;
|
|
for (uint32_t idx = 0; idx < indexCount; idx++) {
|
|
uint32_t function_offset =
|
|
m_unwindinfo_data.GetU32(&offset); // functionOffset
|
|
uint32_t second_level_offset =
|
|
m_unwindinfo_data.GetU32(&offset); // secondLevelPagesSectionOffset
|
|
uint32_t lsda_offset =
|
|
m_unwindinfo_data.GetU32(&offset); // lsdaIndexArraySectionOffset
|
|
|
|
if (second_level_offset > m_section_sp->GetByteSize() ||
|
|
lsda_offset > m_section_sp->GetByteSize()) {
|
|
m_indexes_computed = eLazyBoolNo;
|
|
}
|
|
|
|
if (clear_address_zeroth_bit)
|
|
function_offset &= ~1ull;
|
|
|
|
UnwindIndex this_index;
|
|
this_index.function_offset = function_offset;
|
|
this_index.second_level = second_level_offset;
|
|
this_index.lsda_array_start = lsda_offset;
|
|
|
|
if (m_indexes.size() > 0) {
|
|
m_indexes[m_indexes.size() - 1].lsda_array_end = lsda_offset;
|
|
}
|
|
|
|
if (second_level_offset == 0) {
|
|
this_index.sentinal_entry = true;
|
|
}
|
|
|
|
m_indexes.push_back(this_index);
|
|
}
|
|
m_indexes_computed = eLazyBoolYes;
|
|
} else {
|
|
m_indexes_computed = eLazyBoolNo;
|
|
}
|
|
}
|
|
|
|
uint32_t CompactUnwindInfo::GetLSDAForFunctionOffset(uint32_t lsda_offset,
|
|
uint32_t lsda_count,
|
|
uint32_t function_offset) {
|
|
// struct unwind_info_section_header_lsda_index_entry
|
|
// {
|
|
// uint32_t functionOffset;
|
|
// uint32_t lsdaOffset;
|
|
// };
|
|
|
|
offset_t first_entry = lsda_offset;
|
|
uint32_t low = 0;
|
|
uint32_t high = lsda_count;
|
|
while (low < high) {
|
|
uint32_t mid = (low + high) / 2;
|
|
offset_t offset = first_entry + (mid * 8);
|
|
uint32_t mid_func_offset =
|
|
m_unwindinfo_data.GetU32(&offset); // functionOffset
|
|
uint32_t mid_lsda_offset = m_unwindinfo_data.GetU32(&offset); // lsdaOffset
|
|
if (mid_func_offset == function_offset) {
|
|
return mid_lsda_offset;
|
|
}
|
|
if (mid_func_offset < function_offset) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
lldb::offset_t CompactUnwindInfo::BinarySearchRegularSecondPage(
|
|
uint32_t entry_page_offset, uint32_t entry_count, uint32_t function_offset,
|
|
uint32_t *entry_func_start_offset, uint32_t *entry_func_end_offset) {
|
|
// typedef uint32_t compact_unwind_encoding_t;
|
|
// struct unwind_info_regular_second_level_entry
|
|
// {
|
|
// uint32_t functionOffset;
|
|
// compact_unwind_encoding_t encoding;
|
|
|
|
offset_t first_entry = entry_page_offset;
|
|
|
|
uint32_t low = 0;
|
|
uint32_t high = entry_count;
|
|
uint32_t last = high - 1;
|
|
while (low < high) {
|
|
uint32_t mid = (low + high) / 2;
|
|
offset_t offset = first_entry + (mid * 8);
|
|
uint32_t mid_func_offset =
|
|
m_unwindinfo_data.GetU32(&offset); // functionOffset
|
|
uint32_t next_func_offset = 0;
|
|
if (mid < last) {
|
|
offset = first_entry + ((mid + 1) * 8);
|
|
next_func_offset = m_unwindinfo_data.GetU32(&offset); // functionOffset
|
|
}
|
|
if (mid_func_offset <= function_offset) {
|
|
if (mid == last || (next_func_offset > function_offset)) {
|
|
if (entry_func_start_offset)
|
|
*entry_func_start_offset = mid_func_offset;
|
|
if (mid != last && entry_func_end_offset)
|
|
*entry_func_end_offset = next_func_offset;
|
|
return first_entry + (mid * 8);
|
|
} else {
|
|
low = mid + 1;
|
|
}
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return LLDB_INVALID_OFFSET;
|
|
}
|
|
|
|
uint32_t CompactUnwindInfo::BinarySearchCompressedSecondPage(
|
|
uint32_t entry_page_offset, uint32_t entry_count,
|
|
uint32_t function_offset_to_find, uint32_t function_offset_base,
|
|
uint32_t *entry_func_start_offset, uint32_t *entry_func_end_offset) {
|
|
offset_t first_entry = entry_page_offset;
|
|
|
|
uint32_t low = 0;
|
|
uint32_t high = entry_count;
|
|
uint32_t last = high - 1;
|
|
while (low < high) {
|
|
uint32_t mid = (low + high) / 2;
|
|
offset_t offset = first_entry + (mid * 4);
|
|
uint32_t entry = m_unwindinfo_data.GetU32(&offset); // entry
|
|
uint32_t mid_func_offset = UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry);
|
|
mid_func_offset += function_offset_base;
|
|
uint32_t next_func_offset = 0;
|
|
if (mid < last) {
|
|
offset = first_entry + ((mid + 1) * 4);
|
|
uint32_t next_entry = m_unwindinfo_data.GetU32(&offset); // entry
|
|
next_func_offset = UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(next_entry);
|
|
next_func_offset += function_offset_base;
|
|
}
|
|
if (mid_func_offset <= function_offset_to_find) {
|
|
if (mid == last || (next_func_offset > function_offset_to_find)) {
|
|
if (entry_func_start_offset)
|
|
*entry_func_start_offset = mid_func_offset;
|
|
if (mid != last && entry_func_end_offset)
|
|
*entry_func_end_offset = next_func_offset;
|
|
return UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry);
|
|
} else {
|
|
low = mid + 1;
|
|
}
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
bool CompactUnwindInfo::GetCompactUnwindInfoForFunction(
|
|
Target &target, Address address, FunctionInfo &unwind_info) {
|
|
unwind_info.encoding = 0;
|
|
unwind_info.lsda_address.Clear();
|
|
unwind_info.personality_ptr_address.Clear();
|
|
|
|
if (!IsValid(target.GetProcessSP()))
|
|
return false;
|
|
|
|
addr_t text_section_file_address = LLDB_INVALID_ADDRESS;
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
SectionSP text_sect = sl->FindSectionByType(eSectionTypeCode, true);
|
|
if (text_sect.get()) {
|
|
text_section_file_address = text_sect->GetFileAddress();
|
|
}
|
|
}
|
|
if (text_section_file_address == LLDB_INVALID_ADDRESS)
|
|
return false;
|
|
|
|
addr_t function_offset =
|
|
address.GetFileAddress() - m_objfile.GetHeaderAddress().GetFileAddress();
|
|
|
|
UnwindIndex key;
|
|
key.function_offset = function_offset;
|
|
|
|
std::vector<UnwindIndex>::const_iterator it;
|
|
it = std::lower_bound(m_indexes.begin(), m_indexes.end(), key);
|
|
if (it == m_indexes.end()) {
|
|
return false;
|
|
}
|
|
|
|
if (it->function_offset != key.function_offset) {
|
|
if (it != m_indexes.begin())
|
|
--it;
|
|
}
|
|
|
|
if (it->sentinal_entry == true) {
|
|
return false;
|
|
}
|
|
|
|
auto next_it = it + 1;
|
|
if (next_it != m_indexes.end()) {
|
|
// initialize the function offset end range to be the start of the
|
|
// next index offset. If we find an entry which is at the end of
|
|
// the index table, this will establish the range end.
|
|
unwind_info.valid_range_offset_end = next_it->function_offset;
|
|
}
|
|
|
|
offset_t second_page_offset = it->second_level;
|
|
offset_t lsda_array_start = it->lsda_array_start;
|
|
offset_t lsda_array_count = (it->lsda_array_end - it->lsda_array_start) / 8;
|
|
|
|
offset_t offset = second_page_offset;
|
|
uint32_t kind = m_unwindinfo_data.GetU32(
|
|
&offset); // UNWIND_SECOND_LEVEL_REGULAR or UNWIND_SECOND_LEVEL_COMPRESSED
|
|
|
|
if (kind == UNWIND_SECOND_LEVEL_REGULAR) {
|
|
// struct unwind_info_regular_second_level_page_header
|
|
// {
|
|
// uint32_t kind; // UNWIND_SECOND_LEVEL_REGULAR
|
|
// uint16_t entryPageOffset;
|
|
// uint16_t entryCount;
|
|
|
|
// typedef uint32_t compact_unwind_encoding_t;
|
|
// struct unwind_info_regular_second_level_entry
|
|
// {
|
|
// uint32_t functionOffset;
|
|
// compact_unwind_encoding_t encoding;
|
|
|
|
uint16_t entry_page_offset =
|
|
m_unwindinfo_data.GetU16(&offset); // entryPageOffset
|
|
uint16_t entry_count = m_unwindinfo_data.GetU16(&offset); // entryCount
|
|
|
|
offset_t entry_offset = BinarySearchRegularSecondPage(
|
|
second_page_offset + entry_page_offset, entry_count, function_offset,
|
|
&unwind_info.valid_range_offset_start,
|
|
&unwind_info.valid_range_offset_end);
|
|
if (entry_offset == LLDB_INVALID_OFFSET) {
|
|
return false;
|
|
}
|
|
entry_offset += 4; // skip over functionOffset
|
|
unwind_info.encoding = m_unwindinfo_data.GetU32(&entry_offset); // encoding
|
|
if (unwind_info.encoding & UNWIND_HAS_LSDA) {
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
uint32_t lsda_offset = GetLSDAForFunctionOffset(
|
|
lsda_array_start, lsda_array_count, function_offset);
|
|
addr_t objfile_header_file_address =
|
|
m_objfile.GetHeaderAddress().GetFileAddress();
|
|
unwind_info.lsda_address.ResolveAddressUsingFileSections(
|
|
objfile_header_file_address + lsda_offset, sl);
|
|
}
|
|
}
|
|
if (unwind_info.encoding & UNWIND_PERSONALITY_MASK) {
|
|
uint32_t personality_index =
|
|
EXTRACT_BITS(unwind_info.encoding, UNWIND_PERSONALITY_MASK);
|
|
|
|
if (personality_index > 0) {
|
|
personality_index--;
|
|
if (personality_index < m_unwind_header.personality_array_count) {
|
|
offset_t offset = m_unwind_header.personality_array_offset;
|
|
offset += 4 * personality_index;
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
uint32_t personality_offset = m_unwindinfo_data.GetU32(&offset);
|
|
addr_t objfile_header_file_address =
|
|
m_objfile.GetHeaderAddress().GetFileAddress();
|
|
unwind_info.personality_ptr_address.ResolveAddressUsingFileSections(
|
|
objfile_header_file_address + personality_offset, sl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
} else if (kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
|
|
// struct unwind_info_compressed_second_level_page_header
|
|
// {
|
|
// uint32_t kind; // UNWIND_SECOND_LEVEL_COMPRESSED
|
|
// uint16_t entryPageOffset; // offset from this 2nd lvl page
|
|
// idx to array of entries
|
|
// // (an entry has a function
|
|
// offset and index into the
|
|
// encodings)
|
|
// // NB function offset from the
|
|
// entry in the compressed page
|
|
// // must be added to the index's
|
|
// functionOffset value.
|
|
// uint16_t entryCount;
|
|
// uint16_t encodingsPageOffset; // offset from this 2nd lvl page
|
|
// idx to array of encodings
|
|
// uint16_t encodingsCount;
|
|
|
|
uint16_t entry_page_offset =
|
|
m_unwindinfo_data.GetU16(&offset); // entryPageOffset
|
|
uint16_t entry_count = m_unwindinfo_data.GetU16(&offset); // entryCount
|
|
uint16_t encodings_page_offset =
|
|
m_unwindinfo_data.GetU16(&offset); // encodingsPageOffset
|
|
uint16_t encodings_count =
|
|
m_unwindinfo_data.GetU16(&offset); // encodingsCount
|
|
|
|
uint32_t encoding_index = BinarySearchCompressedSecondPage(
|
|
second_page_offset + entry_page_offset, entry_count, function_offset,
|
|
it->function_offset, &unwind_info.valid_range_offset_start,
|
|
&unwind_info.valid_range_offset_end);
|
|
if (encoding_index == UINT32_MAX ||
|
|
encoding_index >=
|
|
encodings_count + m_unwind_header.common_encodings_array_count) {
|
|
return false;
|
|
}
|
|
uint32_t encoding = 0;
|
|
if (encoding_index < m_unwind_header.common_encodings_array_count) {
|
|
offset = m_unwind_header.common_encodings_array_offset +
|
|
(encoding_index * sizeof(uint32_t));
|
|
encoding = m_unwindinfo_data.GetU32(
|
|
&offset); // encoding entry from the commonEncodingsArray
|
|
} else {
|
|
uint32_t page_specific_entry_index =
|
|
encoding_index - m_unwind_header.common_encodings_array_count;
|
|
offset = second_page_offset + encodings_page_offset +
|
|
(page_specific_entry_index * sizeof(uint32_t));
|
|
encoding = m_unwindinfo_data.GetU32(
|
|
&offset); // encoding entry from the page-specific encoding array
|
|
}
|
|
if (encoding == 0)
|
|
return false;
|
|
|
|
unwind_info.encoding = encoding;
|
|
if (unwind_info.encoding & UNWIND_HAS_LSDA) {
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
uint32_t lsda_offset = GetLSDAForFunctionOffset(
|
|
lsda_array_start, lsda_array_count, function_offset);
|
|
addr_t objfile_header_file_address =
|
|
m_objfile.GetHeaderAddress().GetFileAddress();
|
|
unwind_info.lsda_address.ResolveAddressUsingFileSections(
|
|
objfile_header_file_address + lsda_offset, sl);
|
|
}
|
|
}
|
|
if (unwind_info.encoding & UNWIND_PERSONALITY_MASK) {
|
|
uint32_t personality_index =
|
|
EXTRACT_BITS(unwind_info.encoding, UNWIND_PERSONALITY_MASK);
|
|
|
|
if (personality_index > 0) {
|
|
personality_index--;
|
|
if (personality_index < m_unwind_header.personality_array_count) {
|
|
offset_t offset = m_unwind_header.personality_array_offset;
|
|
offset += 4 * personality_index;
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
uint32_t personality_offset = m_unwindinfo_data.GetU32(&offset);
|
|
addr_t objfile_header_file_address =
|
|
m_objfile.GetHeaderAddress().GetFileAddress();
|
|
unwind_info.personality_ptr_address.ResolveAddressUsingFileSections(
|
|
objfile_header_file_address + personality_offset, sl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
enum x86_64_eh_regnum {
|
|
rax = 0,
|
|
rdx = 1,
|
|
rcx = 2,
|
|
rbx = 3,
|
|
rsi = 4,
|
|
rdi = 5,
|
|
rbp = 6,
|
|
rsp = 7,
|
|
r8 = 8,
|
|
r9 = 9,
|
|
r10 = 10,
|
|
r11 = 11,
|
|
r12 = 12,
|
|
r13 = 13,
|
|
r14 = 14,
|
|
r15 = 15,
|
|
rip = 16 // this is officially the Return Address register number, but close
|
|
// enough
|
|
};
|
|
|
|
// Convert the compact_unwind_info.h register numbering scheme
|
|
// to eRegisterKindEHFrame (eh_frame) register numbering scheme.
|
|
uint32_t translate_to_eh_frame_regnum_x86_64(uint32_t unwind_regno) {
|
|
switch (unwind_regno) {
|
|
case UNWIND_X86_64_REG_RBX:
|
|
return x86_64_eh_regnum::rbx;
|
|
case UNWIND_X86_64_REG_R12:
|
|
return x86_64_eh_regnum::r12;
|
|
case UNWIND_X86_64_REG_R13:
|
|
return x86_64_eh_regnum::r13;
|
|
case UNWIND_X86_64_REG_R14:
|
|
return x86_64_eh_regnum::r14;
|
|
case UNWIND_X86_64_REG_R15:
|
|
return x86_64_eh_regnum::r15;
|
|
case UNWIND_X86_64_REG_RBP:
|
|
return x86_64_eh_regnum::rbp;
|
|
default:
|
|
return LLDB_INVALID_REGNUM;
|
|
}
|
|
}
|
|
|
|
bool CompactUnwindInfo::CreateUnwindPlan_x86_64(Target &target,
|
|
FunctionInfo &function_info,
|
|
UnwindPlan &unwind_plan,
|
|
Address pc_or_function_start) {
|
|
unwind_plan.SetSourceName("compact unwind info");
|
|
unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
|
|
unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
|
|
unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
|
|
|
|
unwind_plan.SetLSDAAddress(function_info.lsda_address);
|
|
unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
|
|
|
|
UnwindPlan::RowSP row(new UnwindPlan::Row);
|
|
|
|
const int wordsize = 8;
|
|
int mode = function_info.encoding & UNWIND_X86_64_MODE_MASK;
|
|
switch (mode) {
|
|
case UNWIND_X86_64_MODE_RBP_FRAME: {
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(
|
|
translate_to_eh_frame_regnum_x86_64(UNWIND_X86_64_REG_RBP),
|
|
2 * wordsize);
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rbp,
|
|
wordsize * -2, true);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rip,
|
|
wordsize * -1, true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(x86_64_eh_regnum::rsp, 0, true);
|
|
|
|
uint32_t saved_registers_offset =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_64_RBP_FRAME_OFFSET);
|
|
|
|
uint32_t saved_registers_locations =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_64_RBP_FRAME_REGISTERS);
|
|
|
|
saved_registers_offset += 2;
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
uint32_t regnum = saved_registers_locations & 0x7;
|
|
switch (regnum) {
|
|
case UNWIND_X86_64_REG_NONE:
|
|
break;
|
|
case UNWIND_X86_64_REG_RBX:
|
|
case UNWIND_X86_64_REG_R12:
|
|
case UNWIND_X86_64_REG_R13:
|
|
case UNWIND_X86_64_REG_R14:
|
|
case UNWIND_X86_64_REG_R15:
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
translate_to_eh_frame_regnum_x86_64(regnum),
|
|
wordsize * -saved_registers_offset, true);
|
|
break;
|
|
}
|
|
saved_registers_offset--;
|
|
saved_registers_locations >>= 3;
|
|
}
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
} break;
|
|
|
|
case UNWIND_X86_64_MODE_STACK_IND: {
|
|
// The clang in Xcode 6 is emitting incorrect compact unwind encodings for
|
|
// this
|
|
// style of unwind. It was fixed in llvm r217020.
|
|
// The clang in Xcode 7 has this fixed.
|
|
return false;
|
|
} break;
|
|
|
|
case UNWIND_X86_64_MODE_STACK_IMMD: {
|
|
uint32_t stack_size = EXTRACT_BITS(function_info.encoding,
|
|
UNWIND_X86_64_FRAMELESS_STACK_SIZE);
|
|
uint32_t register_count = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT);
|
|
uint32_t permutation = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION);
|
|
|
|
if (mode == UNWIND_X86_64_MODE_STACK_IND &&
|
|
function_info.valid_range_offset_start != 0) {
|
|
uint32_t stack_adjust = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_64_FRAMELESS_STACK_ADJUST);
|
|
|
|
// offset into the function instructions; 0 == beginning of first
|
|
// instruction
|
|
uint32_t offset_to_subl_insn = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_64_FRAMELESS_STACK_SIZE);
|
|
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
ProcessSP process_sp = target.GetProcessSP();
|
|
if (process_sp) {
|
|
Address subl_payload_addr(function_info.valid_range_offset_start, sl);
|
|
subl_payload_addr.Slide(offset_to_subl_insn);
|
|
Error error;
|
|
uint64_t large_stack_size = process_sp->ReadUnsignedIntegerFromMemory(
|
|
subl_payload_addr.GetLoadAddress(&target), 4, 0, error);
|
|
if (large_stack_size != 0 && error.Success()) {
|
|
// Got the large stack frame size correctly - use it
|
|
stack_size = large_stack_size + (stack_adjust * wordsize);
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int32_t offset = mode == UNWIND_X86_64_MODE_STACK_IND
|
|
? stack_size
|
|
: stack_size * wordsize;
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(x86_64_eh_regnum::rsp, offset);
|
|
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rip,
|
|
wordsize * -1, true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(x86_64_eh_regnum::rsp, 0, true);
|
|
|
|
if (register_count > 0) {
|
|
|
|
// We need to include (up to) 6 registers in 10 bits.
|
|
// That would be 18 bits if we just used 3 bits per reg to indicate
|
|
// the order they're saved on the stack.
|
|
//
|
|
// This is done with Lehmer code permutation, e.g. see
|
|
// http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
|
|
int permunreg[6] = {0, 0, 0, 0, 0, 0};
|
|
|
|
// This decodes the variable-base number in the 10 bits
|
|
// and gives us the Lehmer code sequence which can then
|
|
// be decoded.
|
|
|
|
switch (register_count) {
|
|
case 6:
|
|
permunreg[0] = permutation / 120; // 120 == 5!
|
|
permutation -= (permunreg[0] * 120);
|
|
permunreg[1] = permutation / 24; // 24 == 4!
|
|
permutation -= (permunreg[1] * 24);
|
|
permunreg[2] = permutation / 6; // 6 == 3!
|
|
permutation -= (permunreg[2] * 6);
|
|
permunreg[3] = permutation / 2; // 2 == 2!
|
|
permutation -= (permunreg[3] * 2);
|
|
permunreg[4] = permutation; // 1 == 1!
|
|
permunreg[5] = 0;
|
|
break;
|
|
case 5:
|
|
permunreg[0] = permutation / 120;
|
|
permutation -= (permunreg[0] * 120);
|
|
permunreg[1] = permutation / 24;
|
|
permutation -= (permunreg[1] * 24);
|
|
permunreg[2] = permutation / 6;
|
|
permutation -= (permunreg[2] * 6);
|
|
permunreg[3] = permutation / 2;
|
|
permutation -= (permunreg[3] * 2);
|
|
permunreg[4] = permutation;
|
|
break;
|
|
case 4:
|
|
permunreg[0] = permutation / 60;
|
|
permutation -= (permunreg[0] * 60);
|
|
permunreg[1] = permutation / 12;
|
|
permutation -= (permunreg[1] * 12);
|
|
permunreg[2] = permutation / 3;
|
|
permutation -= (permunreg[2] * 3);
|
|
permunreg[3] = permutation;
|
|
break;
|
|
case 3:
|
|
permunreg[0] = permutation / 20;
|
|
permutation -= (permunreg[0] * 20);
|
|
permunreg[1] = permutation / 4;
|
|
permutation -= (permunreg[1] * 4);
|
|
permunreg[2] = permutation;
|
|
break;
|
|
case 2:
|
|
permunreg[0] = permutation / 5;
|
|
permutation -= (permunreg[0] * 5);
|
|
permunreg[1] = permutation;
|
|
break;
|
|
case 1:
|
|
permunreg[0] = permutation;
|
|
break;
|
|
}
|
|
|
|
// Decode the Lehmer code for this permutation of
|
|
// the registers v. http://en.wikipedia.org/wiki/Lehmer_code
|
|
|
|
int registers[6] = {UNWIND_X86_64_REG_NONE, UNWIND_X86_64_REG_NONE,
|
|
UNWIND_X86_64_REG_NONE, UNWIND_X86_64_REG_NONE,
|
|
UNWIND_X86_64_REG_NONE, UNWIND_X86_64_REG_NONE};
|
|
bool used[7] = {false, false, false, false, false, false, false};
|
|
for (uint32_t i = 0; i < register_count; i++) {
|
|
int renum = 0;
|
|
for (int j = 1; j < 7; j++) {
|
|
if (used[j] == false) {
|
|
if (renum == permunreg[i]) {
|
|
registers[i] = j;
|
|
used[j] = true;
|
|
break;
|
|
}
|
|
renum++;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t saved_registers_offset = 1;
|
|
saved_registers_offset++;
|
|
|
|
for (int i = (sizeof(registers) / sizeof(int)) - 1; i >= 0; i--) {
|
|
switch (registers[i]) {
|
|
case UNWIND_X86_64_REG_NONE:
|
|
break;
|
|
case UNWIND_X86_64_REG_RBX:
|
|
case UNWIND_X86_64_REG_R12:
|
|
case UNWIND_X86_64_REG_R13:
|
|
case UNWIND_X86_64_REG_R14:
|
|
case UNWIND_X86_64_REG_R15:
|
|
case UNWIND_X86_64_REG_RBP:
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
translate_to_eh_frame_regnum_x86_64(registers[i]),
|
|
wordsize * -saved_registers_offset, true);
|
|
saved_registers_offset++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
} break;
|
|
|
|
case UNWIND_X86_64_MODE_DWARF: {
|
|
return false;
|
|
} break;
|
|
|
|
case 0: {
|
|
return false;
|
|
} break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
enum i386_eh_regnum {
|
|
eax = 0,
|
|
ecx = 1,
|
|
edx = 2,
|
|
ebx = 3,
|
|
ebp = 4,
|
|
esp = 5,
|
|
esi = 6,
|
|
edi = 7,
|
|
eip = 8 // this is officially the Return Address register number, but close
|
|
// enough
|
|
};
|
|
|
|
// Convert the compact_unwind_info.h register numbering scheme
|
|
// to eRegisterKindEHFrame (eh_frame) register numbering scheme.
|
|
uint32_t translate_to_eh_frame_regnum_i386(uint32_t unwind_regno) {
|
|
switch (unwind_regno) {
|
|
case UNWIND_X86_REG_EBX:
|
|
return i386_eh_regnum::ebx;
|
|
case UNWIND_X86_REG_ECX:
|
|
return i386_eh_regnum::ecx;
|
|
case UNWIND_X86_REG_EDX:
|
|
return i386_eh_regnum::edx;
|
|
case UNWIND_X86_REG_EDI:
|
|
return i386_eh_regnum::edi;
|
|
case UNWIND_X86_REG_ESI:
|
|
return i386_eh_regnum::esi;
|
|
case UNWIND_X86_REG_EBP:
|
|
return i386_eh_regnum::ebp;
|
|
default:
|
|
return LLDB_INVALID_REGNUM;
|
|
}
|
|
}
|
|
|
|
bool CompactUnwindInfo::CreateUnwindPlan_i386(Target &target,
|
|
FunctionInfo &function_info,
|
|
UnwindPlan &unwind_plan,
|
|
Address pc_or_function_start) {
|
|
unwind_plan.SetSourceName("compact unwind info");
|
|
unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
|
|
unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
|
|
unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
|
|
|
|
unwind_plan.SetLSDAAddress(function_info.lsda_address);
|
|
unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
|
|
|
|
UnwindPlan::RowSP row(new UnwindPlan::Row);
|
|
|
|
const int wordsize = 4;
|
|
int mode = function_info.encoding & UNWIND_X86_MODE_MASK;
|
|
switch (mode) {
|
|
case UNWIND_X86_MODE_EBP_FRAME: {
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(
|
|
translate_to_eh_frame_regnum_i386(UNWIND_X86_REG_EBP), 2 * wordsize);
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::ebp,
|
|
wordsize * -2, true);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::eip,
|
|
wordsize * -1, true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(i386_eh_regnum::esp, 0, true);
|
|
|
|
uint32_t saved_registers_offset =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_EBP_FRAME_OFFSET);
|
|
|
|
uint32_t saved_registers_locations =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_EBP_FRAME_REGISTERS);
|
|
|
|
saved_registers_offset += 2;
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
uint32_t regnum = saved_registers_locations & 0x7;
|
|
switch (regnum) {
|
|
case UNWIND_X86_REG_NONE:
|
|
break;
|
|
case UNWIND_X86_REG_EBX:
|
|
case UNWIND_X86_REG_ECX:
|
|
case UNWIND_X86_REG_EDX:
|
|
case UNWIND_X86_REG_EDI:
|
|
case UNWIND_X86_REG_ESI:
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
translate_to_eh_frame_regnum_i386(regnum),
|
|
wordsize * -saved_registers_offset, true);
|
|
break;
|
|
}
|
|
saved_registers_offset--;
|
|
saved_registers_locations >>= 3;
|
|
}
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
} break;
|
|
|
|
case UNWIND_X86_MODE_STACK_IND:
|
|
case UNWIND_X86_MODE_STACK_IMMD: {
|
|
uint32_t stack_size =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_FRAMELESS_STACK_SIZE);
|
|
uint32_t register_count = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_FRAMELESS_STACK_REG_COUNT);
|
|
uint32_t permutation = EXTRACT_BITS(
|
|
function_info.encoding, UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION);
|
|
|
|
if (mode == UNWIND_X86_MODE_STACK_IND &&
|
|
function_info.valid_range_offset_start != 0) {
|
|
uint32_t stack_adjust = EXTRACT_BITS(function_info.encoding,
|
|
UNWIND_X86_FRAMELESS_STACK_ADJUST);
|
|
|
|
// offset into the function instructions; 0 == beginning of first
|
|
// instruction
|
|
uint32_t offset_to_subl_insn =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_X86_FRAMELESS_STACK_SIZE);
|
|
|
|
SectionList *sl = m_objfile.GetSectionList();
|
|
if (sl) {
|
|
ProcessSP process_sp = target.GetProcessSP();
|
|
if (process_sp) {
|
|
Address subl_payload_addr(function_info.valid_range_offset_start, sl);
|
|
subl_payload_addr.Slide(offset_to_subl_insn);
|
|
Error error;
|
|
uint64_t large_stack_size = process_sp->ReadUnsignedIntegerFromMemory(
|
|
subl_payload_addr.GetLoadAddress(&target), 4, 0, error);
|
|
if (large_stack_size != 0 && error.Success()) {
|
|
// Got the large stack frame size correctly - use it
|
|
stack_size = large_stack_size + (stack_adjust * wordsize);
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int32_t offset =
|
|
mode == UNWIND_X86_MODE_STACK_IND ? stack_size : stack_size * wordsize;
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(i386_eh_regnum::esp, offset);
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::eip,
|
|
wordsize * -1, true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(i386_eh_regnum::esp, 0, true);
|
|
|
|
if (register_count > 0) {
|
|
|
|
// We need to include (up to) 6 registers in 10 bits.
|
|
// That would be 18 bits if we just used 3 bits per reg to indicate
|
|
// the order they're saved on the stack.
|
|
//
|
|
// This is done with Lehmer code permutation, e.g. see
|
|
// http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
|
|
int permunreg[6] = {0, 0, 0, 0, 0, 0};
|
|
|
|
// This decodes the variable-base number in the 10 bits
|
|
// and gives us the Lehmer code sequence which can then
|
|
// be decoded.
|
|
|
|
switch (register_count) {
|
|
case 6:
|
|
permunreg[0] = permutation / 120; // 120 == 5!
|
|
permutation -= (permunreg[0] * 120);
|
|
permunreg[1] = permutation / 24; // 24 == 4!
|
|
permutation -= (permunreg[1] * 24);
|
|
permunreg[2] = permutation / 6; // 6 == 3!
|
|
permutation -= (permunreg[2] * 6);
|
|
permunreg[3] = permutation / 2; // 2 == 2!
|
|
permutation -= (permunreg[3] * 2);
|
|
permunreg[4] = permutation; // 1 == 1!
|
|
permunreg[5] = 0;
|
|
break;
|
|
case 5:
|
|
permunreg[0] = permutation / 120;
|
|
permutation -= (permunreg[0] * 120);
|
|
permunreg[1] = permutation / 24;
|
|
permutation -= (permunreg[1] * 24);
|
|
permunreg[2] = permutation / 6;
|
|
permutation -= (permunreg[2] * 6);
|
|
permunreg[3] = permutation / 2;
|
|
permutation -= (permunreg[3] * 2);
|
|
permunreg[4] = permutation;
|
|
break;
|
|
case 4:
|
|
permunreg[0] = permutation / 60;
|
|
permutation -= (permunreg[0] * 60);
|
|
permunreg[1] = permutation / 12;
|
|
permutation -= (permunreg[1] * 12);
|
|
permunreg[2] = permutation / 3;
|
|
permutation -= (permunreg[2] * 3);
|
|
permunreg[3] = permutation;
|
|
break;
|
|
case 3:
|
|
permunreg[0] = permutation / 20;
|
|
permutation -= (permunreg[0] * 20);
|
|
permunreg[1] = permutation / 4;
|
|
permutation -= (permunreg[1] * 4);
|
|
permunreg[2] = permutation;
|
|
break;
|
|
case 2:
|
|
permunreg[0] = permutation / 5;
|
|
permutation -= (permunreg[0] * 5);
|
|
permunreg[1] = permutation;
|
|
break;
|
|
case 1:
|
|
permunreg[0] = permutation;
|
|
break;
|
|
}
|
|
|
|
// Decode the Lehmer code for this permutation of
|
|
// the registers v. http://en.wikipedia.org/wiki/Lehmer_code
|
|
|
|
int registers[6] = {UNWIND_X86_REG_NONE, UNWIND_X86_REG_NONE,
|
|
UNWIND_X86_REG_NONE, UNWIND_X86_REG_NONE,
|
|
UNWIND_X86_REG_NONE, UNWIND_X86_REG_NONE};
|
|
bool used[7] = {false, false, false, false, false, false, false};
|
|
for (uint32_t i = 0; i < register_count; i++) {
|
|
int renum = 0;
|
|
for (int j = 1; j < 7; j++) {
|
|
if (used[j] == false) {
|
|
if (renum == permunreg[i]) {
|
|
registers[i] = j;
|
|
used[j] = true;
|
|
break;
|
|
}
|
|
renum++;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t saved_registers_offset = 1;
|
|
saved_registers_offset++;
|
|
|
|
for (int i = (sizeof(registers) / sizeof(int)) - 1; i >= 0; i--) {
|
|
switch (registers[i]) {
|
|
case UNWIND_X86_REG_NONE:
|
|
break;
|
|
case UNWIND_X86_REG_EBX:
|
|
case UNWIND_X86_REG_ECX:
|
|
case UNWIND_X86_REG_EDX:
|
|
case UNWIND_X86_REG_EDI:
|
|
case UNWIND_X86_REG_ESI:
|
|
case UNWIND_X86_REG_EBP:
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
translate_to_eh_frame_regnum_i386(registers[i]),
|
|
wordsize * -saved_registers_offset, true);
|
|
saved_registers_offset++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
} break;
|
|
|
|
case UNWIND_X86_MODE_DWARF: {
|
|
return false;
|
|
} break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// DWARF register numbers from "DWARF for the ARM 64-bit Architecture (AArch64)"
|
|
// doc by ARM
|
|
|
|
enum arm64_eh_regnum {
|
|
x19 = 19,
|
|
x20 = 20,
|
|
x21 = 21,
|
|
x22 = 22,
|
|
x23 = 23,
|
|
x24 = 24,
|
|
x25 = 25,
|
|
x26 = 26,
|
|
x27 = 27,
|
|
x28 = 28,
|
|
|
|
fp = 29,
|
|
ra = 30,
|
|
sp = 31,
|
|
pc = 32,
|
|
|
|
// Compact unwind encodes d8-d15 but we don't have eh_frame / dwarf reg #'s
|
|
// for the 64-bit
|
|
// fp regs. Normally in DWARF it's context sensitive - so it knows it is
|
|
// fetching a
|
|
// 32- or 64-bit quantity from reg v8 to indicate s0 or d0 - but the unwinder
|
|
// is operating
|
|
// at a lower level and we'd try to fetch 128 bits if we were told that v8
|
|
// were stored on
|
|
// the stack...
|
|
v8 = 72,
|
|
v9 = 73,
|
|
v10 = 74,
|
|
v11 = 75,
|
|
v12 = 76,
|
|
v13 = 77,
|
|
v14 = 78,
|
|
v15 = 79,
|
|
};
|
|
|
|
enum arm_eh_regnum {
|
|
arm_r0 = 0,
|
|
arm_r1 = 1,
|
|
arm_r2 = 2,
|
|
arm_r3 = 3,
|
|
arm_r4 = 4,
|
|
arm_r5 = 5,
|
|
arm_r6 = 6,
|
|
arm_r7 = 7,
|
|
arm_r8 = 8,
|
|
arm_r9 = 9,
|
|
arm_r10 = 10,
|
|
arm_r11 = 11,
|
|
arm_r12 = 12,
|
|
|
|
arm_sp = 13,
|
|
arm_lr = 14,
|
|
arm_pc = 15,
|
|
|
|
arm_d0 = 256,
|
|
arm_d1 = 257,
|
|
arm_d2 = 258,
|
|
arm_d3 = 259,
|
|
arm_d4 = 260,
|
|
arm_d5 = 261,
|
|
arm_d6 = 262,
|
|
arm_d7 = 263,
|
|
arm_d8 = 264,
|
|
arm_d9 = 265,
|
|
arm_d10 = 266,
|
|
arm_d11 = 267,
|
|
arm_d12 = 268,
|
|
arm_d13 = 269,
|
|
arm_d14 = 270,
|
|
};
|
|
|
|
bool CompactUnwindInfo::CreateUnwindPlan_arm64(Target &target,
|
|
FunctionInfo &function_info,
|
|
UnwindPlan &unwind_plan,
|
|
Address pc_or_function_start) {
|
|
unwind_plan.SetSourceName("compact unwind info");
|
|
unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
|
|
unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
|
|
unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
|
|
|
|
unwind_plan.SetLSDAAddress(function_info.lsda_address);
|
|
unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
|
|
|
|
UnwindPlan::RowSP row(new UnwindPlan::Row);
|
|
|
|
const int wordsize = 8;
|
|
int mode = function_info.encoding & UNWIND_ARM64_MODE_MASK;
|
|
|
|
if (mode == UNWIND_ARM64_MODE_DWARF)
|
|
return false;
|
|
|
|
if (mode == UNWIND_ARM64_MODE_FRAMELESS) {
|
|
row->SetOffset(0);
|
|
|
|
uint32_t stack_size =
|
|
(EXTRACT_BITS(function_info.encoding,
|
|
UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK)) *
|
|
16;
|
|
|
|
// Our previous Call Frame Address is the stack pointer plus the stack size
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(arm64_eh_regnum::sp, stack_size);
|
|
|
|
// Our previous PC is in the LR
|
|
row->SetRegisterLocationToRegister(arm64_eh_regnum::pc, arm64_eh_regnum::ra,
|
|
true);
|
|
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
}
|
|
|
|
// Should not be possible
|
|
if (mode != UNWIND_ARM64_MODE_FRAME)
|
|
return false;
|
|
|
|
// mode == UNWIND_ARM64_MODE_FRAME
|
|
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(arm64_eh_regnum::fp, 2 * wordsize);
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::fp, wordsize * -2,
|
|
true);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::pc, wordsize * -1,
|
|
true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(arm64_eh_regnum::sp, 0, true);
|
|
|
|
int reg_pairs_saved_count = 1;
|
|
|
|
uint32_t saved_register_bits = function_info.encoding & 0xfff;
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_X19_X20_PAIR) {
|
|
int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x19, cfa_offset,
|
|
true);
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x20, cfa_offset,
|
|
true);
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_X21_X22_PAIR) {
|
|
int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x21, cfa_offset,
|
|
true);
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x22, cfa_offset,
|
|
true);
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_X23_X24_PAIR) {
|
|
int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x23, cfa_offset,
|
|
true);
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x24, cfa_offset,
|
|
true);
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_X25_X26_PAIR) {
|
|
int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x25, cfa_offset,
|
|
true);
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x26, cfa_offset,
|
|
true);
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_X27_X28_PAIR) {
|
|
int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x27, cfa_offset,
|
|
true);
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x28, cfa_offset,
|
|
true);
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
// If we use the v8-v15 regnums here, the unwinder will try to grab 128 bits
|
|
// off the stack;
|
|
// not sure if we have a good way to represent the 64-bitness of these saves.
|
|
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_D8_D9_PAIR) {
|
|
reg_pairs_saved_count++;
|
|
}
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_D10_D11_PAIR) {
|
|
reg_pairs_saved_count++;
|
|
}
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_D12_D13_PAIR) {
|
|
reg_pairs_saved_count++;
|
|
}
|
|
if (saved_register_bits & UNWIND_ARM64_FRAME_D14_D15_PAIR) {
|
|
reg_pairs_saved_count++;
|
|
}
|
|
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
}
|
|
|
|
bool CompactUnwindInfo::CreateUnwindPlan_armv7(Target &target,
|
|
FunctionInfo &function_info,
|
|
UnwindPlan &unwind_plan,
|
|
Address pc_or_function_start) {
|
|
unwind_plan.SetSourceName("compact unwind info");
|
|
unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
|
|
unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
|
|
unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
|
|
|
|
unwind_plan.SetLSDAAddress(function_info.lsda_address);
|
|
unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
|
|
|
|
UnwindPlan::RowSP row(new UnwindPlan::Row);
|
|
|
|
const int wordsize = 4;
|
|
int mode = function_info.encoding & UNWIND_ARM_MODE_MASK;
|
|
|
|
if (mode == UNWIND_ARM_MODE_DWARF)
|
|
return false;
|
|
|
|
uint32_t stack_adjust = (EXTRACT_BITS(function_info.encoding,
|
|
UNWIND_ARM_FRAME_STACK_ADJUST_MASK)) *
|
|
wordsize;
|
|
|
|
row->GetCFAValue().SetIsRegisterPlusOffset(arm_r7,
|
|
(2 * wordsize) + stack_adjust);
|
|
row->SetOffset(0);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
arm_r7, (wordsize * -2) - stack_adjust, true);
|
|
row->SetRegisterLocationToAtCFAPlusOffset(
|
|
arm_pc, (wordsize * -1) - stack_adjust, true);
|
|
row->SetRegisterLocationToIsCFAPlusOffset(arm_sp, 0, true);
|
|
|
|
int cfa_offset = -stack_adjust - (2 * wordsize);
|
|
|
|
uint32_t saved_register_bits = function_info.encoding & 0xff;
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R6) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r6, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R5) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r5, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R4) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r4, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R12) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r12, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R11) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r11, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R10) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r10, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R9) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r9, cfa_offset, true);
|
|
}
|
|
|
|
if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R8) {
|
|
cfa_offset -= wordsize;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_r8, cfa_offset, true);
|
|
}
|
|
|
|
if (mode == UNWIND_ARM_MODE_FRAME_D) {
|
|
uint32_t d_reg_bits =
|
|
EXTRACT_BITS(function_info.encoding, UNWIND_ARM_FRAME_D_REG_COUNT_MASK);
|
|
switch (d_reg_bits) {
|
|
case 0:
|
|
// vpush {d8}
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
|
|
break;
|
|
case 1:
|
|
// vpush {d10}
|
|
// vpush {d8}
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
|
|
break;
|
|
case 2:
|
|
// vpush {d12}
|
|
// vpush {d10}
|
|
// vpush {d8}
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
|
|
break;
|
|
case 3:
|
|
// vpush {d14}
|
|
// vpush {d12}
|
|
// vpush {d10}
|
|
// vpush {d8}
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
|
|
break;
|
|
case 4:
|
|
// vpush {d14}
|
|
// vpush {d12}
|
|
// sp = (sp - 24) & (-16);
|
|
// vst {d8, d9, d10}
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
|
|
|
|
// FIXME we don't have a way to represent reg saves at an specific
|
|
// alignment short of
|
|
// coming up with some DWARF location description.
|
|
|
|
break;
|
|
case 5:
|
|
// vpush {d14}
|
|
// sp = (sp - 40) & (-16);
|
|
// vst {d8, d9, d10, d11}
|
|
// vst {d12}
|
|
|
|
cfa_offset -= 8;
|
|
row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
|
|
|
|
// FIXME we don't have a way to represent reg saves at an specific
|
|
// alignment short of
|
|
// coming up with some DWARF location description.
|
|
|
|
break;
|
|
case 6:
|
|
// sp = (sp - 56) & (-16);
|
|
// vst {d8, d9, d10, d11}
|
|
// vst {d12, d13, d14}
|
|
|
|
// FIXME we don't have a way to represent reg saves at an specific
|
|
// alignment short of
|
|
// coming up with some DWARF location description.
|
|
|
|
break;
|
|
case 7:
|
|
// sp = (sp - 64) & (-16);
|
|
// vst {d8, d9, d10, d11}
|
|
// vst {d12, d13, d14, d15}
|
|
|
|
// FIXME we don't have a way to represent reg saves at an specific
|
|
// alignment short of
|
|
// coming up with some DWARF location description.
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
unwind_plan.AppendRow(row);
|
|
return true;
|
|
}
|