| /* 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; |
| } |
| |
