elf_file.h revision 3470ab4011b5e18d590d5375e2f13a1e3bd69222
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ART_RUNTIME_ELF_FILE_H_ 18#define ART_RUNTIME_ELF_FILE_H_ 19 20#include <map> 21#include <memory> 22#include <vector> 23 24#include "base/unix_file/fd_file.h" 25#include "globals.h" 26#include "elf_utils.h" 27#include "mem_map.h" 28#include "os.h" 29 30namespace art { 31 32// Interface to GDB JIT for backtrace information. 33extern "C" { 34 struct JITCodeEntry; 35} 36 37 38// Used for compile time and runtime for ElfFile access. Because of 39// the need for use at runtime, cannot directly use LLVM classes such as 40// ELFObjectFile. 41class ElfFile { 42 public: 43 static ElfFile* Open(File* file, bool writable, bool program_header_only, std::string* error_msg); 44 // Open with specific mmap flags, Always maps in the whole file, not just the 45 // program header sections. 46 static ElfFile* Open(File* file, int mmap_prot, int mmap_flags, std::string* error_msg); 47 ~ElfFile(); 48 49 // Load segments into memory based on PT_LOAD program headers 50 51 const File& GetFile() const { 52 return *file_; 53 } 54 55 byte* Begin() const { 56 return map_->Begin(); 57 } 58 59 byte* End() const { 60 return map_->End(); 61 } 62 63 size_t Size() const { 64 return map_->Size(); 65 } 66 67 Elf32_Ehdr& GetHeader() const; 68 69 Elf32_Word GetProgramHeaderNum() const; 70 Elf32_Phdr& GetProgramHeader(Elf32_Word) const; 71 Elf32_Phdr* FindProgamHeaderByType(Elf32_Word type) const; 72 73 Elf32_Word GetSectionHeaderNum() const; 74 Elf32_Shdr& GetSectionHeader(Elf32_Word) const; 75 Elf32_Shdr* FindSectionByType(Elf32_Word type) const; 76 Elf32_Shdr* FindSectionByName(const std::string& name) const; 77 78 Elf32_Shdr& GetSectionNameStringSection() const; 79 80 // Find .dynsym using .hash for more efficient lookup than FindSymbolAddress. 81 const byte* FindDynamicSymbolAddress(const std::string& symbol_name) const; 82 const Elf32_Sym* FindDynamicSymbol(const std::string& symbol_name) const; 83 84 static bool IsSymbolSectionType(Elf32_Word section_type); 85 Elf32_Word GetSymbolNum(Elf32_Shdr&) const; 86 Elf32_Sym& GetSymbol(Elf32_Word section_type, Elf32_Word i) const; 87 88 // Find symbol in specified table, returning nullptr if it is not found. 89 // 90 // If build_map is true, builds a map to speed repeated access. The 91 // map does not included untyped symbol values (aka STT_NOTYPE) 92 // since they can contain duplicates. If build_map is false, the map 93 // will be used if it was already created. Typically build_map 94 // should be set unless only a small number of symbols will be 95 // looked up. 96 Elf32_Sym* FindSymbolByName(Elf32_Word section_type, 97 const std::string& symbol_name, 98 bool build_map); 99 100 // Find address of symbol in specified table, returning 0 if it is 101 // not found. See FindSymbolByName for an explanation of build_map. 102 Elf32_Addr FindSymbolAddress(Elf32_Word section_type, 103 const std::string& symbol_name, 104 bool build_map); 105 106 // Lookup a string given string section and offset. Returns nullptr for 107 // special 0 offset. 108 const char* GetString(Elf32_Shdr&, Elf32_Word) const; 109 110 // Lookup a string by section type. Returns nullptr for special 0 offset. 111 const char* GetString(Elf32_Word section_type, Elf32_Word) const; 112 113 Elf32_Word GetDynamicNum() const; 114 Elf32_Dyn& GetDynamic(Elf32_Word) const; 115 Elf32_Word FindDynamicValueByType(Elf32_Sword type) const; 116 117 Elf32_Word GetRelNum(Elf32_Shdr&) const; 118 Elf32_Rel& GetRel(Elf32_Shdr&, Elf32_Word) const; 119 120 Elf32_Word GetRelaNum(Elf32_Shdr&) const; 121 Elf32_Rela& GetRela(Elf32_Shdr&, Elf32_Word) const; 122 123 // Returns the expected size when the file is loaded at runtime 124 size_t GetLoadedSize() const; 125 126 // Load segments into memory based on PT_LOAD program headers. 127 // executable is true at run time, false at compile time. 128 bool Load(bool executable, std::string* error_msg); 129 130 private: 131 ElfFile(File* file, bool writable, bool program_header_only); 132 133 bool Setup(int prot, int flags, std::string* error_msg); 134 135 bool SetMap(MemMap* map, std::string* error_msg); 136 137 byte* GetProgramHeadersStart() const; 138 byte* GetSectionHeadersStart() const; 139 Elf32_Phdr& GetDynamicProgramHeader() const; 140 Elf32_Dyn* GetDynamicSectionStart() const; 141 Elf32_Sym* GetSymbolSectionStart(Elf32_Word section_type) const; 142 const char* GetStringSectionStart(Elf32_Word section_type) const; 143 Elf32_Rel* GetRelSectionStart(Elf32_Shdr&) const; 144 Elf32_Rela* GetRelaSectionStart(Elf32_Shdr&) const; 145 Elf32_Word* GetHashSectionStart() const; 146 Elf32_Word GetHashBucketNum() const; 147 Elf32_Word GetHashChainNum() const; 148 Elf32_Word GetHashBucket(size_t i) const; 149 Elf32_Word GetHashChain(size_t i) const; 150 151 typedef std::map<std::string, Elf32_Sym*> SymbolTable; 152 SymbolTable** GetSymbolTable(Elf32_Word section_type); 153 154 bool ValidPointer(const byte* start) const; 155 156 const File* const file_; 157 const bool writable_; 158 const bool program_header_only_; 159 160 // ELF header mapping. If program_header_only_ is false, will 161 // actually point to the entire elf file. 162 std::unique_ptr<MemMap> map_; 163 Elf32_Ehdr* header_; 164 std::vector<MemMap*> segments_; 165 166 // Pointer to start of first PT_LOAD program segment after Load() 167 // when program_header_only_ is true. 168 byte* base_address_; 169 170 // The program header should always available but use GetProgramHeadersStart() to be sure. 171 byte* program_headers_start_; 172 173 // Conditionally available values. Use accessors to ensure they exist if they are required. 174 byte* section_headers_start_; 175 Elf32_Phdr* dynamic_program_header_; 176 Elf32_Dyn* dynamic_section_start_; 177 Elf32_Sym* symtab_section_start_; 178 Elf32_Sym* dynsym_section_start_; 179 char* strtab_section_start_; 180 char* dynstr_section_start_; 181 Elf32_Word* hash_section_start_; 182 183 SymbolTable* symtab_symbol_table_; 184 SymbolTable* dynsym_symbol_table_; 185 186 // Support for GDB JIT 187 byte* jit_elf_image_; 188 JITCodeEntry* jit_gdb_entry_; 189 std::unique_ptr<ElfFile> gdb_file_mapping_; 190 void GdbJITSupport(); 191}; 192 193} // namespace art 194 195#endif // ART_RUNTIME_ELF_FILE_H_ 196