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 30 namespace art { 31 32 // Interface to GDB JIT for backtrace information. 33 extern "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. 41 class 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 GetFile()51 const File& GetFile() const { 52 return *file_; 53 } 54 Begin()55 byte* Begin() const { 56 return map_->Begin(); 57 } 58 End()59 byte* End() const { 60 return map_->End(); 61 } 62 Size()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 72 Elf32_Word GetSectionHeaderNum() const; 73 Elf32_Shdr* GetSectionHeader(Elf32_Word) const; 74 Elf32_Shdr* FindSectionByType(Elf32_Word type) const; 75 Elf32_Shdr* FindSectionByName(const std::string& name) const; 76 77 Elf32_Shdr* GetSectionNameStringSection() const; 78 79 // Find .dynsym using .hash for more efficient lookup than FindSymbolAddress. 80 const byte* FindDynamicSymbolAddress(const std::string& symbol_name) const; 81 82 Elf32_Word GetSymbolNum(Elf32_Shdr&) const; 83 Elf32_Sym* GetSymbol(Elf32_Word section_type, Elf32_Word i) const; 84 85 // Find address of symbol in specified table, returning 0 if it is 86 // not found. See FindSymbolByName for an explanation of build_map. 87 Elf32_Addr FindSymbolAddress(Elf32_Word section_type, 88 const std::string& symbol_name, 89 bool build_map); 90 91 // Lookup a string given string section and offset. Returns nullptr for 92 // special 0 offset. 93 const char* GetString(Elf32_Shdr&, Elf32_Word) const; 94 95 Elf32_Word GetDynamicNum() const; 96 Elf32_Dyn& GetDynamic(Elf32_Word) const; 97 98 Elf32_Word GetRelNum(Elf32_Shdr&) const; 99 Elf32_Rel& GetRel(Elf32_Shdr&, Elf32_Word) const; 100 101 Elf32_Word GetRelaNum(Elf32_Shdr&) const; 102 Elf32_Rela& GetRela(Elf32_Shdr&, Elf32_Word) const; 103 104 // Returns the expected size when the file is loaded at runtime 105 size_t GetLoadedSize() const; 106 107 // Load segments into memory based on PT_LOAD program headers. 108 // executable is true at run time, false at compile time. 109 bool Load(bool executable, std::string* error_msg); 110 111 private: 112 ElfFile(File* file, bool writable, bool program_header_only); 113 114 bool Setup(int prot, int flags, std::string* error_msg); 115 116 bool SetMap(MemMap* map, std::string* error_msg); 117 118 byte* GetProgramHeadersStart() const; 119 byte* GetSectionHeadersStart() const; 120 Elf32_Phdr& GetDynamicProgramHeader() const; 121 Elf32_Dyn* GetDynamicSectionStart() const; 122 Elf32_Sym* GetSymbolSectionStart(Elf32_Word section_type) const; 123 const char* GetStringSectionStart(Elf32_Word section_type) const; 124 Elf32_Rel* GetRelSectionStart(Elf32_Shdr&) const; 125 Elf32_Rela* GetRelaSectionStart(Elf32_Shdr&) const; 126 Elf32_Word* GetHashSectionStart() const; 127 Elf32_Word GetHashBucketNum() const; 128 Elf32_Word GetHashChainNum() const; 129 Elf32_Word GetHashBucket(size_t i, bool* ok) const; 130 Elf32_Word GetHashChain(size_t i, bool* ok) const; 131 132 typedef std::map<std::string, Elf32_Sym*> SymbolTable; 133 SymbolTable** GetSymbolTable(Elf32_Word section_type); 134 135 bool ValidPointer(const byte* start) const; 136 137 const Elf32_Sym* FindDynamicSymbol(const std::string& symbol_name) const; 138 139 // Check that certain sections and their dependencies exist. 140 bool CheckSectionsExist(std::string* error_msg) const; 141 142 // Check that the link of the first section links to the second section. 143 bool CheckSectionsLinked(const byte* source, const byte* target) const; 144 145 // Check whether the offset is in range, and set to target to Begin() + offset if OK. 146 bool CheckAndSet(Elf32_Off offset, const char* label, byte** target, std::string* error_msg); 147 148 // Find symbol in specified table, returning nullptr if it is not found. 149 // 150 // If build_map is true, builds a map to speed repeated access. The 151 // map does not included untyped symbol values (aka STT_NOTYPE) 152 // since they can contain duplicates. If build_map is false, the map 153 // will be used if it was already created. Typically build_map 154 // should be set unless only a small number of symbols will be 155 // looked up. 156 Elf32_Sym* FindSymbolByName(Elf32_Word section_type, 157 const std::string& symbol_name, 158 bool build_map); 159 160 Elf32_Phdr* FindProgamHeaderByType(Elf32_Word type) const; 161 162 Elf32_Dyn* FindDynamicByType(Elf32_Sword type) const; 163 Elf32_Word FindDynamicValueByType(Elf32_Sword type) const; 164 165 // Lookup a string by section type. Returns nullptr for special 0 offset. 166 const char* GetString(Elf32_Word section_type, Elf32_Word) const; 167 168 const File* const file_; 169 const bool writable_; 170 const bool program_header_only_; 171 172 // ELF header mapping. If program_header_only_ is false, will 173 // actually point to the entire elf file. 174 std::unique_ptr<MemMap> map_; 175 Elf32_Ehdr* header_; 176 std::vector<MemMap*> segments_; 177 178 // Pointer to start of first PT_LOAD program segment after Load() 179 // when program_header_only_ is true. 180 byte* base_address_; 181 182 // The program header should always available but use GetProgramHeadersStart() to be sure. 183 byte* program_headers_start_; 184 185 // Conditionally available values. Use accessors to ensure they exist if they are required. 186 byte* section_headers_start_; 187 Elf32_Phdr* dynamic_program_header_; 188 Elf32_Dyn* dynamic_section_start_; 189 Elf32_Sym* symtab_section_start_; 190 Elf32_Sym* dynsym_section_start_; 191 char* strtab_section_start_; 192 char* dynstr_section_start_; 193 Elf32_Word* hash_section_start_; 194 195 SymbolTable* symtab_symbol_table_; 196 SymbolTable* dynsym_symbol_table_; 197 198 // Support for GDB JIT 199 byte* jit_elf_image_; 200 JITCodeEntry* jit_gdb_entry_; 201 std::unique_ptr<ElfFile> gdb_file_mapping_; 202 void GdbJITSupport(); 203 }; 204 205 } // namespace art 206 207 #endif // ART_RUNTIME_ELF_FILE_H_ 208