/* * 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; } 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); if (!memory_.ReadEncodedValue<AddressType>(cie->fde_address_encoding & 0xf, &fde->pc_start)) { last_error_.code = DWARF_ERROR_MEMORY_INVALID; last_error_.address = memory_.cur_offset(); return false; } fde->pc_start = AdjustPcFromFde(fde->pc_start); if (!memory_.ReadEncodedValue<AddressType>(cie->fde_address_encoding & 0xf, &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(); 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, uint64_t load_bias, const DwarfFde* fde) { DwarfCfa<AddressType> cfa(&memory_, fde); // Always print the cie information. const DwarfCie* cie = fde->cie; if (!cfa.Log(indent, pc, load_bias, cie->cfa_instructions_offset, cie->cfa_instructions_end)) { last_error_ = cfa.last_error(); return false; } if (!cfa.Log(indent, pc, load_bias, 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) { entries_offset_ = offset; entries_end_ = offset + size; memory_.clear_func_offset(); memory_.clear_text_offset(); memory_.set_data_offset(offset); memory_.set_cur_offset(offset); memory_.set_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; 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; if (!memory_.template ReadEncodedValue<AddressType>(encoding & 0xf, &start)) { last_error_.code = DWARF_ERROR_MEMORY_INVALID; last_error_.address = memory_.cur_offset(); return false; } start = AdjustPcFromFde(start); uint64_t length; if (!memory_.template ReadEncodedValue<AddressType>(encoding & 0xf, &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