| /* 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 ElfFile classes that encapsulate an ELF file. |
| */ |
| |
| #include "string.h" |
| #include "elf_file.h" |
| #include "elf_alloc.h" |
| #include "dwarf_cu.h" |
| #include "dwarf_utils.h" |
| |
| #include <fcntl.h> |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| |
| /* Tags to parse when collecting info about routines. */ |
| static const Dwarf_Tag parse_rt_tags[] = { |
| DW_TAG_compile_unit, |
| DW_TAG_partial_unit, |
| DW_TAG_inlined_subroutine, |
| DW_TAG_subprogram, |
| 0 |
| }; |
| static const DwarfParseContext parse_rt_context = { parse_rt_tags }; |
| |
| //============================================================================= |
| // Base ElfFile implementation |
| //============================================================================= |
| |
| ElfFile::ElfFile() |
| : fixed_base_address_(0), |
| elf_handle_((MapFile*)-1), |
| elf_file_path_(NULL), |
| allocator_(NULL), |
| sec_table_(NULL), |
| sec_count_(0), |
| sec_entry_size_(0), |
| last_cu_(NULL), |
| cu_count_(0), |
| is_exec_(0) { |
| } |
| |
| ElfFile::~ElfFile() { |
| DwarfCU* cu_to_del = last_cu_; |
| while (cu_to_del != NULL) { |
| DwarfCU* next_cu_to_del = cu_to_del->prev_cu_; |
| delete cu_to_del; |
| cu_to_del = next_cu_to_del; |
| } |
| |
| if (mapfile_is_valid(elf_handle_)) { |
| mapfile_close(elf_handle_); |
| } |
| |
| if (elf_file_path_ != NULL) { |
| delete[] elf_file_path_; |
| } |
| |
| if (sec_table_ != NULL) { |
| delete[] reinterpret_cast<Elf_Byte*>(sec_table_); |
| } |
| |
| /* Must be deleted last! */ |
| if (allocator_ != NULL) { |
| delete allocator_; |
| } |
| } |
| |
| ElfFile* ElfFile::Create(const char* path) { |
| ElfFile* ret = NULL; |
| /* Allocate enough space on the stack to fit the largest ELF file header. */ |
| Elf64_FHdr header; |
| const Elf_CommonHdr* elf_hdr = &header.common; |
| |
| assert(path != NULL && *path != '\0'); |
| if (path == NULL || *path == '\0') { |
| _set_errno(EINVAL); |
| return NULL; |
| } |
| |
| /* |
| * Open ELF file, and read its header (the largest one possible). |
| */ |
| MapFile* file_handle = mapfile_open(path, O_RDONLY | O_BINARY, 0); |
| if (!mapfile_is_valid(file_handle)) { |
| return NULL; |
| } |
| const ssize_t read_bytes = mapfile_read(file_handle, &header, sizeof(header)); |
| mapfile_close(file_handle); |
| assert(read_bytes != -1 && read_bytes == sizeof(header)); |
| if (read_bytes == -1 || read_bytes != sizeof(header)) { |
| if (read_bytes != -1) { |
| _set_errno(EINVAL); |
| } |
| return NULL; |
| } |
| |
| /* Lets see if this is an ELF file at all. */ |
| if (memcmp(elf_hdr->e_ident, ELFMAG, SELFMAG) != 0) { |
| /* File is not an ELF file. */ |
| _set_errno(ENOEXEC); |
| return NULL; |
| } |
| |
| /* Lets check ELF's "bitness". */ |
| assert(elf_hdr->ei_info.ei_class == ELFCLASS32 || |
| elf_hdr->ei_info.ei_class == ELFCLASS64); |
| if (elf_hdr->ei_info.ei_class != ELFCLASS32 && |
| elf_hdr->ei_info.ei_class != ELFCLASS64) { |
| /* Neither 32, or 64-bit ELF file. Something wrong here. */ |
| _set_errno(EBADF); |
| return NULL; |
| } |
| |
| /* Lets instantiate appropriate ElfFileImpl object for this ELF. */ |
| if (elf_hdr->ei_info.ei_class == ELFCLASS32) { |
| ret = new ElfFileImpl<Elf32_Addr, Elf32_Off>; |
| } else { |
| ret = new ElfFileImpl<Elf64_Addr, Elf64_Off>; |
| } |
| assert(ret != NULL); |
| if (ret != NULL) { |
| if (!ret->initialize(elf_hdr, path)) { |
| delete ret; |
| ret = NULL; |
| } |
| } else { |
| _set_errno(ENOMEM); |
| } |
| |
| return ret; |
| } |
| |
| bool ElfFile::initialize(const Elf_CommonHdr* elf_hdr, const char* path) { |
| /* Must be created first! */ |
| allocator_ = new ElfAllocator(); |
| assert(allocator_ != NULL); |
| if (allocator_ == NULL) { |
| _set_errno(ENOMEM); |
| return false; |
| } |
| |
| /* Copy file path. */ |
| size_t path_len = strlen(path) + 1; |
| elf_file_path_ = new char[path_len]; |
| assert(elf_file_path_ != NULL); |
| if (elf_file_path_ == NULL) { |
| _set_errno(ENOMEM); |
| return false; |
| } |
| memcpy(elf_file_path_, path, path_len); |
| |
| /* Cache some basic ELF properties. */ |
| is_ELF_64_ = elf_hdr->ei_info.ei_class == ELFCLASS64; |
| is_elf_big_endian_ = elf_hdr->ei_info.ei_data == ELFDATA2MSB; |
| same_endianness_ = is_elf_little_endian() == is_little_endian_cpu(); |
| is_exec_ = elf_hdr->e_type == 2; |
| |
| /* Reopen file for further reads and mappings. */ |
| elf_handle_ = mapfile_open(elf_file_path_, O_RDONLY | O_BINARY, 0); |
| return mapfile_is_valid(elf_handle_); |
| } |
| |
| bool ElfFile::get_pc_address_info(Elf_Xword address, |
| Elf_AddressInfo* address_info) { |
| assert(address_info != NULL); |
| if (address_info == NULL) { |
| _set_errno(EINVAL); |
| return false; |
| } |
| |
| /* Collect routine information for all CUs in this file. */ |
| if (parse_compilation_units(&parse_rt_context) == -1) { |
| return false; |
| } |
| |
| /* Iterate through the collected CUs looking for the one that |
| * contains the given address. */ |
| address_info->inline_stack = NULL; |
| DwarfCU* cu = last_cu(); |
| while (cu != NULL) { |
| /* Find a leaf DIE object in the current CU that contains the address. */ |
| Dwarf_AddressInfo info; |
| info.die_obj = cu->get_leaf_die_for_address(address); |
| if (info.die_obj != NULL) { |
| /* Convert the address to a location inside source file. */ |
| if (cu->get_pc_address_file_info(address, &info)) { |
| /* Copy location information to the returning structure. */ |
| address_info->file_name = info.file_name; |
| address_info->dir_name = info.dir_name; |
| address_info->line_number = info.line_number; |
| } else { |
| address_info->file_name = NULL; |
| address_info->dir_name = NULL; |
| address_info->line_number = 0; |
| } |
| |
| /* Lets see if the DIE represents a routine (rather than |
| * a lexical block, for instance). */ |
| Dwarf_Tag tag = info.die_obj->get_tag(); |
| while (!dwarf_tag_is_routine(tag)) { |
| /* This is not a routine DIE. Lets loop trhough the parents of that |
| * DIE looking for the first routine DIE. */ |
| info.die_obj = info.die_obj->parent_die(); |
| if (info.die_obj == NULL) { |
| /* Reached compilation unit DIE. Can't go any further. */ |
| address_info->routine_name = "<unknown>"; |
| return true; |
| } |
| tag = info.die_obj->get_tag(); |
| } |
| |
| /* Save name of the routine that contains the address. */ |
| address_info->routine_name = info.die_obj->get_name(); |
| if (address_info->routine_name == NULL) { |
| /* In some cases (minimum debugging info in the file) routine |
| * name may be not avaible. We, however, are obliged by API |
| * considerations to return something in this field. */ |
| address_info->routine_name = "<unknown>"; |
| } |
| |
| /* Lets see if address belongs to an inlined routine. */ |
| if (tag != DW_TAG_inlined_subroutine) { |
| address_info->inline_stack = NULL; |
| return true; |
| } |
| |
| /* |
| * Address belongs to an inlined routine. Create inline stack. |
| */ |
| |
| /* Allocate inline stack array big enough to fit all parent entries. */ |
| address_info->inline_stack = |
| new Elf_InlineInfo[info.die_obj->get_level() + 1]; |
| assert(address_info->inline_stack != NULL); |
| if (address_info->inline_stack == NULL) { |
| _set_errno(ENOMEM); |
| return false; |
| } |
| memset(address_info->inline_stack, 0, |
| sizeof(Elf_InlineInfo) * (info.die_obj->get_level() + 1)); |
| |
| /* Reverse DIEs filling in inline stack entries for inline |
| * routine tags. */ |
| int inl_index = 0; |
| do { |
| /* Save source file information. */ |
| DIEAttrib file_desc; |
| if (info.die_obj->get_attrib(DW_AT_call_file, &file_desc)) { |
| const Dwarf_STMTL_FileDesc* desc = |
| cu->get_stmt_file_info(file_desc.value()->u32); |
| if (desc != NULL) { |
| address_info->inline_stack[inl_index].inlined_in_file = |
| desc->file_name; |
| address_info->inline_stack[inl_index].inlined_in_file_dir = |
| cu->get_stmt_dir_name(desc->get_dir_index()); |
| } |
| } |
| if (address_info->inline_stack[inl_index].inlined_in_file == NULL) { |
| address_info->inline_stack[inl_index].inlined_in_file = "<unknown>"; |
| address_info->inline_stack[inl_index].inlined_in_file_dir = NULL; |
| } |
| |
| /* Save source line information. */ |
| if (info.die_obj->get_attrib(DW_AT_call_line, &file_desc)) { |
| address_info->inline_stack[inl_index].inlined_at_line = file_desc.value()->u32; |
| } |
| |
| /* Advance DIE to the parent routine, and save its name. */ |
| info.die_obj = info.die_obj->parent_die(); |
| assert(info.die_obj != NULL); |
| if (info.die_obj != NULL) { |
| tag = info.die_obj->get_tag(); |
| while (!dwarf_tag_is_routine(tag)) { |
| info.die_obj = info.die_obj->parent_die(); |
| if (info.die_obj == NULL) { |
| break; |
| } |
| tag = info.die_obj->get_tag(); |
| } |
| if (info.die_obj != NULL) { |
| address_info->inline_stack[inl_index].routine_name = |
| info.die_obj->get_name(); |
| } |
| } |
| if (address_info->inline_stack[inl_index].routine_name == NULL) { |
| address_info->inline_stack[inl_index].routine_name = "<unknown>"; |
| } |
| |
| /* Continue with the parent DIE. */ |
| inl_index++; |
| } while (info.die_obj != NULL && tag == DW_TAG_inlined_subroutine); |
| |
| return true; |
| } |
| cu = cu->prev_cu(); |
| } |
| |
| return false; |
| } |
| |
| void ElfFile::free_pc_address_info(Elf_AddressInfo* address_info) const { |
| assert(address_info != NULL); |
| if (address_info != NULL && address_info->inline_stack != NULL) { |
| delete address_info->inline_stack; |
| address_info->inline_stack = NULL; |
| } |
| } |
| |
| //============================================================================= |
| // ElfFileImpl |
| //============================================================================= |
| |
| template <typename Elf_Addr, typename Elf_Off> |
| bool ElfFileImpl<Elf_Addr, Elf_Off>::initialize(const Elf_CommonHdr* elf_hdr, |
| const char* path) { |
| /* Must be called first! */ |
| if (!ElfFile::initialize(elf_hdr, path)) { |
| return false; |
| } |
| |
| /* Cache some header data, so later we can discard the header. */ |
| const Elf_FHdr<Elf_Addr, Elf_Off>* header = |
| reinterpret_cast<const Elf_FHdr<Elf_Addr, Elf_Off>*>(elf_hdr); |
| sec_count_ = pull_val(header->e_shnum); |
| sec_entry_size_ = pull_val(header->e_shentsize); |
| fixed_base_address_ = pull_val(header->e_entry) & ~0xFFF; |
| |
| /* Cache section table (must have one!) */ |
| const Elf_Off sec_table_off = pull_val(header->e_shoff); |
| assert(sec_table_off != 0 && sec_count_ != 0); |
| if (sec_table_off == 0 || sec_count_ == 0) { |
| _set_errno(EBADF); |
| return false; |
| } |
| const size_t sec_table_size = sec_count_ * sec_entry_size_; |
| sec_table_ = new Elf_Byte[sec_table_size]; |
| assert(sec_table_ != NULL); |
| if (sec_table_ == NULL) { |
| _set_errno(ENOMEM); |
| return false; |
| } |
| if (mapfile_read_at(elf_handle_, sec_table_off, sec_table_, |
| sec_table_size) < 0) { |
| return false; |
| } |
| |
| /* Map ELF's string section (must have one!). */ |
| const Elf_Half str_sec_index = pull_val(header->e_shstrndx); |
| assert(str_sec_index != SHN_UNDEF); |
| if (str_sec_index == SHN_UNDEF) { |
| _set_errno(EBADF); |
| return false; |
| } |
| const Elf_SHdr<Elf_Addr, Elf_Off>* str_sec = |
| reinterpret_cast<const Elf_SHdr<Elf_Addr, Elf_Off>*> |
| (get_section_by_index(str_sec_index)); |
| assert(str_sec != NULL); |
| if (str_sec == NULL) { |
| _set_errno(EBADF); |
| return false; |
| } |
| if (!string_section_.map(elf_handle_, pull_val(str_sec->sh_offset), |
| pull_val(str_sec->sh_size))) { |
| return false; |
| } |
| |
| /* Lets determine DWARF format. According to the docs, DWARF is 64 bit, if |
| * first 4 bytes in the compilation unit header are set to 0xFFFFFFFF. |
| * .debug_info section of the ELF file begins with the first CU header. */ |
| if (!map_section_by_name(".debug_info", &debug_info_)) { |
| _set_errno(EBADF); |
| return false; |
| } |
| |
| /* Note that we don't care about endianness here, since 0xFFFFFFFF is an |
| * endianness-independent value, so we don't have to pull_val here. */ |
| is_DWARF_64_ = |
| *reinterpret_cast<const Elf_Word*>(debug_info_.data()) == 0xFFFFFFFF; |
| |
| return true; |
| } |
| |
| template <typename Elf_Addr, typename Elf_Off> |
| int ElfFileImpl<Elf_Addr, Elf_Off>::parse_compilation_units( |
| const DwarfParseContext* parse_context) { |
| /* Lets see if we already parsed the file. */ |
| if (last_cu() != NULL) { |
| return cu_count_; |
| } |
| |
| /* Cache sections required for this parsing. */ |
| if (!map_section_by_name(".debug_abbrev", &debug_abbrev_) || |
| !map_section_by_name(".debug_ranges", &debug_ranges_) || |
| !map_section_by_name(".debug_line", &debug_line_) || |
| !map_section_by_name(".debug_str", &debug_str_)) { |
| _set_errno(EBADF); |
| return false; |
| } |
| |
| /* .debug_info section opens with the first CU header. */ |
| const void* next_cu = debug_info_.data(); |
| |
| /* Iterate through CUs until we reached the end of .debug_info section, or |
| * advanced to a CU with zero size, indicating the end of CU list for this |
| * file. */ |
| while (is_valid_cu(next_cu)) { |
| /* Instatiate CU, depending on DWARF "bitness". */ |
| DwarfCU* cu = DwarfCU::create_instance(this, next_cu); |
| if (cu == NULL) { |
| _set_errno(ENOMEM); |
| return -1; |
| } |
| |
| if (cu->parse(parse_context, &next_cu)) { |
| cu->set_prev_cu(last_cu_); |
| last_cu_ = cu; |
| cu_count_++; |
| } else { |
| delete cu; |
| return -1; |
| } |
| }; |
| |
| return cu_count_; |
| } |
| |
| template <typename Elf_Addr, typename Elf_Off> |
| bool ElfFileImpl<Elf_Addr, Elf_Off>::get_section_info_by_name(const char* name, |
| Elf_Off* offset, |
| Elf_Word* size) { |
| const Elf_SHdr<Elf_Addr, Elf_Off>* cur_section = |
| reinterpret_cast<const Elf_SHdr<Elf_Addr, Elf_Off>*>(sec_table_); |
| |
| for (Elf_Half sec = 0; sec < sec_count_; sec++) { |
| const char* sec_name = get_str_sec_str(pull_val(cur_section->sh_name)); |
| if (sec_name != NULL && strcmp(name, sec_name) == 0) { |
| *offset = pull_val(cur_section->sh_offset); |
| *size = pull_val(cur_section->sh_size); |
| return true; |
| } |
| cur_section = reinterpret_cast<const Elf_SHdr<Elf_Addr, Elf_Off>*> |
| (INC_CPTR(cur_section, sec_entry_size_)); |
| } |
| _set_errno(EINVAL); |
| return false; |
| } |
| |
| template <typename Elf_Addr, typename Elf_Off> |
| bool ElfFileImpl<Elf_Addr, Elf_Off>::map_section_by_name( |
| const char* name, |
| ElfMappedSection* section) { |
| if (section->is_mapped()) { |
| return true; |
| } |
| |
| Elf_Off offset; |
| Elf_Word size; |
| if (!get_section_info_by_name(name, &offset, &size)) { |
| return false; |
| } |
| |
| return section->map(elf_handle_, offset, size); |
| } |
