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_IMPL_H_ 18 #define ART_RUNTIME_ELF_FILE_IMPL_H_ 19 20 #include <map> 21 #include <memory> 22 #include <type_traits> 23 #include <vector> 24 25 #include "base/mem_map.h" 26 #include "elf/elf_utils.h" 27 28 namespace art { 29 30 template <typename ElfTypes> 31 class ElfFileImpl { 32 public: 33 using Elf_Addr = typename ElfTypes::Addr; 34 using Elf_Off = typename ElfTypes::Off; 35 using Elf_Half = typename ElfTypes::Half; 36 using Elf_Word = typename ElfTypes::Word; 37 using Elf_Sword = typename ElfTypes::Sword; 38 using Elf_Ehdr = typename ElfTypes::Ehdr; 39 using Elf_Shdr = typename ElfTypes::Shdr; 40 using Elf_Sym = typename ElfTypes::Sym; 41 using Elf_Rel = typename ElfTypes::Rel; 42 using Elf_Rela = typename ElfTypes::Rela; 43 using Elf_Phdr = typename ElfTypes::Phdr; 44 using Elf_Dyn = typename ElfTypes::Dyn; 45 46 static ElfFileImpl* Open(File* file, 47 bool writable, 48 bool program_header_only, 49 bool low_4gb, 50 /*out*/std::string* error_msg); 51 static ElfFileImpl* Open(File* file, 52 int mmap_prot, 53 int mmap_flags, 54 bool low_4gb, 55 /*out*/std::string* error_msg); 56 ~ElfFileImpl(); 57 GetFilePath()58 const std::string& GetFilePath() const { 59 return file_path_; 60 } 61 GetBaseAddress()62 uint8_t* GetBaseAddress() const { 63 return base_address_; 64 } 65 Begin()66 uint8_t* Begin() const { 67 return map_.Begin(); 68 } 69 End()70 uint8_t* End() const { 71 return map_.End(); 72 } 73 Size()74 size_t Size() const { 75 return map_.Size(); 76 } 77 78 Elf_Ehdr& GetHeader() const; 79 80 Elf_Word GetProgramHeaderNum() const; 81 Elf_Phdr* GetProgramHeader(Elf_Word) const; 82 83 Elf_Word GetSectionHeaderNum() const; 84 Elf_Shdr* GetSectionHeader(Elf_Word) const; 85 Elf_Shdr* FindSectionByType(Elf_Word type) const; 86 Elf_Shdr* FindSectionByName(const std::string& name) const; 87 88 Elf_Shdr* GetSectionNameStringSection() const; 89 90 // Find .dynsym using .hash for more efficient lookup than FindSymbolAddress. 91 const uint8_t* FindDynamicSymbolAddress(const std::string& symbol_name) const; 92 93 static bool IsSymbolSectionType(Elf_Word section_type); 94 Elf_Word GetSymbolNum(Elf_Shdr&) const; 95 Elf_Sym* GetSymbol(Elf_Word section_type, Elf_Word i) const; 96 97 // Find address of symbol in specified table, returning 0 if it is 98 // not found. See FindSymbolByName for an explanation of build_map. 99 Elf_Addr FindSymbolAddress(Elf_Word section_type, 100 const std::string& symbol_name, 101 bool build_map); 102 103 // Lookup a string given string section and offset. Returns null for special 0 offset. 104 const char* GetString(Elf_Shdr&, Elf_Word) const; 105 106 Elf_Word GetDynamicNum() const; 107 Elf_Dyn& GetDynamic(Elf_Word) const; 108 109 Elf_Word GetRelNum(Elf_Shdr&) const; 110 Elf_Rel& GetRel(Elf_Shdr&, Elf_Word) const; 111 112 Elf_Word GetRelaNum(Elf_Shdr&) const; 113 Elf_Rela& GetRela(Elf_Shdr&, Elf_Word) const; 114 115 // Retrieves the expected size when the file is loaded at runtime. Returns true if successful. 116 bool GetLoadedSize(size_t* size, std::string* error_msg) const; 117 118 // Load segments into memory based on PT_LOAD program headers. 119 // executable is true at run time, false at compile time. 120 bool Load(File* file, 121 bool executable, 122 bool low_4gb, 123 /*inout*/MemMap* reservation, 124 /*out*/std::string* error_msg); 125 126 bool Fixup(Elf_Addr base_address); 127 bool FixupDynamic(Elf_Addr base_address); 128 bool FixupSectionHeaders(Elf_Addr base_address); 129 bool FixupProgramHeaders(Elf_Addr base_address); 130 bool FixupSymbols(Elf_Addr base_address, bool dynamic); 131 bool FixupRelocations(Elf_Addr base_address); 132 bool FixupDebugSections(Elf_Addr base_address_delta); 133 bool ApplyOatPatchesTo(const char* target_section_name, Elf_Addr base_address_delta); 134 static void ApplyOatPatches(const uint8_t* patches, const uint8_t* patches_end, Elf_Addr delta, 135 uint8_t* to_patch, const uint8_t* to_patch_end); 136 137 bool Strip(File* file, std::string* error_msg); 138 139 private: 140 ElfFileImpl(File* file, bool writable, bool program_header_only); 141 142 bool GetLoadedAddressRange(/*out*/uint8_t** vaddr_begin, 143 /*out*/size_t* vaddr_size, 144 /*out*/std::string* error_msg) const; 145 146 bool Setup(File* file, int prot, int flags, bool low_4gb, std::string* error_msg); 147 148 bool SetMap(File* file, MemMap&& map, std::string* error_msg); 149 150 uint8_t* GetProgramHeadersStart() const; 151 uint8_t* GetSectionHeadersStart() const; 152 Elf_Phdr& GetDynamicProgramHeader() const; 153 Elf_Dyn* GetDynamicSectionStart() const; 154 Elf_Sym* GetSymbolSectionStart(Elf_Word section_type) const; 155 const char* GetStringSectionStart(Elf_Word section_type) const; 156 Elf_Rel* GetRelSectionStart(Elf_Shdr&) const; 157 Elf_Rela* GetRelaSectionStart(Elf_Shdr&) const; 158 Elf_Word* GetHashSectionStart() const; 159 Elf_Word GetHashBucketNum() const; 160 Elf_Word GetHashChainNum() const; 161 Elf_Word GetHashBucket(size_t i, bool* ok) const; 162 Elf_Word GetHashChain(size_t i, bool* ok) const; 163 164 typedef std::map<std::string, Elf_Sym*> SymbolTable; 165 SymbolTable** GetSymbolTable(Elf_Word section_type); 166 167 bool ValidPointer(const uint8_t* start) const; 168 169 const Elf_Sym* FindDynamicSymbol(const std::string& symbol_name) const; 170 171 // Check that certain sections and their dependencies exist. 172 bool CheckSectionsExist(File* file, std::string* error_msg) const; 173 174 // Check that the link of the first section links to the second section. 175 bool CheckSectionsLinked(const uint8_t* source, const uint8_t* target) const; 176 177 // Check whether the offset is in range, and set to target to Begin() + offset if OK. 178 bool CheckAndSet(Elf32_Off offset, const char* label, uint8_t** target, std::string* error_msg); 179 180 // Find symbol in specified table, returning null if it is not found. 181 // 182 // If build_map is true, builds a map to speed repeated access. The 183 // map does not included untyped symbol values (aka STT_NOTYPE) 184 // since they can contain duplicates. If build_map is false, the map 185 // will be used if it was already created. Typically build_map 186 // should be set unless only a small number of symbols will be 187 // looked up. 188 Elf_Sym* FindSymbolByName(Elf_Word section_type, 189 const std::string& symbol_name, 190 bool build_map); 191 192 Elf_Phdr* FindProgamHeaderByType(Elf_Word type) const; 193 194 Elf_Dyn* FindDynamicByType(Elf_Sword type) const; 195 Elf_Word FindDynamicValueByType(Elf_Sword type) const; 196 197 // Lookup a string by section type. Returns null for special 0 offset. 198 const char* GetString(Elf_Word section_type, Elf_Word) const; 199 200 const std::string file_path_; 201 const bool writable_; 202 const bool program_header_only_; 203 204 // ELF header mapping. If program_header_only_ is false, will 205 // actually point to the entire elf file. 206 MemMap map_; 207 Elf_Ehdr* header_; 208 std::vector<MemMap> segments_; 209 210 // Pointer to start of first PT_LOAD program segment after Load() 211 // when program_header_only_ is true. 212 uint8_t* base_address_; 213 214 // The program header should always available but use GetProgramHeadersStart() to be sure. 215 uint8_t* program_headers_start_; 216 217 // Conditionally available values. Use accessors to ensure they exist if they are required. 218 uint8_t* section_headers_start_; 219 Elf_Phdr* dynamic_program_header_; 220 Elf_Dyn* dynamic_section_start_; 221 Elf_Sym* symtab_section_start_; 222 Elf_Sym* dynsym_section_start_; 223 char* strtab_section_start_; 224 char* dynstr_section_start_; 225 Elf_Word* hash_section_start_; 226 227 SymbolTable* symtab_symbol_table_; 228 SymbolTable* dynsym_symbol_table_; 229 230 DISALLOW_COPY_AND_ASSIGN(ElfFileImpl); 231 }; 232 233 } // namespace art 234 235 #endif // ART_RUNTIME_ELF_FILE_IMPL_H_ 236