4cc36d2b43
It turns out that for the dwarf information, if a FDE indicates it's pc relative, then pc has to be incremented by the load bias. If not, then it should not be incremented. Previously, the code always subtracted load bias values from pcs, and assumed that all fdes were incremented by load bias values. The new code actually reads the fdes and adjusted the pcs in the fde and in the eh frame hdr so that load bias values are already handled properly. In addition, add dumping of arm exidx values in unwind_reg_info. This allowed verifying that the debug frame in those elf files was being handled properly. Added a new unit test that only has a debug frame that has a non-zero load bias and has fde entries that do not have pc relative encoding. Fix a couple of other small bugs. Bug: 109824792 Test: All libbacktrace/libunwindstack unit tests pass. Test: Ran ART 137-cfi test and 004-ThreadStress. Test: Verify that displaying the fde start and end pc actually match the Test: real data for fde that have pc relative set, and that don't. Test: Verified that the unwind information for arm exidx matches the Test: debug frame data. Change-Id: I707555286b5cb05df9f25489e8c5ede753cfe0fb
915 lines
28 KiB
C++
915 lines
28 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <unwindstack/DwarfError.h>
|
|
#include <unwindstack/DwarfLocation.h>
|
|
#include <unwindstack/DwarfMemory.h>
|
|
#include <unwindstack/DwarfSection.h>
|
|
#include <unwindstack/DwarfStructs.h>
|
|
#include <unwindstack/Log.h>
|
|
#include <unwindstack/Memory.h>
|
|
#include <unwindstack/Regs.h>
|
|
|
|
#include "DwarfCfa.h"
|
|
#include "DwarfDebugFrame.h"
|
|
#include "DwarfEhFrame.h"
|
|
#include "DwarfEncoding.h"
|
|
#include "DwarfOp.h"
|
|
#include "RegsInfo.h"
|
|
|
|
namespace unwindstack {
|
|
|
|
DwarfSection::DwarfSection(Memory* memory) : memory_(memory) {}
|
|
|
|
const DwarfFde* DwarfSection::GetFdeFromPc(uint64_t pc) {
|
|
uint64_t fde_offset;
|
|
if (!GetFdeOffsetFromPc(pc, &fde_offset)) {
|
|
return nullptr;
|
|
}
|
|
const DwarfFde* fde = GetFdeFromOffset(fde_offset);
|
|
if (fde == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Guaranteed pc >= pc_start, need to check pc in the fde range.
|
|
if (pc < fde->pc_end) {
|
|
return fde;
|
|
}
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_STATE;
|
|
return nullptr;
|
|
}
|
|
|
|
bool DwarfSection::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished) {
|
|
// Lookup the pc in the cache.
|
|
auto it = loc_regs_.upper_bound(pc);
|
|
if (it == loc_regs_.end() || pc < it->second.pc_start) {
|
|
last_error_.code = DWARF_ERROR_NONE;
|
|
const DwarfFde* fde = GetFdeFromPc(pc);
|
|
if (fde == nullptr || fde->cie == nullptr) {
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_STATE;
|
|
return false;
|
|
}
|
|
|
|
// Now get the location information for this pc.
|
|
dwarf_loc_regs_t loc_regs;
|
|
if (!GetCfaLocationInfo(pc, fde, &loc_regs)) {
|
|
return false;
|
|
}
|
|
loc_regs.cie = fde->cie;
|
|
|
|
// Store it in the cache.
|
|
it = loc_regs_.emplace(loc_regs.pc_end, std::move(loc_regs)).first;
|
|
}
|
|
|
|
// Now eval the actual registers.
|
|
return Eval(it->second.cie, process_memory, it->second, regs, finished);
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::EvalExpression(const DwarfLocation& loc, Memory* regular_memory,
|
|
AddressType* value,
|
|
RegsInfo<AddressType>* regs_info,
|
|
bool* is_dex_pc) {
|
|
DwarfOp<AddressType> op(&memory_, regular_memory);
|
|
op.set_regs_info(regs_info);
|
|
|
|
// Need to evaluate the op data.
|
|
uint64_t end = loc.values[1];
|
|
uint64_t start = end - loc.values[0];
|
|
if (!op.Eval(start, end)) {
|
|
last_error_ = op.last_error();
|
|
return false;
|
|
}
|
|
if (op.StackSize() == 0) {
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_STATE;
|
|
return false;
|
|
}
|
|
// We don't support an expression that evaluates to a register number.
|
|
if (op.is_register()) {
|
|
last_error_.code = DWARF_ERROR_NOT_IMPLEMENTED;
|
|
return false;
|
|
}
|
|
*value = op.StackAt(0);
|
|
if (is_dex_pc != nullptr && op.dex_pc_set()) {
|
|
*is_dex_pc = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
struct EvalInfo {
|
|
const dwarf_loc_regs_t* loc_regs;
|
|
const DwarfCie* cie;
|
|
Memory* regular_memory;
|
|
AddressType cfa;
|
|
bool return_address_undefined = false;
|
|
RegsInfo<AddressType> regs_info;
|
|
};
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::EvalRegister(const DwarfLocation* loc, uint32_t reg,
|
|
AddressType* reg_ptr, void* info) {
|
|
EvalInfo<AddressType>* eval_info = reinterpret_cast<EvalInfo<AddressType>*>(info);
|
|
Memory* regular_memory = eval_info->regular_memory;
|
|
switch (loc->type) {
|
|
case DWARF_LOCATION_OFFSET:
|
|
if (!regular_memory->ReadFully(eval_info->cfa + loc->values[0], reg_ptr, sizeof(AddressType))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = eval_info->cfa + loc->values[0];
|
|
return false;
|
|
}
|
|
break;
|
|
case DWARF_LOCATION_VAL_OFFSET:
|
|
*reg_ptr = eval_info->cfa + loc->values[0];
|
|
break;
|
|
case DWARF_LOCATION_REGISTER: {
|
|
uint32_t cur_reg = loc->values[0];
|
|
if (cur_reg >= eval_info->regs_info.Total()) {
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
*reg_ptr = eval_info->regs_info.Get(cur_reg) + loc->values[1];
|
|
break;
|
|
}
|
|
case DWARF_LOCATION_EXPRESSION:
|
|
case DWARF_LOCATION_VAL_EXPRESSION: {
|
|
AddressType value;
|
|
bool is_dex_pc = false;
|
|
if (!EvalExpression(*loc, regular_memory, &value, &eval_info->regs_info, &is_dex_pc)) {
|
|
return false;
|
|
}
|
|
if (loc->type == DWARF_LOCATION_EXPRESSION) {
|
|
if (!regular_memory->ReadFully(value, reg_ptr, sizeof(AddressType))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = value;
|
|
return false;
|
|
}
|
|
} else {
|
|
*reg_ptr = value;
|
|
if (is_dex_pc) {
|
|
eval_info->regs_info.regs->set_dex_pc(value);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case DWARF_LOCATION_UNDEFINED:
|
|
if (reg == eval_info->cie->return_address_register) {
|
|
eval_info->return_address_undefined = true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::Eval(const DwarfCie* cie, Memory* regular_memory,
|
|
const dwarf_loc_regs_t& loc_regs, Regs* regs,
|
|
bool* finished) {
|
|
RegsImpl<AddressType>* cur_regs = reinterpret_cast<RegsImpl<AddressType>*>(regs);
|
|
if (cie->return_address_register >= cur_regs->total_regs()) {
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
// Get the cfa value;
|
|
auto cfa_entry = loc_regs.find(CFA_REG);
|
|
if (cfa_entry == loc_regs.end()) {
|
|
last_error_.code = DWARF_ERROR_CFA_NOT_DEFINED;
|
|
return false;
|
|
}
|
|
|
|
// Always set the dex pc to zero when evaluating.
|
|
cur_regs->set_dex_pc(0);
|
|
|
|
EvalInfo<AddressType> eval_info{.loc_regs = &loc_regs,
|
|
.cie = cie,
|
|
.regular_memory = regular_memory,
|
|
.regs_info = RegsInfo<AddressType>(cur_regs)};
|
|
const DwarfLocation* loc = &cfa_entry->second;
|
|
// Only a few location types are valid for the cfa.
|
|
switch (loc->type) {
|
|
case DWARF_LOCATION_REGISTER:
|
|
if (loc->values[0] >= cur_regs->total_regs()) {
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
eval_info.cfa = (*cur_regs)[loc->values[0]];
|
|
eval_info.cfa += loc->values[1];
|
|
break;
|
|
case DWARF_LOCATION_VAL_EXPRESSION: {
|
|
AddressType value;
|
|
if (!EvalExpression(*loc, regular_memory, &value, &eval_info.regs_info, nullptr)) {
|
|
return false;
|
|
}
|
|
// There is only one type of valid expression for CFA evaluation.
|
|
eval_info.cfa = value;
|
|
break;
|
|
}
|
|
default:
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
for (const auto& entry : loc_regs) {
|
|
uint32_t reg = entry.first;
|
|
// Already handled the CFA register.
|
|
if (reg == CFA_REG) continue;
|
|
|
|
AddressType* reg_ptr;
|
|
if (reg >= cur_regs->total_regs()) {
|
|
// Skip this unknown register.
|
|
continue;
|
|
}
|
|
|
|
reg_ptr = eval_info.regs_info.Save(reg);
|
|
if (!EvalRegister(&entry.second, reg, reg_ptr, &eval_info)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Find the return address location.
|
|
if (eval_info.return_address_undefined) {
|
|
cur_regs->set_pc(0);
|
|
} else {
|
|
cur_regs->set_pc((*cur_regs)[cie->return_address_register]);
|
|
}
|
|
|
|
// If the pc was set to zero, consider this the final frame.
|
|
*finished = (cur_regs->pc() == 0) ? true : false;
|
|
|
|
cur_regs->set_sp(eval_info.cfa);
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
const DwarfCie* DwarfSectionImpl<AddressType>::GetCie(uint64_t offset) {
|
|
auto cie_entry = cie_entries_.find(offset);
|
|
if (cie_entry != cie_entries_.end()) {
|
|
return &cie_entry->second;
|
|
}
|
|
DwarfCie* cie = &cie_entries_[offset];
|
|
memory_.set_cur_offset(offset);
|
|
if (!FillInCie(cie)) {
|
|
// Erase the cached entry.
|
|
cie_entries_.erase(offset);
|
|
return nullptr;
|
|
}
|
|
return cie;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::FillInCie(DwarfCie* cie) {
|
|
uint32_t length32;
|
|
if (!memory_.ReadBytes(&length32, sizeof(length32))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
// Set the default for the lsda encoding.
|
|
cie->lsda_encoding = DW_EH_PE_omit;
|
|
|
|
if (length32 == static_cast<uint32_t>(-1)) {
|
|
// 64 bit Cie
|
|
uint64_t length64;
|
|
if (!memory_.ReadBytes(&length64, sizeof(length64))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
cie->cfa_instructions_end = memory_.cur_offset() + length64;
|
|
cie->fde_address_encoding = DW_EH_PE_sdata8;
|
|
|
|
uint64_t cie_id;
|
|
if (!memory_.ReadBytes(&cie_id, sizeof(cie_id))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (cie_id != cie64_value_) {
|
|
// This is not a Cie, something has gone horribly wrong.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
} else {
|
|
// 32 bit Cie
|
|
cie->cfa_instructions_end = memory_.cur_offset() + length32;
|
|
cie->fde_address_encoding = DW_EH_PE_sdata4;
|
|
|
|
uint32_t cie_id;
|
|
if (!memory_.ReadBytes(&cie_id, sizeof(cie_id))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (cie_id != cie32_value_) {
|
|
// This is not a Cie, something has gone horribly wrong.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!memory_.ReadBytes(&cie->version, sizeof(cie->version))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (cie->version != 1 && cie->version != 3 && cie->version != 4) {
|
|
// Unrecognized version.
|
|
last_error_.code = DWARF_ERROR_UNSUPPORTED_VERSION;
|
|
return false;
|
|
}
|
|
|
|
// Read the augmentation string.
|
|
char aug_value;
|
|
do {
|
|
if (!memory_.ReadBytes(&aug_value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
cie->augmentation_string.push_back(aug_value);
|
|
} while (aug_value != '\0');
|
|
|
|
if (cie->version == 4) {
|
|
// Skip the Address Size field since we only use it for validation.
|
|
memory_.set_cur_offset(memory_.cur_offset() + 1);
|
|
|
|
// Segment Size
|
|
if (!memory_.ReadBytes(&cie->segment_size, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Code Alignment Factor
|
|
if (!memory_.ReadULEB128(&cie->code_alignment_factor)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
// Data Alignment Factor
|
|
if (!memory_.ReadSLEB128(&cie->data_alignment_factor)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (cie->version == 1) {
|
|
// Return Address is a single byte.
|
|
uint8_t return_address_register;
|
|
if (!memory_.ReadBytes(&return_address_register, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
cie->return_address_register = return_address_register;
|
|
} else if (!memory_.ReadULEB128(&cie->return_address_register)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (cie->augmentation_string[0] != 'z') {
|
|
cie->cfa_instructions_offset = memory_.cur_offset();
|
|
return true;
|
|
}
|
|
|
|
uint64_t aug_length;
|
|
if (!memory_.ReadULEB128(&aug_length)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
cie->cfa_instructions_offset = memory_.cur_offset() + aug_length;
|
|
|
|
for (size_t i = 1; i < cie->augmentation_string.size(); i++) {
|
|
switch (cie->augmentation_string[i]) {
|
|
case 'L':
|
|
if (!memory_.ReadBytes(&cie->lsda_encoding, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
break;
|
|
case 'P': {
|
|
uint8_t encoding;
|
|
if (!memory_.ReadBytes(&encoding, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
memory_.set_pc_offset(pc_offset_);
|
|
if (!memory_.ReadEncodedValue<AddressType>(encoding, &cie->personality_handler)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} break;
|
|
case 'R':
|
|
if (!memory_.ReadBytes(&cie->fde_address_encoding, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
const DwarfFde* DwarfSectionImpl<AddressType>::GetFdeFromOffset(uint64_t offset) {
|
|
auto fde_entry = fde_entries_.find(offset);
|
|
if (fde_entry != fde_entries_.end()) {
|
|
return &fde_entry->second;
|
|
}
|
|
DwarfFde* fde = &fde_entries_[offset];
|
|
memory_.set_cur_offset(offset);
|
|
if (!FillInFde(fde)) {
|
|
fde_entries_.erase(offset);
|
|
return nullptr;
|
|
}
|
|
return fde;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::FillInFde(DwarfFde* fde) {
|
|
uint32_t length32;
|
|
if (!memory_.ReadBytes(&length32, sizeof(length32))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (length32 == static_cast<uint32_t>(-1)) {
|
|
// 64 bit Fde.
|
|
uint64_t length64;
|
|
if (!memory_.ReadBytes(&length64, sizeof(length64))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
fde->cfa_instructions_end = memory_.cur_offset() + length64;
|
|
|
|
uint64_t value64;
|
|
if (!memory_.ReadBytes(&value64, sizeof(value64))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (value64 == cie64_value_) {
|
|
// This is a Cie, this means something has gone wrong.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
// Get the Cie pointer, which is necessary to properly read the rest of
|
|
// of the Fde information.
|
|
fde->cie_offset = GetCieOffsetFromFde64(value64);
|
|
} else {
|
|
// 32 bit Fde.
|
|
fde->cfa_instructions_end = memory_.cur_offset() + length32;
|
|
|
|
uint32_t value32;
|
|
if (!memory_.ReadBytes(&value32, sizeof(value32))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (value32 == cie32_value_) {
|
|
// This is a Cie, this means something has gone wrong.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
// Get the Cie pointer, which is necessary to properly read the rest of
|
|
// of the Fde information.
|
|
fde->cie_offset = GetCieOffsetFromFde32(value32);
|
|
}
|
|
uint64_t cur_offset = memory_.cur_offset();
|
|
|
|
const DwarfCie* cie = GetCie(fde->cie_offset);
|
|
if (cie == nullptr) {
|
|
return false;
|
|
}
|
|
fde->cie = cie;
|
|
|
|
if (cie->segment_size != 0) {
|
|
// Skip over the segment selector for now.
|
|
cur_offset += cie->segment_size;
|
|
}
|
|
memory_.set_cur_offset(cur_offset);
|
|
|
|
// The load bias only applies to the start.
|
|
memory_.set_pc_offset(load_bias_);
|
|
bool valid = memory_.ReadEncodedValue<AddressType>(cie->fde_address_encoding, &fde->pc_start);
|
|
fde->pc_start = AdjustPcFromFde(fde->pc_start);
|
|
|
|
memory_.set_pc_offset(0);
|
|
if (!valid || !memory_.ReadEncodedValue<AddressType>(cie->fde_address_encoding, &fde->pc_end)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
fde->pc_end += fde->pc_start;
|
|
|
|
if (cie->augmentation_string.size() > 0 && cie->augmentation_string[0] == 'z') {
|
|
// Augmentation Size
|
|
uint64_t aug_length;
|
|
if (!memory_.ReadULEB128(&aug_length)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
uint64_t cur_offset = memory_.cur_offset();
|
|
|
|
memory_.set_pc_offset(pc_offset_);
|
|
if (!memory_.ReadEncodedValue<AddressType>(cie->lsda_encoding, &fde->lsda_address)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
// Set our position to after all of the augmentation data.
|
|
memory_.set_cur_offset(cur_offset + aug_length);
|
|
}
|
|
fde->cfa_instructions_offset = memory_.cur_offset();
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::GetCfaLocationInfo(uint64_t pc, const DwarfFde* fde,
|
|
dwarf_loc_regs_t* loc_regs) {
|
|
DwarfCfa<AddressType> cfa(&memory_, fde);
|
|
|
|
// Look for the cached copy of the cie data.
|
|
auto reg_entry = cie_loc_regs_.find(fde->cie_offset);
|
|
if (reg_entry == cie_loc_regs_.end()) {
|
|
if (!cfa.GetLocationInfo(pc, fde->cie->cfa_instructions_offset, fde->cie->cfa_instructions_end,
|
|
loc_regs)) {
|
|
last_error_ = cfa.last_error();
|
|
return false;
|
|
}
|
|
cie_loc_regs_[fde->cie_offset] = *loc_regs;
|
|
}
|
|
cfa.set_cie_loc_regs(&cie_loc_regs_[fde->cie_offset]);
|
|
if (!cfa.GetLocationInfo(pc, fde->cfa_instructions_offset, fde->cfa_instructions_end, loc_regs)) {
|
|
last_error_ = cfa.last_error();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::Log(uint8_t indent, uint64_t pc, const DwarfFde* fde) {
|
|
DwarfCfa<AddressType> cfa(&memory_, fde);
|
|
|
|
// Always print the cie information.
|
|
const DwarfCie* cie = fde->cie;
|
|
if (!cfa.Log(indent, pc, cie->cfa_instructions_offset, cie->cfa_instructions_end)) {
|
|
last_error_ = cfa.last_error();
|
|
return false;
|
|
}
|
|
if (!cfa.Log(indent, pc, fde->cfa_instructions_offset, fde->cfa_instructions_end)) {
|
|
last_error_ = cfa.last_error();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::Init(uint64_t offset, uint64_t size, uint64_t load_bias) {
|
|
load_bias_ = load_bias;
|
|
entries_offset_ = offset;
|
|
entries_end_ = offset + size;
|
|
|
|
memory_.clear_func_offset();
|
|
memory_.clear_text_offset();
|
|
memory_.set_cur_offset(offset);
|
|
memory_.set_data_offset(offset);
|
|
pc_offset_ = offset;
|
|
|
|
return CreateSortedFdeList();
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::GetCieInfo(uint8_t* segment_size, uint8_t* encoding) {
|
|
uint8_t version;
|
|
if (!memory_.ReadBytes(&version, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
// Read the augmentation string.
|
|
std::vector<char> aug_string;
|
|
char aug_value;
|
|
bool get_encoding = false;
|
|
do {
|
|
if (!memory_.ReadBytes(&aug_value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (aug_value == 'R') {
|
|
get_encoding = true;
|
|
}
|
|
aug_string.push_back(aug_value);
|
|
} while (aug_value != '\0');
|
|
|
|
if (version == 4) {
|
|
// Skip the Address Size field.
|
|
memory_.set_cur_offset(memory_.cur_offset() + 1);
|
|
|
|
// Read the segment size.
|
|
if (!memory_.ReadBytes(segment_size, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} else {
|
|
*segment_size = 0;
|
|
}
|
|
|
|
if (aug_string[0] != 'z' || !get_encoding) {
|
|
// No encoding
|
|
return true;
|
|
}
|
|
|
|
// Skip code alignment factor
|
|
uint8_t value;
|
|
do {
|
|
if (!memory_.ReadBytes(&value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} while (value & 0x80);
|
|
|
|
// Skip data alignment factor
|
|
do {
|
|
if (!memory_.ReadBytes(&value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} while (value & 0x80);
|
|
|
|
if (version == 1) {
|
|
// Skip return address register.
|
|
memory_.set_cur_offset(memory_.cur_offset() + 1);
|
|
} else {
|
|
// Skip return address register.
|
|
do {
|
|
if (!memory_.ReadBytes(&value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} while (value & 0x80);
|
|
}
|
|
|
|
// Skip the augmentation length.
|
|
do {
|
|
if (!memory_.ReadBytes(&value, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
} while (value & 0x80);
|
|
|
|
for (size_t i = 1; i < aug_string.size(); i++) {
|
|
if (aug_string[i] == 'R') {
|
|
if (!memory_.ReadBytes(encoding, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
// Got the encoding, that's all we are looking for.
|
|
return true;
|
|
} else if (aug_string[i] == 'L') {
|
|
memory_.set_cur_offset(memory_.cur_offset() + 1);
|
|
} else if (aug_string[i] == 'P') {
|
|
uint8_t encoding;
|
|
if (!memory_.ReadBytes(&encoding, 1)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
uint64_t value;
|
|
memory_.set_pc_offset(pc_offset_);
|
|
if (!memory_.template ReadEncodedValue<AddressType>(encoding, &value)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// It should be impossible to get here.
|
|
abort();
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::AddFdeInfo(uint64_t entry_offset, uint8_t segment_size,
|
|
uint8_t encoding) {
|
|
if (segment_size != 0) {
|
|
memory_.set_cur_offset(memory_.cur_offset() + 1);
|
|
}
|
|
|
|
uint64_t start;
|
|
memory_.set_pc_offset(load_bias_);
|
|
bool valid = memory_.template ReadEncodedValue<AddressType>(encoding, &start);
|
|
start = AdjustPcFromFde(start);
|
|
|
|
uint64_t length;
|
|
memory_.set_pc_offset(0);
|
|
if (!valid || !memory_.template ReadEncodedValue<AddressType>(encoding, &length)) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
if (length != 0) {
|
|
fdes_.emplace_back(entry_offset, start, length);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::CreateSortedFdeList() {
|
|
memory_.set_cur_offset(entries_offset_);
|
|
|
|
// Loop through all of the entries and read just enough to create
|
|
// a sorted list of pcs.
|
|
// This code assumes that first comes the cie, then the fdes that
|
|
// it applies to.
|
|
uint64_t cie_offset = 0;
|
|
uint8_t address_encoding;
|
|
uint8_t segment_size;
|
|
while (memory_.cur_offset() < entries_end_) {
|
|
uint64_t cur_entry_offset = memory_.cur_offset();
|
|
|
|
// Figure out the entry length and type.
|
|
uint32_t value32;
|
|
if (!memory_.ReadBytes(&value32, sizeof(value32))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
uint64_t next_entry_offset;
|
|
if (value32 == static_cast<uint32_t>(-1)) {
|
|
uint64_t value64;
|
|
if (!memory_.ReadBytes(&value64, sizeof(value64))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
next_entry_offset = memory_.cur_offset() + value64;
|
|
|
|
// Read the Cie Id of a Cie or the pointer of the Fde.
|
|
if (!memory_.ReadBytes(&value64, sizeof(value64))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (value64 == cie64_value_) {
|
|
// Cie 64 bit
|
|
address_encoding = DW_EH_PE_sdata8;
|
|
if (!GetCieInfo(&segment_size, &address_encoding)) {
|
|
return false;
|
|
}
|
|
cie_offset = cur_entry_offset;
|
|
} else {
|
|
uint64_t last_cie_offset = GetCieOffsetFromFde64(value64);
|
|
if (last_cie_offset != cie_offset) {
|
|
// This means that this Fde is not following the Cie.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
// Fde 64 bit
|
|
if (!AddFdeInfo(cur_entry_offset, segment_size, address_encoding)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
next_entry_offset = memory_.cur_offset() + value32;
|
|
|
|
// Read the Cie Id of a Cie or the pointer of the Fde.
|
|
if (!memory_.ReadBytes(&value32, sizeof(value32))) {
|
|
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
|
|
last_error_.address = memory_.cur_offset();
|
|
return false;
|
|
}
|
|
|
|
if (value32 == cie32_value_) {
|
|
// Cie 32 bit
|
|
address_encoding = DW_EH_PE_sdata4;
|
|
if (!GetCieInfo(&segment_size, &address_encoding)) {
|
|
return false;
|
|
}
|
|
cie_offset = cur_entry_offset;
|
|
} else {
|
|
uint64_t last_cie_offset = GetCieOffsetFromFde32(value32);
|
|
if (last_cie_offset != cie_offset) {
|
|
// This means that this Fde is not following the Cie.
|
|
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
|
|
return false;
|
|
}
|
|
|
|
// Fde 32 bit
|
|
if (!AddFdeInfo(cur_entry_offset, segment_size, address_encoding)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (next_entry_offset < memory_.cur_offset()) {
|
|
// Simply consider the processing done in this case.
|
|
break;
|
|
}
|
|
memory_.set_cur_offset(next_entry_offset);
|
|
}
|
|
|
|
// Sort the entries.
|
|
std::sort(fdes_.begin(), fdes_.end(), [](const FdeInfo& a, const FdeInfo& b) {
|
|
if (a.start == b.start) return a.end < b.end;
|
|
return a.start < b.start;
|
|
});
|
|
|
|
fde_count_ = fdes_.size();
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
bool DwarfSectionImpl<AddressType>::GetFdeOffsetFromPc(uint64_t pc, uint64_t* fde_offset) {
|
|
if (fde_count_ == 0) {
|
|
return false;
|
|
}
|
|
|
|
size_t first = 0;
|
|
size_t last = fde_count_;
|
|
while (first < last) {
|
|
size_t current = (first + last) / 2;
|
|
const FdeInfo* info = &fdes_[current];
|
|
if (pc >= info->start && pc < info->end) {
|
|
*fde_offset = info->offset;
|
|
return true;
|
|
}
|
|
|
|
if (pc < info->start) {
|
|
last = current;
|
|
} else {
|
|
first = current + 1;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template <typename AddressType>
|
|
const DwarfFde* DwarfSectionImpl<AddressType>::GetFdeFromIndex(size_t index) {
|
|
if (index >= fdes_.size()) {
|
|
return nullptr;
|
|
}
|
|
return this->GetFdeFromOffset(fdes_[index].offset);
|
|
}
|
|
|
|
// Explicitly instantiate DwarfSectionImpl
|
|
template class DwarfSectionImpl<uint32_t>;
|
|
template class DwarfSectionImpl<uint64_t>;
|
|
|
|
// Explicitly instantiate DwarfDebugFrame
|
|
template class DwarfDebugFrame<uint32_t>;
|
|
template class DwarfDebugFrame<uint64_t>;
|
|
|
|
// Explicitly instantiate DwarfEhFrame
|
|
template class DwarfEhFrame<uint32_t>;
|
|
template class DwarfEhFrame<uint64_t>;
|
|
|
|
} // namespace unwindstack
|