| /* Copyright (C) 2007-2010 The Android Open Source Project | |
| ** | |
| ** This software is licensed under the terms of the GNU General Public | |
| ** License version 2, as published by the Free Software Foundation, and | |
| ** may be copied, distributed, and modified under those terms. | |
| ** | |
| ** This program is distributed in the hope that it will be useful, | |
| ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| ** GNU General Public License for more details. | |
| */ | |
| /* | |
| * Contains implementation of a class DwarfCU, that encapsulates a compilation | |
| * unit in the .debug_info section of the mapped ELF file. | |
| */ | |
| #include "string.h" | |
| #include "stdio.h" | |
| #include "elf_file.h" | |
| #include "dwarf_cu.h" | |
| #include "dwarf_utils.h" | |
| DwarfCU::DwarfCU(ElfFile* elf) | |
| : elf_file_(elf), | |
| cu_die_(NULL), | |
| prev_cu_(NULL) { | |
| } | |
| DwarfCU::~DwarfCU() { | |
| if (cu_die_ != NULL) { | |
| delete cu_die_; | |
| } | |
| abbrs_.empty(); | |
| } | |
| DwarfCU* DwarfCU::create_instance(ElfFile* elf, const void* hdr) { | |
| DwarfCU* ret; | |
| /* 64-bit DWARF CU has first 4 bytes in its header set to 0xFFFFFFFF. */ | |
| if (*reinterpret_cast<const Elf_Word*>(hdr) == 0xFFFFFFFF) { | |
| ret = new(elf) DwarfCUImpl<Dwarf64_CUHdr, Dwarf64_Off> | |
| (elf, reinterpret_cast<const Dwarf64_CUHdr*>(hdr)); | |
| } else { | |
| ret = new(elf) DwarfCUImpl<Dwarf32_CUHdr, Dwarf32_Off> | |
| (elf, reinterpret_cast<const Dwarf32_CUHdr*>(hdr)); | |
| } | |
| assert(ret != NULL); | |
| if (ret == NULL) { | |
| _set_errno(ENOMEM); | |
| } | |
| return ret; | |
| } | |
| const Elf_Byte* DwarfCU::process_attrib(const Elf_Byte* prop, | |
| Dwarf_Form form, | |
| Dwarf_Value* attr_value) const { | |
| assert(form != 0); | |
| Dwarf_Value tmp_val; | |
| Dwarf_Value leb128; | |
| attr_value->type = DWARF_VALUE_UNKNOWN; | |
| attr_value->encoded_size = 0; | |
| attr_value->u64 = 0; | |
| switch (form) { | |
| /* Property is a block of data, contained in .debug_info section. Block | |
| * size is encoded with 1 byte value, and block data immediately follows | |
| * block size. */ | |
| case DW_FORM_block1: | |
| attr_value->type = DWARF_VALUE_BLOCK; | |
| attr_value->block.block_size = *prop; | |
| attr_value->block.block_ptr = prop + 1; | |
| attr_value->encoded_size = | |
| static_cast<Elf_Word>(attr_value->block.block_size + 1); | |
| break; | |
| /* Property is a block of data, contained in .debug_info section. Block | |
| * size is encoded with 2 bytes value, and block data immediately follows | |
| * block size. */ | |
| case DW_FORM_block2: | |
| attr_value->type = DWARF_VALUE_BLOCK; | |
| attr_value->block.block_size = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Half*>(prop)); | |
| attr_value->block.block_ptr = prop + 2; | |
| attr_value->encoded_size = | |
| static_cast<Elf_Word>(attr_value->block.block_size + 2); | |
| break; | |
| /* Property is a block of data, contained in .debug_info section. Block | |
| * size is encoded with 4 bytes value, and block data immediately follows | |
| * block size. */ | |
| case DW_FORM_block4: | |
| attr_value->type = DWARF_VALUE_BLOCK; | |
| attr_value->block.block_size = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->block.block_ptr = prop + 4; | |
| attr_value->encoded_size = | |
| static_cast<Elf_Word>(attr_value->block.block_size + 4); | |
| break; | |
| /* Property is a block of data, contained in .debug_info section. Block | |
| * size is encoded with unsigned LEB128 value, and block data immediately | |
| * follows block size. */ | |
| case DW_FORM_block: | |
| reinterpret_cast<const Dwarf_Leb128*>(prop)->process_unsigned(&leb128); | |
| attr_value->type = DWARF_VALUE_BLOCK; | |
| attr_value->block.block_size = leb128.u32; | |
| attr_value->block.block_ptr = prop + leb128.encoded_size; | |
| attr_value->encoded_size = | |
| static_cast<Elf_Word>(attr_value->block.block_size + | |
| leb128.encoded_size); | |
| break; | |
| /* Property is unsigned 1 byte value. */ | |
| case DW_FORM_flag: | |
| case DW_FORM_data1: | |
| case DW_FORM_ref1: | |
| attr_value->type = DWARF_VALUE_U8; | |
| attr_value->u8 = *prop; | |
| attr_value->encoded_size = 1; | |
| break; | |
| /* Property is unsigned 2 bytes value. */ | |
| case DW_FORM_data2: | |
| case DW_FORM_ref2: | |
| attr_value->type = DWARF_VALUE_U16; | |
| attr_value->u16 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Half*>(prop)); | |
| attr_value->encoded_size = 2; | |
| break; | |
| /* Property is unsigned 4 bytes value. */ | |
| case DW_FORM_data4: | |
| case DW_FORM_ref4: | |
| attr_value->type = DWARF_VALUE_U32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->encoded_size = 4; | |
| break; | |
| /* Property is unsigned 8 bytes value. */ | |
| case DW_FORM_data8: | |
| case DW_FORM_ref8: | |
| case DW_FORM_ref_sig8: | |
| attr_value->type = DWARF_VALUE_U64; | |
| attr_value->u64 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| attr_value->encoded_size = 8; | |
| break; | |
| /* Property is signed LEB128 value. */ | |
| case DW_FORM_sdata: | |
| reinterpret_cast<const Dwarf_Leb128*>(prop)->process_signed(attr_value); | |
| break; | |
| /* Property is unsigned LEB128 value. */ | |
| case DW_FORM_ref_udata: | |
| case DW_FORM_udata: | |
| reinterpret_cast<const Dwarf_Leb128*>(prop)->process_unsigned(attr_value); | |
| break; | |
| /* Property is a string contained directly in .debug_info section. */ | |
| case DW_FORM_string: | |
| attr_value->type = DWARF_VALUE_STR; | |
| attr_value->str = reinterpret_cast<const char*>(prop); | |
| attr_value->encoded_size = strlen(attr_value->str) + 1; | |
| break; | |
| /* Property is an offset of a string contained in .debug_str section. | |
| * We will process the reference here, converting it into the actual | |
| * string value. */ | |
| case DW_FORM_strp: | |
| attr_value->type = DWARF_VALUE_STR; | |
| if (elf_file_->is_DWARF_64()) { | |
| Elf_Xword str_offset = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| attr_value->str = elf_file_->get_debug_str(str_offset); | |
| attr_value->encoded_size = 8; | |
| } else { | |
| Elf_Word str_offset = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->str = elf_file_->get_debug_str(str_offset); | |
| attr_value->encoded_size = 4; | |
| } | |
| break; | |
| /* Property is an address. */ | |
| case DW_FORM_addr: | |
| if (addr_sizeof_ == 4) { | |
| attr_value->type = DWARF_VALUE_PTR32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| } else { | |
| attr_value->type = DWARF_VALUE_PTR64; | |
| attr_value->u64 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| } | |
| attr_value->encoded_size = addr_sizeof_; | |
| break; | |
| /* Reference from the beginning of .debug_info section. */ | |
| case DW_FORM_ref_addr: | |
| /* DWARF3+ requires that encoding size of this property must be 4 bytes | |
| * in 32-bit DWARF, and 8 bytes in 64-bit DWARF, while DWARF2- requires | |
| * encoding size to be equal to CU's pointer size. */ | |
| if (is_DWARF3_or_higher()) { | |
| if (elf_file_->is_DWARF_64()) { | |
| attr_value->type = DWARF_VALUE_U64; | |
| attr_value->u64 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| attr_value->encoded_size = 4; | |
| } else { | |
| attr_value->type = DWARF_VALUE_U32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->encoded_size = 8; | |
| } | |
| } else { | |
| if (addr_sizeof_ == 4) { | |
| attr_value->type = DWARF_VALUE_U32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| } else { | |
| attr_value->type = DWARF_VALUE_U64; | |
| attr_value->u64 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| } | |
| attr_value->encoded_size = addr_sizeof_; | |
| } | |
| break; | |
| /* Reference to a section, other than .debug_info, or .debug_str */ | |
| case DW_FORM_sec_offset: | |
| if (elf_file_->is_DWARF_64()) { | |
| attr_value->type = DWARF_VALUE_U64; | |
| attr_value->u64 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop)); | |
| attr_value->encoded_size = 4; | |
| } else { | |
| attr_value->type = DWARF_VALUE_U32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->encoded_size = 8; | |
| } | |
| break; | |
| /* This is a replacement for DW_FORM_flag, which doesn't consume memory | |
| * in .debug_info section, and only by the fact of its existence it is | |
| * equal to DW_FORM_flag with value set to 1. */ | |
| case DW_FORM_flag_present: | |
| attr_value->type = DWARF_VALUE_U8; | |
| attr_value->u8 = 1; | |
| attr_value->encoded_size = 0; | |
| break; | |
| /* Encodes the actual form to be used. */ | |
| case DW_FORM_indirect: | |
| // Starts with ULEB128 | |
| prop = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*> | |
| (prop)->process_unsigned(&tmp_val)); | |
| /* ULEB128 encodes the actual form to be used to process this entry. */ | |
| process_attrib(prop, tmp_val.u16, attr_value); | |
| attr_value->encoded_size += tmp_val.encoded_size; | |
| break; | |
| /* This form is defined for DWARF4, and has no documentation whatsoever. */ | |
| case DW_FORM_exprloc: | |
| default: | |
| attr_value->type = DWARF_VALUE_U32; | |
| attr_value->u32 = | |
| elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop)); | |
| attr_value->encoded_size = 4; | |
| break; | |
| } | |
| return prop + attr_value->encoded_size; | |
| } | |
| void DwarfCU::dump() const { | |
| printf("\n\n>>>>>>>>>>>>>>> CU %p (version %u, address size %u)\n", | |
| cu_die_->die(), static_cast<Elf_Word>(version_), | |
| static_cast<Elf_Word>(addr_sizeof_)); | |
| printf(">>>>> Build dir path: %s\n", comp_dir_path()); | |
| printf(">>>>> Build file path: %s\n", rel_cu_path()); | |
| if (cu_die_ != NULL) { | |
| cu_die_->dump(false); | |
| } | |
| } | |
| //============================================================================= | |
| // DwarfCUImpl implementation | |
| //============================================================================= | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::DwarfCUImpl(ElfFile* elf, | |
| const Dwarf_CUHdr* hdr) | |
| : DwarfCU(elf), | |
| cu_header_(hdr) { | |
| /* Cache CU's DIE abbreviation descriptor in the array. This MUST be done | |
| * BEFORE first call to array's cache_to() method. */ | |
| const Dwarf_Abbr_DIE* cu_abbr_die = reinterpret_cast<const Dwarf_Abbr_DIE*> | |
| (INC_CPTR(elf->get_debug_abbrev_data(), | |
| elf->pull_val(hdr->abbrev_offset))); | |
| abbrs_.add(cu_abbr_die); | |
| cu_size_ = elf->pull_val(hdr->size_hdr.size); | |
| version_ = elf->pull_val(hdr->version); | |
| addr_sizeof_ = hdr->address_size; | |
| memset(&stmtl_header_, 0, sizeof(stmtl_header_)); | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::parse( | |
| const DwarfParseContext* parse_context, | |
| const void** next_cu_die) { | |
| /* Start parsing with the DIE for this CU. */ | |
| if (process_DIE(parse_context, get_DIE(), NULL) == NULL) { | |
| return false; | |
| } | |
| /* CU area size (thus, next CU header offset) in .debug_info section equals | |
| * to CU size, plus number of bytes, required to encode CU size in CU header | |
| * (4 for 32-bit CU, and 12 for 64-bit CU. */ | |
| *next_cu_die = | |
| INC_CPTR(cu_header_, cu_size_ + ELFF_FIELD_OFFSET(Dwarf_CUHdr, version)); | |
| return true; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| const Elf_Byte* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::process_DIE( | |
| const DwarfParseContext* parse_context, | |
| const Dwarf_DIE* die, | |
| DIEObject* parent_obj) { | |
| while (is_attrib_ptr_valid(die) && !die->is_separator()) { | |
| Dwarf_AbbrNum abbr_num; | |
| Dwarf_Tag die_tag; | |
| Elf_Word sibling_off = 0; | |
| /* Get DIE's abbreviation number, and advance to DIE's properties. */ | |
| const Elf_Byte* die_attr = die->process(&abbr_num); | |
| /* Get abbreviation for the current DIE. */ | |
| const Dwarf_Abbr_DIE* die_abbr = abbrs_.cache_to(abbr_num); | |
| if (die_abbr == NULL) { | |
| return NULL; | |
| } | |
| /* Get base DIE properties, and advance to the DIE's | |
| * attribute descriptors. */ | |
| const Dwarf_Abbr_AT* at_abbr = die_abbr->process(NULL, &die_tag); | |
| /* Instantiate DIE object for this DIE, and get list of properties, | |
| * that should be collected while processing that DIE. */ | |
| DIEObject* die_obj = | |
| create_die_object(parse_context, die, parent_obj, die_tag); | |
| if (die_obj == NULL && errno != 0) { | |
| return NULL; | |
| } | |
| if (die_obj != NULL) { | |
| if (parent_obj != NULL) { | |
| /* Update list of parent's children. */ | |
| die_obj->link_sibling(parent_obj->last_child()); | |
| parent_obj->link_child(die_obj); | |
| } else { | |
| /* NULL parent object is allowed only for CU DIE itself. */ | |
| assert(cu_die_ == NULL && die_tag == DW_TAG_compile_unit); | |
| if (cu_die_ == NULL && die_tag != DW_TAG_compile_unit) { | |
| _set_errno(EINVAL); | |
| return NULL; | |
| } | |
| cu_die_ = die_obj; | |
| /* This CU DIE object will be used as a parent for all DIE | |
| * objects, created in this method. */ | |
| parent_obj = cu_die_; | |
| } | |
| } | |
| // Loop through all DIE properties. | |
| while (elf_file_->is_valid_abbr_ptr(at_abbr, sizeof(Dwarf_Abbr_AT)) && | |
| !at_abbr->is_separator()) { | |
| Dwarf_At at_value; | |
| Dwarf_Form at_form; | |
| Dwarf_Value attr_value; | |
| // Obtain next property value. | |
| at_abbr = at_abbr->process(&at_value, &at_form); | |
| die_attr = process_attrib(die_attr, at_form, &attr_value); | |
| if (at_value == DW_AT_sibling) { | |
| /* DW_AT_sibling means that next DIE is a child of the one that's | |
| * being currently processed. We need to cache value of this property | |
| * in order to correctly calculate next sibling of this DIE after | |
| * child's DIE has been processed. */ | |
| assert(sibling_off == 0); | |
| sibling_off = attr_value.u32; | |
| } | |
| } | |
| /* Next DIE immediately follows last property for the current DIE. */ | |
| die = reinterpret_cast<const Dwarf_DIE*>(die_attr); | |
| if (sibling_off != 0) { | |
| // Process child DIE. | |
| process_DIE(parse_context, die, die_obj != NULL ? die_obj : parent_obj); | |
| // Next sibling DIE offset is relative to this CU's header beginning. | |
| die = INC_CPTR_T(Dwarf_DIE, cu_header_, sibling_off); | |
| } | |
| } | |
| return INC_CPTR_T(Elf_Byte, die, 1); | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| DIEObject* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::create_die_object( | |
| const DwarfParseContext* parse_context, | |
| const Dwarf_DIE* die, | |
| DIEObject* parent, | |
| Dwarf_Tag tag) { | |
| DIEObject* ret = NULL; | |
| /* We will always create a DIE object for CU DIE. */ | |
| if (tag == DW_TAG_compile_unit || collect_die(parse_context, tag)) { | |
| ret = new(elf_file_) DIEObject(die, this, parent); | |
| assert(ret != NULL); | |
| if (ret == NULL) { | |
| _set_errno(ENOMEM); | |
| } | |
| } else { | |
| _set_errno(0); | |
| } | |
| return ret; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::init_stmtl() { | |
| if (stmtl_header_.unit_length != 0) { | |
| return true; | |
| } | |
| assert(cu_die_ != NULL); | |
| if (cu_die_ == NULL) { | |
| _set_errno(EINVAL); | |
| return false; | |
| } | |
| DIEAttrib stmtl; | |
| if (!cu_die()->get_attrib(DW_AT_stmt_list, &stmtl)) { | |
| _set_errno(EINVAL); | |
| return false; | |
| } | |
| const void* stmtl_start = | |
| INC_CPTR(elf_file()->get_debug_line_data(), stmtl.value()->u32); | |
| if (*reinterpret_cast<const Elf_Word*>(stmtl_start) == 0xFFFFFFFF) { | |
| cache_stmtl<Dwarf64_STMTLHdr>(reinterpret_cast<const Dwarf64_STMTLHdr*>(stmtl_start)); | |
| } else { | |
| cache_stmtl<Dwarf32_STMTLHdr>(reinterpret_cast<const Dwarf32_STMTLHdr*>(stmtl_start)); | |
| } | |
| return true; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_pc_address_file_info( | |
| Elf_Xword address, | |
| Dwarf_AddressInfo* info) { | |
| /* Make sure STMTL header is cached. */ | |
| if (!init_stmtl()) { | |
| return false; | |
| } | |
| /* Flags address match, that should trigger return next time | |
| * source line gets adjusted. */ | |
| bool found = false; | |
| /* Create new state machine. */ | |
| DwarfStateMachine state(stmtl_header_.default_is_stmt != 0); | |
| /* Start the "Line Number Program" */ | |
| const Elf_Byte* go = stmtl_header_.start; | |
| while (go < stmtl_header_.end) { | |
| const Elf_Byte op = *go; | |
| go++; | |
| if (op == 0) { | |
| /* This is an extended opcode. */ | |
| Dwarf_Value op_size; | |
| /* First ULEB128 contains opcode size, (excluding ULEB128 itself). */ | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&op_size)); | |
| /* Next is the extended opcode. */ | |
| const Elf_Byte* ex_op_ptr = go; | |
| switch (*ex_op_ptr) { | |
| case DW_LNE_end_sequence: | |
| state.end_sequence_ = true; | |
| state.reset(stmtl_header_.default_is_stmt != 0); | |
| found = false; | |
| break; | |
| case DW_LNE_set_address: { | |
| Elf_Xword prev_address = state.address_; | |
| if (is_CU_address_64()) { | |
| state.address_ = | |
| elf_file()->pull_val(reinterpret_cast<const Elf_Xword*>(ex_op_ptr + 1)); | |
| } else { | |
| state.address_ = | |
| elf_file()->pull_val(reinterpret_cast<const Elf_Word*>(ex_op_ptr + 1)); | |
| } | |
| if (prev_address != 0 && | |
| address >= prev_address && address < state.address_) { | |
| return set_source_info(&state, info); | |
| } else if (address == state.address_) { | |
| found = true; | |
| } | |
| break; | |
| } | |
| case DW_LNE_define_file: { | |
| /* Parameters start with the directly encoded zero-terminated | |
| * file name. */ | |
| state.set_file_info_ = INC_CPTR_T(Dwarf_STMTL_FileDesc, ex_op_ptr, 1); | |
| assert(state.set_file_info_ != NULL); | |
| if (state.set_file_info_ != NULL) { | |
| ex_op_ptr = reinterpret_cast<const Elf_Byte*>(state.set_file_info_->process(NULL)); | |
| } | |
| break; | |
| } | |
| case DW_LNE_set_discriminator: { | |
| Dwarf_Value discr_val; | |
| /* One parameter: discriminator's ULEB128 value. */ | |
| reinterpret_cast<const Dwarf_Leb128*>(ex_op_ptr + 1)->process_unsigned(&discr_val); | |
| state.discriminator_ = discr_val.u32; | |
| break; | |
| } | |
| default: | |
| assert(0); | |
| return false; | |
| } | |
| go += op_size.u32; | |
| } else if (op < stmtl_header_.opcode_base) { | |
| /* This is a standard opcode. */ | |
| switch (op) { | |
| case DW_LNS_copy: | |
| /* No parameters. */ | |
| state.basic_block_ = false; | |
| state.prologue_end_ = false; | |
| state.epilogue_begin_ = false; | |
| break; | |
| case DW_LNS_advance_pc: { | |
| /* One parameter: ULEB128 value to add to the current address value | |
| * in the state machine. */ | |
| Dwarf_Value addr_add; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&addr_add)); | |
| Elf_Xword prev_address = state.address_; | |
| state.address_ += addr_add.u64; | |
| if (prev_address != 0 && | |
| address >= prev_address && address < state.address_) { | |
| return set_source_info(&state, info); | |
| } else if (address == state.address_) { | |
| found = true; | |
| } | |
| break; | |
| } | |
| case DW_LNS_advance_line: { | |
| /* One parameter: signed LEB128 value to add to the current line | |
| * number in the state machine. */ | |
| Dwarf_Value line_add; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_signed(&line_add)); | |
| state.line_ += line_add.s32; | |
| if (found) { | |
| return set_source_info(&state, info); | |
| } | |
| break; | |
| } | |
| case DW_LNS_set_file: { | |
| /* One parameter: ULEB128 value encoding current file number. */ | |
| Dwarf_Value file_num; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&file_num)); | |
| state.file_ = file_num.u32; | |
| /* This operation should discard previously saved file information. */ | |
| state.set_file_info_ = NULL; | |
| break; | |
| } | |
| case DW_LNS_set_column: { | |
| /* One parameter: ULEB128 value encoding current column number. */ | |
| Dwarf_Value column_num; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&column_num)); | |
| state.column_ = column_num.u32; | |
| break; | |
| } | |
| case DW_LNS_negate_stmt: | |
| /* No parameters. */ | |
| state.is_stmt_ = !state.is_stmt_; | |
| break; | |
| case DW_LNS_set_basic_block: | |
| /* No parameters. */ | |
| state.basic_block_ = true; | |
| break; | |
| case DW_LNS_const_add_pc: { | |
| Elf_Xword prev_address = state.address_; | |
| /* No parameters. This operation does the same thing, as special | |
| * opcode 255 would do to the current address. */ | |
| Elf_Word adjusted = | |
| static_cast<Elf_Word>(255) - stmtl_header_.opcode_base; | |
| state.address_ += (adjusted / stmtl_header_.line_range) * | |
| stmtl_header_.min_instruction_len; | |
| if (prev_address != 0 && | |
| address >= prev_address && address < state.address_) { | |
| return set_source_info(&state, info); | |
| } else if (address == state.address_) { | |
| found = true; | |
| } | |
| break; | |
| } | |
| case DW_LNS_fixed_advance_pc: { | |
| Elf_Xword prev_address = state.address_; | |
| /* One parameter: directly encoded 16-bit value to add to the | |
| * current address. */ | |
| state.address_ += | |
| elf_file()->pull_val(reinterpret_cast<const Elf_Half*>(go)); | |
| if (prev_address != 0 && | |
| address >= prev_address && address < state.address_) { | |
| return set_source_info(&state, info); | |
| } else if (address == state.address_) { | |
| found = true; | |
| } | |
| go += sizeof(Elf_Half); | |
| break; | |
| } | |
| case DW_LNS_set_prologue_end: | |
| /* No parameters. */ | |
| state.prologue_end_ = true; | |
| break; | |
| case DW_LNS_set_epilogue_begin: | |
| /* No parameters. */ | |
| state.epilogue_begin_ = true; | |
| break; | |
| case DW_LNS_set_isa: { | |
| /* One parameter: ISA value encoded as ULEB128. */ | |
| Dwarf_Value isa_val; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&isa_val)); | |
| state.isa_ = isa_val.u32; | |
| break; | |
| } | |
| default: | |
| /* Unknown opcode. Just skip it. */ | |
| for (Elf_Byte uleb = 0; | |
| uleb < stmtl_header_.standard_opcode_lengths[op - 1]; uleb++) { | |
| Dwarf_Value tmp; | |
| go = reinterpret_cast<const Elf_Byte*> | |
| (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&tmp)); | |
| } | |
| break; | |
| } | |
| } else { | |
| Elf_Xword prev_address = state.address_; | |
| /* This is a special opcode. */ | |
| const Elf_Word adjusted = op - stmtl_header_.opcode_base; | |
| /* Advance address. */ | |
| state.address_ += (adjusted / stmtl_header_.line_range) * | |
| stmtl_header_.min_instruction_len; | |
| if (prev_address != 0 && | |
| address >= prev_address && address < state.address_) { | |
| return set_source_info(&state, info); | |
| } | |
| /* Advance line. */ | |
| state.line_ += stmtl_header_.line_base + | |
| (adjusted % stmtl_header_.line_range); | |
| if (state.address_ == address) { | |
| return set_source_info(&state, info); | |
| } | |
| /* Do the woodoo. */ | |
| state.basic_block_ = false; | |
| state.prologue_end_ = false; | |
| state.epilogue_begin_ = false; | |
| } | |
| } | |
| return false; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| const Dwarf_STMTL_FileDesc* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_stmt_file_info( | |
| Elf_Word index) { | |
| /* Index must be 1-based. */ | |
| if (index == 0) { | |
| return NULL; | |
| } | |
| const Dwarf_STMTL_FileDesc* cur_desc = stmtl_header_.file_infos; | |
| while (index != 1 && !cur_desc->is_last_entry()) { | |
| cur_desc = cur_desc->process(NULL); | |
| index--; | |
| } | |
| assert(!cur_desc->is_last_entry()); | |
| return cur_desc->is_last_entry() ? NULL : cur_desc; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| const char* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_stmt_dir_name( | |
| Elf_Word dir_index) { | |
| if (dir_index == 0) { | |
| /* Requested is current compilation directory. */ | |
| return comp_dir_path(); | |
| } | |
| if (dir_index > stmtl_header_.inc_dir_num) { | |
| return NULL; | |
| } | |
| const char* cur_dir = stmtl_header_.include_directories; | |
| while (dir_index != 1) { | |
| cur_dir += strlen(cur_dir) + 1; | |
| dir_index--; | |
| } | |
| return cur_dir; | |
| } | |
| template <typename Dwarf_CUHdr, typename Dwarf_Off> | |
| bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::set_source_info( | |
| const DwarfStateMachine* state, | |
| Dwarf_AddressInfo* info) { | |
| info->line_number = state->line_; | |
| const Dwarf_STMTL_FileDesc* file_info = state->set_file_info_; | |
| if (file_info == NULL) { | |
| file_info = get_stmt_file_info(state->file_); | |
| if (file_info == NULL) { | |
| info->file_name = rel_cu_path(); | |
| info->dir_name = comp_dir_path(); | |
| return true; | |
| } | |
| } | |
| info->file_name = file_info->get_file_name(); | |
| const Elf_Word dir_index = file_info->get_dir_index(); | |
| info->dir_name = get_stmt_dir_name(dir_index); | |
| return true; | |
| } | |