1 //===- ELFObjectFile.cpp - ELF object file implementation -------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the ELFObjectFile class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ADT/SmallVector.h" 15 #include "llvm/ADT/StringSwitch.h" 16 #include "llvm/ADT/Triple.h" 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/Object/ObjectFile.h" 19 #include "llvm/Support/ELF.h" 20 #include "llvm/Support/Endian.h" 21 #include "llvm/Support/ErrorHandling.h" 22 #include "llvm/Support/MemoryBuffer.h" 23 #include "llvm/Support/raw_ostream.h" 24 #include <algorithm> 25 #include <limits> 26 #include <utility> 27 28 using namespace llvm; 29 using namespace object; 30 31 // Templates to choose Elf_Addr and Elf_Off depending on is64Bits. 32 namespace { 33 template<support::endianness target_endianness> 34 struct ELFDataTypeTypedefHelperCommon { 35 typedef support::detail::packed_endian_specific_integral 36 <uint16_t, target_endianness, support::aligned> Elf_Half; 37 typedef support::detail::packed_endian_specific_integral 38 <uint32_t, target_endianness, support::aligned> Elf_Word; 39 typedef support::detail::packed_endian_specific_integral 40 <int32_t, target_endianness, support::aligned> Elf_Sword; 41 typedef support::detail::packed_endian_specific_integral 42 <uint64_t, target_endianness, support::aligned> Elf_Xword; 43 typedef support::detail::packed_endian_specific_integral 44 <int64_t, target_endianness, support::aligned> Elf_Sxword; 45 }; 46 } 47 48 namespace { 49 template<support::endianness target_endianness, bool is64Bits> 50 struct ELFDataTypeTypedefHelper; 51 52 /// ELF 32bit types. 53 template<support::endianness target_endianness> 54 struct ELFDataTypeTypedefHelper<target_endianness, false> 55 : ELFDataTypeTypedefHelperCommon<target_endianness> { 56 typedef support::detail::packed_endian_specific_integral 57 <uint32_t, target_endianness, support::aligned> Elf_Addr; 58 typedef support::detail::packed_endian_specific_integral 59 <uint32_t, target_endianness, support::aligned> Elf_Off; 60 }; 61 62 /// ELF 64bit types. 63 template<support::endianness target_endianness> 64 struct ELFDataTypeTypedefHelper<target_endianness, true> 65 : ELFDataTypeTypedefHelperCommon<target_endianness>{ 66 typedef support::detail::packed_endian_specific_integral 67 <uint64_t, target_endianness, support::aligned> Elf_Addr; 68 typedef support::detail::packed_endian_specific_integral 69 <uint64_t, target_endianness, support::aligned> Elf_Off; 70 }; 71 } 72 73 // I really don't like doing this, but the alternative is copypasta. 74 #define LLVM_ELF_IMPORT_TYPES(target_endianness, is64Bits) \ 75 typedef typename \ 76 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Addr Elf_Addr; \ 77 typedef typename \ 78 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Off Elf_Off; \ 79 typedef typename \ 80 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Half Elf_Half; \ 81 typedef typename \ 82 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Word Elf_Word; \ 83 typedef typename \ 84 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Sword Elf_Sword; \ 85 typedef typename \ 86 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Xword Elf_Xword; \ 87 typedef typename \ 88 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Sxword Elf_Sxword; 89 90 // Section header. 91 namespace { 92 template<support::endianness target_endianness, bool is64Bits> 93 struct Elf_Shdr_Base; 94 95 template<support::endianness target_endianness> 96 struct Elf_Shdr_Base<target_endianness, false> { 97 LLVM_ELF_IMPORT_TYPES(target_endianness, false) 98 Elf_Word sh_name; // Section name (index into string table) 99 Elf_Word sh_type; // Section type (SHT_*) 100 Elf_Word sh_flags; // Section flags (SHF_*) 101 Elf_Addr sh_addr; // Address where section is to be loaded 102 Elf_Off sh_offset; // File offset of section data, in bytes 103 Elf_Word sh_size; // Size of section, in bytes 104 Elf_Word sh_link; // Section type-specific header table index link 105 Elf_Word sh_info; // Section type-specific extra information 106 Elf_Word sh_addralign;// Section address alignment 107 Elf_Word sh_entsize; // Size of records contained within the section 108 }; 109 110 template<support::endianness target_endianness> 111 struct Elf_Shdr_Base<target_endianness, true> { 112 LLVM_ELF_IMPORT_TYPES(target_endianness, true) 113 Elf_Word sh_name; // Section name (index into string table) 114 Elf_Word sh_type; // Section type (SHT_*) 115 Elf_Xword sh_flags; // Section flags (SHF_*) 116 Elf_Addr sh_addr; // Address where section is to be loaded 117 Elf_Off sh_offset; // File offset of section data, in bytes 118 Elf_Xword sh_size; // Size of section, in bytes 119 Elf_Word sh_link; // Section type-specific header table index link 120 Elf_Word sh_info; // Section type-specific extra information 121 Elf_Xword sh_addralign;// Section address alignment 122 Elf_Xword sh_entsize; // Size of records contained within the section 123 }; 124 125 template<support::endianness target_endianness, bool is64Bits> 126 struct Elf_Shdr_Impl : Elf_Shdr_Base<target_endianness, is64Bits> { 127 using Elf_Shdr_Base<target_endianness, is64Bits>::sh_entsize; 128 using Elf_Shdr_Base<target_endianness, is64Bits>::sh_size; 129 130 /// @brief Get the number of entities this section contains if it has any. 131 unsigned getEntityCount() const { 132 if (sh_entsize == 0) 133 return 0; 134 return sh_size / sh_entsize; 135 } 136 }; 137 } 138 139 namespace { 140 template<support::endianness target_endianness, bool is64Bits> 141 struct Elf_Sym_Base; 142 143 template<support::endianness target_endianness> 144 struct Elf_Sym_Base<target_endianness, false> { 145 LLVM_ELF_IMPORT_TYPES(target_endianness, false) 146 Elf_Word st_name; // Symbol name (index into string table) 147 Elf_Addr st_value; // Value or address associated with the symbol 148 Elf_Word st_size; // Size of the symbol 149 unsigned char st_info; // Symbol's type and binding attributes 150 unsigned char st_other; // Must be zero; reserved 151 Elf_Half st_shndx; // Which section (header table index) it's defined in 152 }; 153 154 template<support::endianness target_endianness> 155 struct Elf_Sym_Base<target_endianness, true> { 156 LLVM_ELF_IMPORT_TYPES(target_endianness, true) 157 Elf_Word st_name; // Symbol name (index into string table) 158 unsigned char st_info; // Symbol's type and binding attributes 159 unsigned char st_other; // Must be zero; reserved 160 Elf_Half st_shndx; // Which section (header table index) it's defined in 161 Elf_Addr st_value; // Value or address associated with the symbol 162 Elf_Xword st_size; // Size of the symbol 163 }; 164 165 template<support::endianness target_endianness, bool is64Bits> 166 struct Elf_Sym_Impl : Elf_Sym_Base<target_endianness, is64Bits> { 167 using Elf_Sym_Base<target_endianness, is64Bits>::st_info; 168 169 // These accessors and mutators correspond to the ELF32_ST_BIND, 170 // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification: 171 unsigned char getBinding() const { return st_info >> 4; } 172 unsigned char getType() const { return st_info & 0x0f; } 173 void setBinding(unsigned char b) { setBindingAndType(b, getType()); } 174 void setType(unsigned char t) { setBindingAndType(getBinding(), t); } 175 void setBindingAndType(unsigned char b, unsigned char t) { 176 st_info = (b << 4) + (t & 0x0f); 177 } 178 }; 179 } 180 181 namespace { 182 template<support::endianness target_endianness, bool is64Bits, bool isRela> 183 struct Elf_Rel_Base; 184 185 template<support::endianness target_endianness> 186 struct Elf_Rel_Base<target_endianness, false, false> { 187 LLVM_ELF_IMPORT_TYPES(target_endianness, false) 188 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 189 Elf_Word r_info; // Symbol table index and type of relocation to apply 190 }; 191 192 template<support::endianness target_endianness> 193 struct Elf_Rel_Base<target_endianness, true, false> { 194 LLVM_ELF_IMPORT_TYPES(target_endianness, true) 195 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 196 Elf_Xword r_info; // Symbol table index and type of relocation to apply 197 }; 198 199 template<support::endianness target_endianness> 200 struct Elf_Rel_Base<target_endianness, false, true> { 201 LLVM_ELF_IMPORT_TYPES(target_endianness, false) 202 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 203 Elf_Word r_info; // Symbol table index and type of relocation to apply 204 Elf_Sword r_addend; // Compute value for relocatable field by adding this 205 }; 206 207 template<support::endianness target_endianness> 208 struct Elf_Rel_Base<target_endianness, true, true> { 209 LLVM_ELF_IMPORT_TYPES(target_endianness, true) 210 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 211 Elf_Xword r_info; // Symbol table index and type of relocation to apply 212 Elf_Sxword r_addend; // Compute value for relocatable field by adding this. 213 }; 214 215 template<support::endianness target_endianness, bool is64Bits, bool isRela> 216 struct Elf_Rel_Impl; 217 218 template<support::endianness target_endianness, bool isRela> 219 struct Elf_Rel_Impl<target_endianness, true, isRela> 220 : Elf_Rel_Base<target_endianness, true, isRela> { 221 using Elf_Rel_Base<target_endianness, true, isRela>::r_info; 222 LLVM_ELF_IMPORT_TYPES(target_endianness, true) 223 224 // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE, 225 // and ELF64_R_INFO macros defined in the ELF specification: 226 uint64_t getSymbol() const { return (r_info >> 32); } 227 unsigned char getType() const { 228 return (unsigned char) (r_info & 0xffffffffL); 229 } 230 void setSymbol(uint64_t s) { setSymbolAndType(s, getType()); } 231 void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); } 232 void setSymbolAndType(uint64_t s, unsigned char t) { 233 r_info = (s << 32) + (t&0xffffffffL); 234 } 235 }; 236 237 template<support::endianness target_endianness, bool isRela> 238 struct Elf_Rel_Impl<target_endianness, false, isRela> 239 : Elf_Rel_Base<target_endianness, false, isRela> { 240 using Elf_Rel_Base<target_endianness, false, isRela>::r_info; 241 LLVM_ELF_IMPORT_TYPES(target_endianness, false) 242 243 // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE, 244 // and ELF32_R_INFO macros defined in the ELF specification: 245 uint32_t getSymbol() const { return (r_info >> 8); } 246 unsigned char getType() const { return (unsigned char) (r_info & 0x0ff); } 247 void setSymbol(uint32_t s) { setSymbolAndType(s, getType()); } 248 void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); } 249 void setSymbolAndType(uint32_t s, unsigned char t) { 250 r_info = (s << 8) + t; 251 } 252 }; 253 254 } 255 256 namespace { 257 template<support::endianness target_endianness, bool is64Bits> 258 class ELFObjectFile : public ObjectFile { 259 LLVM_ELF_IMPORT_TYPES(target_endianness, is64Bits) 260 261 typedef Elf_Shdr_Impl<target_endianness, is64Bits> Elf_Shdr; 262 typedef Elf_Sym_Impl<target_endianness, is64Bits> Elf_Sym; 263 typedef Elf_Rel_Impl<target_endianness, is64Bits, false> Elf_Rel; 264 typedef Elf_Rel_Impl<target_endianness, is64Bits, true> Elf_Rela; 265 266 struct Elf_Ehdr { 267 unsigned char e_ident[ELF::EI_NIDENT]; // ELF Identification bytes 268 Elf_Half e_type; // Type of file (see ET_*) 269 Elf_Half e_machine; // Required architecture for this file (see EM_*) 270 Elf_Word e_version; // Must be equal to 1 271 Elf_Addr e_entry; // Address to jump to in order to start program 272 Elf_Off e_phoff; // Program header table's file offset, in bytes 273 Elf_Off e_shoff; // Section header table's file offset, in bytes 274 Elf_Word e_flags; // Processor-specific flags 275 Elf_Half e_ehsize; // Size of ELF header, in bytes 276 Elf_Half e_phentsize;// Size of an entry in the program header table 277 Elf_Half e_phnum; // Number of entries in the program header table 278 Elf_Half e_shentsize;// Size of an entry in the section header table 279 Elf_Half e_shnum; // Number of entries in the section header table 280 Elf_Half e_shstrndx; // Section header table index of section name 281 // string table 282 bool checkMagic() const { 283 return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0; 284 } 285 unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; } 286 unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; } 287 }; 288 289 typedef SmallVector<const Elf_Shdr*, 1> Sections_t; 290 typedef DenseMap<unsigned, unsigned> IndexMap_t; 291 typedef DenseMap<const Elf_Shdr*, SmallVector<uint32_t, 1> > RelocMap_t; 292 293 const Elf_Ehdr *Header; 294 const Elf_Shdr *SectionHeaderTable; 295 const Elf_Shdr *dot_shstrtab_sec; // Section header string table. 296 const Elf_Shdr *dot_strtab_sec; // Symbol header string table. 297 Sections_t SymbolTableSections; 298 IndexMap_t SymbolTableSectionsIndexMap; 299 DenseMap<const Elf_Sym*, ELF::Elf64_Word> ExtendedSymbolTable; 300 301 /// @brief Map sections to an array of relocation sections that reference 302 /// them sorted by section index. 303 RelocMap_t SectionRelocMap; 304 305 /// @brief Get the relocation section that contains \a Rel. 306 const Elf_Shdr *getRelSection(DataRefImpl Rel) const { 307 return getSection(Rel.w.b); 308 } 309 310 void validateSymbol(DataRefImpl Symb) const; 311 bool isRelocationHasAddend(DataRefImpl Rel) const; 312 template<typename T> 313 const T *getEntry(uint16_t Section, uint32_t Entry) const; 314 template<typename T> 315 const T *getEntry(const Elf_Shdr *Section, uint32_t Entry) const; 316 const Elf_Sym *getSymbol(DataRefImpl Symb) const; 317 const Elf_Shdr *getSection(DataRefImpl index) const; 318 const Elf_Shdr *getSection(uint32_t index) const; 319 const Elf_Rel *getRel(DataRefImpl Rel) const; 320 const Elf_Rela *getRela(DataRefImpl Rela) const; 321 const char *getString(uint32_t section, uint32_t offset) const; 322 const char *getString(const Elf_Shdr *section, uint32_t offset) const; 323 error_code getSymbolName(const Elf_Sym *Symb, StringRef &Res) const; 324 325 protected: 326 virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const; 327 virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const; 328 virtual error_code getSymbolOffset(DataRefImpl Symb, uint64_t &Res) const; 329 virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const; 330 virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const; 331 virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const; 332 virtual error_code isSymbolInternal(DataRefImpl Symb, bool &Res) const; 333 virtual error_code isSymbolGlobal(DataRefImpl Symb, bool &Res) const; 334 virtual error_code isSymbolWeak(DataRefImpl Symb, bool &Res) const; 335 virtual error_code getSymbolType(DataRefImpl Symb, SymbolRef::Type &Res) const; 336 virtual error_code isSymbolAbsolute(DataRefImpl Symb, bool &Res) const; 337 virtual error_code getSymbolSection(DataRefImpl Symb, 338 section_iterator &Res) const; 339 340 virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const; 341 virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const; 342 virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const; 343 virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const; 344 virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const; 345 virtual error_code getSectionAlignment(DataRefImpl Sec, uint64_t &Res) const; 346 virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const; 347 virtual error_code isSectionData(DataRefImpl Sec, bool &Res) const; 348 virtual error_code isSectionBSS(DataRefImpl Sec, bool &Res) const; 349 virtual error_code sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb, 350 bool &Result) const; 351 virtual relocation_iterator getSectionRelBegin(DataRefImpl Sec) const; 352 virtual relocation_iterator getSectionRelEnd(DataRefImpl Sec) const; 353 354 virtual error_code getRelocationNext(DataRefImpl Rel, 355 RelocationRef &Res) const; 356 virtual error_code getRelocationAddress(DataRefImpl Rel, 357 uint64_t &Res) const; 358 virtual error_code getRelocationSymbol(DataRefImpl Rel, 359 SymbolRef &Res) const; 360 virtual error_code getRelocationType(DataRefImpl Rel, 361 uint32_t &Res) const; 362 virtual error_code getRelocationTypeName(DataRefImpl Rel, 363 SmallVectorImpl<char> &Result) const; 364 virtual error_code getRelocationAdditionalInfo(DataRefImpl Rel, 365 int64_t &Res) const; 366 virtual error_code getRelocationValueString(DataRefImpl Rel, 367 SmallVectorImpl<char> &Result) const; 368 369 public: 370 ELFObjectFile(MemoryBuffer *Object, error_code &ec); 371 virtual symbol_iterator begin_symbols() const; 372 virtual symbol_iterator end_symbols() const; 373 virtual section_iterator begin_sections() const; 374 virtual section_iterator end_sections() const; 375 376 virtual uint8_t getBytesInAddress() const; 377 virtual StringRef getFileFormatName() const; 378 virtual unsigned getArch() const; 379 380 uint64_t getNumSections() const; 381 uint64_t getStringTableIndex() const; 382 ELF::Elf64_Word getSymbolTableIndex(const Elf_Sym *symb) const; 383 const Elf_Shdr *getSection(const Elf_Sym *symb) const; 384 385 static inline bool classof(const Binary *v) { 386 return v->getType() == isELF; 387 } 388 static inline bool classof(const ELFObjectFile *v) { return true; } 389 }; 390 } // end namespace 391 392 template<support::endianness target_endianness, bool is64Bits> 393 void ELFObjectFile<target_endianness, is64Bits> 394 ::validateSymbol(DataRefImpl Symb) const { 395 const Elf_Sym *symb = getSymbol(Symb); 396 const Elf_Shdr *SymbolTableSection = SymbolTableSections[Symb.d.b]; 397 // FIXME: We really need to do proper error handling in the case of an invalid 398 // input file. Because we don't use exceptions, I think we'll just pass 399 // an error object around. 400 if (!( symb 401 && SymbolTableSection 402 && symb >= (const Elf_Sym*)(base() 403 + SymbolTableSection->sh_offset) 404 && symb < (const Elf_Sym*)(base() 405 + SymbolTableSection->sh_offset 406 + SymbolTableSection->sh_size))) 407 // FIXME: Proper error handling. 408 report_fatal_error("Symb must point to a valid symbol!"); 409 } 410 411 template<support::endianness target_endianness, bool is64Bits> 412 error_code ELFObjectFile<target_endianness, is64Bits> 413 ::getSymbolNext(DataRefImpl Symb, 414 SymbolRef &Result) const { 415 validateSymbol(Symb); 416 const Elf_Shdr *SymbolTableSection = SymbolTableSections[Symb.d.b]; 417 418 ++Symb.d.a; 419 // Check to see if we are at the end of this symbol table. 420 if (Symb.d.a >= SymbolTableSection->getEntityCount()) { 421 // We are at the end. If there are other symbol tables, jump to them. 422 ++Symb.d.b; 423 Symb.d.a = 1; // The 0th symbol in ELF is fake. 424 // Otherwise return the terminator. 425 if (Symb.d.b >= SymbolTableSections.size()) { 426 Symb.d.a = std::numeric_limits<uint32_t>::max(); 427 Symb.d.b = std::numeric_limits<uint32_t>::max(); 428 } 429 } 430 431 Result = SymbolRef(Symb, this); 432 return object_error::success; 433 } 434 435 template<support::endianness target_endianness, bool is64Bits> 436 error_code ELFObjectFile<target_endianness, is64Bits> 437 ::getSymbolName(DataRefImpl Symb, 438 StringRef &Result) const { 439 validateSymbol(Symb); 440 const Elf_Sym *symb = getSymbol(Symb); 441 return getSymbolName(symb, Result); 442 } 443 444 template<support::endianness target_endianness, bool is64Bits> 445 ELF::Elf64_Word ELFObjectFile<target_endianness, is64Bits> 446 ::getSymbolTableIndex(const Elf_Sym *symb) const { 447 if (symb->st_shndx == ELF::SHN_XINDEX) 448 return ExtendedSymbolTable.lookup(symb); 449 return symb->st_shndx; 450 } 451 452 template<support::endianness target_endianness, bool is64Bits> 453 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Shdr * 454 ELFObjectFile<target_endianness, is64Bits> 455 ::getSection(const Elf_Sym *symb) const { 456 if (symb->st_shndx == ELF::SHN_XINDEX) 457 return getSection(ExtendedSymbolTable.lookup(symb)); 458 if (symb->st_shndx >= ELF::SHN_LORESERVE) 459 return 0; 460 return getSection(symb->st_shndx); 461 } 462 463 template<support::endianness target_endianness, bool is64Bits> 464 error_code ELFObjectFile<target_endianness, is64Bits> 465 ::getSymbolOffset(DataRefImpl Symb, 466 uint64_t &Result) const { 467 validateSymbol(Symb); 468 const Elf_Sym *symb = getSymbol(Symb); 469 const Elf_Shdr *Section; 470 switch (getSymbolTableIndex(symb)) { 471 case ELF::SHN_COMMON: 472 // Undefined symbols have no address yet. 473 case ELF::SHN_UNDEF: 474 Result = UnknownAddressOrSize; 475 return object_error::success; 476 case ELF::SHN_ABS: 477 Result = symb->st_value; 478 return object_error::success; 479 default: Section = getSection(symb); 480 } 481 482 switch (symb->getType()) { 483 case ELF::STT_SECTION: 484 Result = Section ? Section->sh_addr : UnknownAddressOrSize; 485 return object_error::success; 486 case ELF::STT_FUNC: 487 case ELF::STT_OBJECT: 488 case ELF::STT_NOTYPE: 489 Result = symb->st_value; 490 return object_error::success; 491 default: 492 Result = UnknownAddressOrSize; 493 return object_error::success; 494 } 495 } 496 497 template<support::endianness target_endianness, bool is64Bits> 498 error_code ELFObjectFile<target_endianness, is64Bits> 499 ::getSymbolAddress(DataRefImpl Symb, 500 uint64_t &Result) const { 501 validateSymbol(Symb); 502 const Elf_Sym *symb = getSymbol(Symb); 503 const Elf_Shdr *Section; 504 switch (getSymbolTableIndex(symb)) { 505 case ELF::SHN_COMMON: // Fall through. 506 // Undefined symbols have no address yet. 507 case ELF::SHN_UNDEF: 508 Result = UnknownAddressOrSize; 509 return object_error::success; 510 case ELF::SHN_ABS: 511 Result = reinterpret_cast<uintptr_t>(base()+symb->st_value); 512 return object_error::success; 513 default: Section = getSection(symb); 514 } 515 const uint8_t* addr = base(); 516 if (Section) 517 addr += Section->sh_offset; 518 switch (symb->getType()) { 519 case ELF::STT_SECTION: 520 Result = reinterpret_cast<uintptr_t>(addr); 521 return object_error::success; 522 case ELF::STT_FUNC: // Fall through. 523 case ELF::STT_OBJECT: // Fall through. 524 case ELF::STT_NOTYPE: 525 addr += symb->st_value; 526 Result = reinterpret_cast<uintptr_t>(addr); 527 return object_error::success; 528 default: 529 Result = UnknownAddressOrSize; 530 return object_error::success; 531 } 532 } 533 534 template<support::endianness target_endianness, bool is64Bits> 535 error_code ELFObjectFile<target_endianness, is64Bits> 536 ::getSymbolSize(DataRefImpl Symb, 537 uint64_t &Result) const { 538 validateSymbol(Symb); 539 const Elf_Sym *symb = getSymbol(Symb); 540 if (symb->st_size == 0) 541 Result = UnknownAddressOrSize; 542 Result = symb->st_size; 543 return object_error::success; 544 } 545 546 template<support::endianness target_endianness, bool is64Bits> 547 error_code ELFObjectFile<target_endianness, is64Bits> 548 ::getSymbolNMTypeChar(DataRefImpl Symb, 549 char &Result) const { 550 validateSymbol(Symb); 551 const Elf_Sym *symb = getSymbol(Symb); 552 const Elf_Shdr *Section = getSection(symb); 553 554 char ret = '?'; 555 556 if (Section) { 557 switch (Section->sh_type) { 558 case ELF::SHT_PROGBITS: 559 case ELF::SHT_DYNAMIC: 560 switch (Section->sh_flags) { 561 case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR): 562 ret = 't'; break; 563 case (ELF::SHF_ALLOC | ELF::SHF_WRITE): 564 ret = 'd'; break; 565 case ELF::SHF_ALLOC: 566 case (ELF::SHF_ALLOC | ELF::SHF_MERGE): 567 case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS): 568 ret = 'r'; break; 569 } 570 break; 571 case ELF::SHT_NOBITS: ret = 'b'; 572 } 573 } 574 575 switch (getSymbolTableIndex(symb)) { 576 case ELF::SHN_UNDEF: 577 if (ret == '?') 578 ret = 'U'; 579 break; 580 case ELF::SHN_ABS: ret = 'a'; break; 581 case ELF::SHN_COMMON: ret = 'c'; break; 582 } 583 584 switch (symb->getBinding()) { 585 case ELF::STB_GLOBAL: ret = ::toupper(ret); break; 586 case ELF::STB_WEAK: 587 if (getSymbolTableIndex(symb) == ELF::SHN_UNDEF) 588 ret = 'w'; 589 else 590 if (symb->getType() == ELF::STT_OBJECT) 591 ret = 'V'; 592 else 593 ret = 'W'; 594 } 595 596 if (ret == '?' && symb->getType() == ELF::STT_SECTION) { 597 StringRef name; 598 if (error_code ec = getSymbolName(Symb, name)) 599 return ec; 600 Result = StringSwitch<char>(name) 601 .StartsWith(".debug", 'N') 602 .StartsWith(".note", 'n') 603 .Default('?'); 604 return object_error::success; 605 } 606 607 Result = ret; 608 return object_error::success; 609 } 610 611 template<support::endianness target_endianness, bool is64Bits> 612 error_code ELFObjectFile<target_endianness, is64Bits> 613 ::getSymbolType(DataRefImpl Symb, 614 SymbolRef::Type &Result) const { 615 validateSymbol(Symb); 616 const Elf_Sym *symb = getSymbol(Symb); 617 618 if (getSymbolTableIndex(symb) == ELF::SHN_UNDEF) { 619 Result = SymbolRef::ST_External; 620 return object_error::success; 621 } 622 623 switch (symb->getType()) { 624 case ELF::STT_SECTION: 625 Result = SymbolRef::ST_Debug; 626 break; 627 case ELF::STT_FILE: 628 Result = SymbolRef::ST_File; 629 break; 630 case ELF::STT_FUNC: 631 Result = SymbolRef::ST_Function; 632 break; 633 case ELF::STT_OBJECT: 634 Result = SymbolRef::ST_Data; 635 break; 636 default: 637 Result = SymbolRef::ST_Other; 638 break; 639 } 640 return object_error::success; 641 } 642 643 template<support::endianness target_endianness, bool is64Bits> 644 error_code ELFObjectFile<target_endianness, is64Bits> 645 ::isSymbolGlobal(DataRefImpl Symb, 646 bool &Result) const { 647 validateSymbol(Symb); 648 const Elf_Sym *symb = getSymbol(Symb); 649 650 Result = symb->getBinding() == ELF::STB_GLOBAL; 651 return object_error::success; 652 } 653 654 template<support::endianness target_endianness, bool is64Bits> 655 error_code ELFObjectFile<target_endianness, is64Bits> 656 ::isSymbolWeak(DataRefImpl Symb, 657 bool &Result) const { 658 validateSymbol(Symb); 659 const Elf_Sym *symb = getSymbol(Symb); 660 661 Result = symb->getBinding() == ELF::STB_WEAK; 662 return object_error::success; 663 } 664 665 template<support::endianness target_endianness, bool is64Bits> 666 error_code ELFObjectFile<target_endianness, is64Bits> 667 ::isSymbolAbsolute(DataRefImpl Symb, bool &Res) const { 668 validateSymbol(Symb); 669 const Elf_Sym *symb = getSymbol(Symb); 670 Res = symb->st_shndx == ELF::SHN_ABS; 671 return object_error::success; 672 } 673 674 template<support::endianness target_endianness, bool is64Bits> 675 error_code ELFObjectFile<target_endianness, is64Bits> 676 ::getSymbolSection(DataRefImpl Symb, 677 section_iterator &Res) const { 678 validateSymbol(Symb); 679 const Elf_Sym *symb = getSymbol(Symb); 680 const Elf_Shdr *sec = getSection(symb); 681 if (!sec) 682 Res = end_sections(); 683 else { 684 DataRefImpl Sec; 685 Sec.p = reinterpret_cast<intptr_t>(sec); 686 Res = section_iterator(SectionRef(Sec, this)); 687 } 688 return object_error::success; 689 } 690 691 template<support::endianness target_endianness, bool is64Bits> 692 error_code ELFObjectFile<target_endianness, is64Bits> 693 ::isSymbolInternal(DataRefImpl Symb, 694 bool &Result) const { 695 validateSymbol(Symb); 696 const Elf_Sym *symb = getSymbol(Symb); 697 698 if ( symb->getType() == ELF::STT_FILE 699 || symb->getType() == ELF::STT_SECTION) 700 Result = true; 701 Result = false; 702 return object_error::success; 703 } 704 705 template<support::endianness target_endianness, bool is64Bits> 706 error_code ELFObjectFile<target_endianness, is64Bits> 707 ::getSectionNext(DataRefImpl Sec, SectionRef &Result) const { 708 const uint8_t *sec = reinterpret_cast<const uint8_t *>(Sec.p); 709 sec += Header->e_shentsize; 710 Sec.p = reinterpret_cast<intptr_t>(sec); 711 Result = SectionRef(Sec, this); 712 return object_error::success; 713 } 714 715 template<support::endianness target_endianness, bool is64Bits> 716 error_code ELFObjectFile<target_endianness, is64Bits> 717 ::getSectionName(DataRefImpl Sec, 718 StringRef &Result) const { 719 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 720 Result = StringRef(getString(dot_shstrtab_sec, sec->sh_name)); 721 return object_error::success; 722 } 723 724 template<support::endianness target_endianness, bool is64Bits> 725 error_code ELFObjectFile<target_endianness, is64Bits> 726 ::getSectionAddress(DataRefImpl Sec, 727 uint64_t &Result) const { 728 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 729 Result = sec->sh_addr; 730 return object_error::success; 731 } 732 733 template<support::endianness target_endianness, bool is64Bits> 734 error_code ELFObjectFile<target_endianness, is64Bits> 735 ::getSectionSize(DataRefImpl Sec, 736 uint64_t &Result) const { 737 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 738 Result = sec->sh_size; 739 return object_error::success; 740 } 741 742 template<support::endianness target_endianness, bool is64Bits> 743 error_code ELFObjectFile<target_endianness, is64Bits> 744 ::getSectionContents(DataRefImpl Sec, 745 StringRef &Result) const { 746 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 747 const char *start = (const char*)base() + sec->sh_offset; 748 Result = StringRef(start, sec->sh_size); 749 return object_error::success; 750 } 751 752 template<support::endianness target_endianness, bool is64Bits> 753 error_code ELFObjectFile<target_endianness, is64Bits> 754 ::getSectionAlignment(DataRefImpl Sec, 755 uint64_t &Result) const { 756 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 757 Result = sec->sh_addralign; 758 return object_error::success; 759 } 760 761 template<support::endianness target_endianness, bool is64Bits> 762 error_code ELFObjectFile<target_endianness, is64Bits> 763 ::isSectionText(DataRefImpl Sec, 764 bool &Result) const { 765 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 766 if (sec->sh_flags & ELF::SHF_EXECINSTR) 767 Result = true; 768 else 769 Result = false; 770 return object_error::success; 771 } 772 773 template<support::endianness target_endianness, bool is64Bits> 774 error_code ELFObjectFile<target_endianness, is64Bits> 775 ::isSectionData(DataRefImpl Sec, 776 bool &Result) const { 777 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 778 if (sec->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) 779 && sec->sh_type == ELF::SHT_PROGBITS) 780 Result = true; 781 else 782 Result = false; 783 return object_error::success; 784 } 785 786 template<support::endianness target_endianness, bool is64Bits> 787 error_code ELFObjectFile<target_endianness, is64Bits> 788 ::isSectionBSS(DataRefImpl Sec, 789 bool &Result) const { 790 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 791 if (sec->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) 792 && sec->sh_type == ELF::SHT_NOBITS) 793 Result = true; 794 else 795 Result = false; 796 return object_error::success; 797 } 798 799 template<support::endianness target_endianness, bool is64Bits> 800 error_code ELFObjectFile<target_endianness, is64Bits> 801 ::sectionContainsSymbol(DataRefImpl Sec, 802 DataRefImpl Symb, 803 bool &Result) const { 804 // FIXME: Unimplemented. 805 Result = false; 806 return object_error::success; 807 } 808 809 template<support::endianness target_endianness, bool is64Bits> 810 relocation_iterator ELFObjectFile<target_endianness, is64Bits> 811 ::getSectionRelBegin(DataRefImpl Sec) const { 812 DataRefImpl RelData; 813 memset(&RelData, 0, sizeof(RelData)); 814 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 815 typename RelocMap_t::const_iterator ittr = SectionRelocMap.find(sec); 816 if (sec != 0 && ittr != SectionRelocMap.end()) { 817 RelData.w.a = getSection(ittr->second[0])->sh_info; 818 RelData.w.b = ittr->second[0]; 819 RelData.w.c = 0; 820 } 821 return relocation_iterator(RelocationRef(RelData, this)); 822 } 823 824 template<support::endianness target_endianness, bool is64Bits> 825 relocation_iterator ELFObjectFile<target_endianness, is64Bits> 826 ::getSectionRelEnd(DataRefImpl Sec) const { 827 DataRefImpl RelData; 828 memset(&RelData, 0, sizeof(RelData)); 829 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 830 typename RelocMap_t::const_iterator ittr = SectionRelocMap.find(sec); 831 if (sec != 0 && ittr != SectionRelocMap.end()) { 832 // Get the index of the last relocation section for this section. 833 std::size_t relocsecindex = ittr->second[ittr->second.size() - 1]; 834 const Elf_Shdr *relocsec = getSection(relocsecindex); 835 RelData.w.a = relocsec->sh_info; 836 RelData.w.b = relocsecindex; 837 RelData.w.c = relocsec->sh_size / relocsec->sh_entsize; 838 } 839 return relocation_iterator(RelocationRef(RelData, this)); 840 } 841 842 // Relocations 843 template<support::endianness target_endianness, bool is64Bits> 844 error_code ELFObjectFile<target_endianness, is64Bits> 845 ::getRelocationNext(DataRefImpl Rel, 846 RelocationRef &Result) const { 847 ++Rel.w.c; 848 const Elf_Shdr *relocsec = getSection(Rel.w.b); 849 if (Rel.w.c >= (relocsec->sh_size / relocsec->sh_entsize)) { 850 // We have reached the end of the relocations for this section. See if there 851 // is another relocation section. 852 typename RelocMap_t::mapped_type relocseclist = 853 SectionRelocMap.lookup(getSection(Rel.w.a)); 854 855 // Do a binary search for the current reloc section index (which must be 856 // present). Then get the next one. 857 typename RelocMap_t::mapped_type::const_iterator loc = 858 std::lower_bound(relocseclist.begin(), relocseclist.end(), Rel.w.b); 859 ++loc; 860 861 // If there is no next one, don't do anything. The ++Rel.w.c above sets Rel 862 // to the end iterator. 863 if (loc != relocseclist.end()) { 864 Rel.w.b = *loc; 865 Rel.w.a = 0; 866 } 867 } 868 Result = RelocationRef(Rel, this); 869 return object_error::success; 870 } 871 872 template<support::endianness target_endianness, bool is64Bits> 873 error_code ELFObjectFile<target_endianness, is64Bits> 874 ::getRelocationSymbol(DataRefImpl Rel, 875 SymbolRef &Result) const { 876 uint32_t symbolIdx; 877 const Elf_Shdr *sec = getSection(Rel.w.b); 878 switch (sec->sh_type) { 879 default : 880 report_fatal_error("Invalid section type in Rel!"); 881 case ELF::SHT_REL : { 882 symbolIdx = getRel(Rel)->getSymbol(); 883 break; 884 } 885 case ELF::SHT_RELA : { 886 symbolIdx = getRela(Rel)->getSymbol(); 887 break; 888 } 889 } 890 DataRefImpl SymbolData; 891 IndexMap_t::const_iterator it = SymbolTableSectionsIndexMap.find(sec->sh_link); 892 if (it == SymbolTableSectionsIndexMap.end()) 893 report_fatal_error("Relocation symbol table not found!"); 894 SymbolData.d.a = symbolIdx; 895 SymbolData.d.b = it->second; 896 Result = SymbolRef(SymbolData, this); 897 return object_error::success; 898 } 899 900 template<support::endianness target_endianness, bool is64Bits> 901 error_code ELFObjectFile<target_endianness, is64Bits> 902 ::getRelocationAddress(DataRefImpl Rel, 903 uint64_t &Result) const { 904 uint64_t offset; 905 const Elf_Shdr *sec = getSection(Rel.w.b); 906 switch (sec->sh_type) { 907 default : 908 report_fatal_error("Invalid section type in Rel!"); 909 case ELF::SHT_REL : { 910 offset = getRel(Rel)->r_offset; 911 break; 912 } 913 case ELF::SHT_RELA : { 914 offset = getRela(Rel)->r_offset; 915 break; 916 } 917 } 918 919 Result = offset; 920 return object_error::success; 921 } 922 923 template<support::endianness target_endianness, bool is64Bits> 924 error_code ELFObjectFile<target_endianness, is64Bits> 925 ::getRelocationType(DataRefImpl Rel, 926 uint32_t &Result) const { 927 const Elf_Shdr *sec = getSection(Rel.w.b); 928 switch (sec->sh_type) { 929 default : 930 report_fatal_error("Invalid section type in Rel!"); 931 case ELF::SHT_REL : { 932 Result = getRel(Rel)->getType(); 933 break; 934 } 935 case ELF::SHT_RELA : { 936 Result = getRela(Rel)->getType(); 937 break; 938 } 939 } 940 return object_error::success; 941 } 942 943 #define LLVM_ELF_SWITCH_RELOC_TYPE_NAME(enum) \ 944 case ELF::enum: res = #enum; break; 945 946 template<support::endianness target_endianness, bool is64Bits> 947 error_code ELFObjectFile<target_endianness, is64Bits> 948 ::getRelocationTypeName(DataRefImpl Rel, 949 SmallVectorImpl<char> &Result) const { 950 const Elf_Shdr *sec = getSection(Rel.w.b); 951 uint8_t type; 952 StringRef res; 953 switch (sec->sh_type) { 954 default : 955 return object_error::parse_failed; 956 case ELF::SHT_REL : { 957 type = getRel(Rel)->getType(); 958 break; 959 } 960 case ELF::SHT_RELA : { 961 type = getRela(Rel)->getType(); 962 break; 963 } 964 } 965 switch (Header->e_machine) { 966 case ELF::EM_X86_64: 967 switch (type) { 968 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_NONE); 969 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_64); 970 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC32); 971 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOT32); 972 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PLT32); 973 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_COPY); 974 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GLOB_DAT); 975 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_JUMP_SLOT); 976 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_RELATIVE); 977 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPCREL); 978 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_32); 979 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_32S); 980 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_16); 981 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC16); 982 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_8); 983 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC8); 984 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPMOD64); 985 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPOFF64); 986 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TPOFF64); 987 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSGD); 988 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSLD); 989 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPOFF32); 990 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTTPOFF); 991 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TPOFF32); 992 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC64); 993 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTOFF64); 994 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPC32); 995 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_SIZE32); 996 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_SIZE64); 997 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPC32_TLSDESC); 998 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSDESC_CALL); 999 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSDESC); 1000 default: 1001 res = "Unknown"; 1002 } 1003 break; 1004 case ELF::EM_386: 1005 switch (type) { 1006 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_NONE); 1007 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_32); 1008 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC32); 1009 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOT32); 1010 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PLT32); 1011 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_COPY); 1012 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GLOB_DAT); 1013 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_JUMP_SLOT); 1014 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_RELATIVE); 1015 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOTOFF); 1016 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOTPC); 1017 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_32PLT); 1018 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_TPOFF); 1019 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_IE); 1020 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GOTIE); 1021 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LE); 1022 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD); 1023 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM); 1024 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_16); 1025 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC16); 1026 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_8); 1027 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC8); 1028 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_32); 1029 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_PUSH); 1030 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_CALL); 1031 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_POP); 1032 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_32); 1033 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_PUSH); 1034 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_CALL); 1035 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_POP); 1036 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDO_32); 1037 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_IE_32); 1038 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LE_32); 1039 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DTPMOD32); 1040 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DTPOFF32); 1041 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_TPOFF32); 1042 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GOTDESC); 1043 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DESC_CALL); 1044 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DESC); 1045 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_IRELATIVE); 1046 default: 1047 res = "Unknown"; 1048 } 1049 break; 1050 default: 1051 res = "Unknown"; 1052 } 1053 Result.append(res.begin(), res.end()); 1054 return object_error::success; 1055 } 1056 1057 #undef LLVM_ELF_SWITCH_RELOC_TYPE_NAME 1058 1059 template<support::endianness target_endianness, bool is64Bits> 1060 error_code ELFObjectFile<target_endianness, is64Bits> 1061 ::getRelocationAdditionalInfo(DataRefImpl Rel, 1062 int64_t &Result) const { 1063 const Elf_Shdr *sec = getSection(Rel.w.b); 1064 switch (sec->sh_type) { 1065 default : 1066 report_fatal_error("Invalid section type in Rel!"); 1067 case ELF::SHT_REL : { 1068 Result = 0; 1069 return object_error::success; 1070 } 1071 case ELF::SHT_RELA : { 1072 Result = getRela(Rel)->r_addend; 1073 return object_error::success; 1074 } 1075 } 1076 } 1077 1078 template<support::endianness target_endianness, bool is64Bits> 1079 error_code ELFObjectFile<target_endianness, is64Bits> 1080 ::getRelocationValueString(DataRefImpl Rel, 1081 SmallVectorImpl<char> &Result) const { 1082 const Elf_Shdr *sec = getSection(Rel.w.b); 1083 uint8_t type; 1084 StringRef res; 1085 int64_t addend = 0; 1086 uint16_t symbol_index = 0; 1087 switch (sec->sh_type) { 1088 default : 1089 return object_error::parse_failed; 1090 case ELF::SHT_REL : { 1091 type = getRel(Rel)->getType(); 1092 symbol_index = getRel(Rel)->getSymbol(); 1093 // TODO: Read implicit addend from section data. 1094 break; 1095 } 1096 case ELF::SHT_RELA : { 1097 type = getRela(Rel)->getType(); 1098 symbol_index = getRela(Rel)->getSymbol(); 1099 addend = getRela(Rel)->r_addend; 1100 break; 1101 } 1102 } 1103 const Elf_Sym *symb = getEntry<Elf_Sym>(sec->sh_link, symbol_index); 1104 StringRef symname; 1105 if (error_code ec = getSymbolName(symb, symname)) 1106 return ec; 1107 switch (Header->e_machine) { 1108 case ELF::EM_X86_64: 1109 switch (type) { 1110 case ELF::R_X86_64_32S: 1111 res = symname; 1112 break; 1113 case ELF::R_X86_64_PC32: { 1114 std::string fmtbuf; 1115 raw_string_ostream fmt(fmtbuf); 1116 fmt << symname << (addend < 0 ? "" : "+") << addend << "-P"; 1117 fmt.flush(); 1118 Result.append(fmtbuf.begin(), fmtbuf.end()); 1119 } 1120 break; 1121 default: 1122 res = "Unknown"; 1123 } 1124 break; 1125 default: 1126 res = "Unknown"; 1127 } 1128 if (Result.empty()) 1129 Result.append(res.begin(), res.end()); 1130 return object_error::success; 1131 } 1132 1133 template<support::endianness target_endianness, bool is64Bits> 1134 ELFObjectFile<target_endianness, is64Bits>::ELFObjectFile(MemoryBuffer *Object 1135 , error_code &ec) 1136 : ObjectFile(Binary::isELF, Object, ec) 1137 , SectionHeaderTable(0) 1138 , dot_shstrtab_sec(0) 1139 , dot_strtab_sec(0) { 1140 Header = reinterpret_cast<const Elf_Ehdr *>(base()); 1141 1142 if (Header->e_shoff == 0) 1143 return; 1144 1145 SectionHeaderTable = 1146 reinterpret_cast<const Elf_Shdr *>(base() + Header->e_shoff); 1147 uint64_t SectionTableSize = getNumSections() * Header->e_shentsize; 1148 if (!( (const uint8_t *)SectionHeaderTable + SectionTableSize 1149 <= base() + Data->getBufferSize())) 1150 // FIXME: Proper error handling. 1151 report_fatal_error("Section table goes past end of file!"); 1152 1153 1154 // To find the symbol tables we walk the section table to find SHT_SYMTAB. 1155 const Elf_Shdr* SymbolTableSectionHeaderIndex = 0; 1156 const Elf_Shdr* sh = reinterpret_cast<const Elf_Shdr*>(SectionHeaderTable); 1157 for (uint64_t i = 0, e = getNumSections(); i != e; ++i) { 1158 if (sh->sh_type == ELF::SHT_SYMTAB_SHNDX) { 1159 if (SymbolTableSectionHeaderIndex) 1160 // FIXME: Proper error handling. 1161 report_fatal_error("More than one .symtab_shndx!"); 1162 SymbolTableSectionHeaderIndex = sh; 1163 } 1164 if (sh->sh_type == ELF::SHT_SYMTAB) { 1165 SymbolTableSectionsIndexMap[i] = SymbolTableSections.size(); 1166 SymbolTableSections.push_back(sh); 1167 } 1168 if (sh->sh_type == ELF::SHT_REL || sh->sh_type == ELF::SHT_RELA) { 1169 SectionRelocMap[getSection(sh->sh_info)].push_back(i); 1170 } 1171 ++sh; 1172 } 1173 1174 // Sort section relocation lists by index. 1175 for (typename RelocMap_t::iterator i = SectionRelocMap.begin(), 1176 e = SectionRelocMap.end(); i != e; ++i) { 1177 std::sort(i->second.begin(), i->second.end()); 1178 } 1179 1180 // Get string table sections. 1181 dot_shstrtab_sec = getSection(getStringTableIndex()); 1182 if (dot_shstrtab_sec) { 1183 // Verify that the last byte in the string table in a null. 1184 if (((const char*)base() + dot_shstrtab_sec->sh_offset) 1185 [dot_shstrtab_sec->sh_size - 1] != 0) 1186 // FIXME: Proper error handling. 1187 report_fatal_error("String table must end with a null terminator!"); 1188 } 1189 1190 // Merge this into the above loop. 1191 for (const char *i = reinterpret_cast<const char *>(SectionHeaderTable), 1192 *e = i + getNumSections() * Header->e_shentsize; 1193 i != e; i += Header->e_shentsize) { 1194 const Elf_Shdr *sh = reinterpret_cast<const Elf_Shdr*>(i); 1195 if (sh->sh_type == ELF::SHT_STRTAB) { 1196 StringRef SectionName(getString(dot_shstrtab_sec, sh->sh_name)); 1197 if (SectionName == ".strtab") { 1198 if (dot_strtab_sec != 0) 1199 // FIXME: Proper error handling. 1200 report_fatal_error("Already found section named .strtab!"); 1201 dot_strtab_sec = sh; 1202 const char *dot_strtab = (const char*)base() + sh->sh_offset; 1203 if (dot_strtab[sh->sh_size - 1] != 0) 1204 // FIXME: Proper error handling. 1205 report_fatal_error("String table must end with a null terminator!"); 1206 } 1207 } 1208 } 1209 1210 // Build symbol name side-mapping if there is one. 1211 if (SymbolTableSectionHeaderIndex) { 1212 const Elf_Word *ShndxTable = reinterpret_cast<const Elf_Word*>(base() + 1213 SymbolTableSectionHeaderIndex->sh_offset); 1214 error_code ec; 1215 for (symbol_iterator si = begin_symbols(), 1216 se = end_symbols(); si != se; si.increment(ec)) { 1217 if (ec) 1218 report_fatal_error("Fewer extended symbol table entries than symbols!"); 1219 if (*ShndxTable != ELF::SHN_UNDEF) 1220 ExtendedSymbolTable[getSymbol(si->getRawDataRefImpl())] = *ShndxTable; 1221 ++ShndxTable; 1222 } 1223 } 1224 } 1225 1226 template<support::endianness target_endianness, bool is64Bits> 1227 symbol_iterator ELFObjectFile<target_endianness, is64Bits> 1228 ::begin_symbols() const { 1229 DataRefImpl SymbolData; 1230 memset(&SymbolData, 0, sizeof(SymbolData)); 1231 if (SymbolTableSections.size() == 0) { 1232 SymbolData.d.a = std::numeric_limits<uint32_t>::max(); 1233 SymbolData.d.b = std::numeric_limits<uint32_t>::max(); 1234 } else { 1235 SymbolData.d.a = 1; // The 0th symbol in ELF is fake. 1236 SymbolData.d.b = 0; 1237 } 1238 return symbol_iterator(SymbolRef(SymbolData, this)); 1239 } 1240 1241 template<support::endianness target_endianness, bool is64Bits> 1242 symbol_iterator ELFObjectFile<target_endianness, is64Bits> 1243 ::end_symbols() const { 1244 DataRefImpl SymbolData; 1245 memset(&SymbolData, 0, sizeof(SymbolData)); 1246 SymbolData.d.a = std::numeric_limits<uint32_t>::max(); 1247 SymbolData.d.b = std::numeric_limits<uint32_t>::max(); 1248 return symbol_iterator(SymbolRef(SymbolData, this)); 1249 } 1250 1251 template<support::endianness target_endianness, bool is64Bits> 1252 section_iterator ELFObjectFile<target_endianness, is64Bits> 1253 ::begin_sections() const { 1254 DataRefImpl ret; 1255 memset(&ret, 0, sizeof(DataRefImpl)); 1256 ret.p = reinterpret_cast<intptr_t>(base() + Header->e_shoff); 1257 return section_iterator(SectionRef(ret, this)); 1258 } 1259 1260 template<support::endianness target_endianness, bool is64Bits> 1261 section_iterator ELFObjectFile<target_endianness, is64Bits> 1262 ::end_sections() const { 1263 DataRefImpl ret; 1264 memset(&ret, 0, sizeof(DataRefImpl)); 1265 ret.p = reinterpret_cast<intptr_t>(base() 1266 + Header->e_shoff 1267 + (Header->e_shentsize*getNumSections())); 1268 return section_iterator(SectionRef(ret, this)); 1269 } 1270 1271 template<support::endianness target_endianness, bool is64Bits> 1272 uint8_t ELFObjectFile<target_endianness, is64Bits>::getBytesInAddress() const { 1273 return is64Bits ? 8 : 4; 1274 } 1275 1276 template<support::endianness target_endianness, bool is64Bits> 1277 StringRef ELFObjectFile<target_endianness, is64Bits> 1278 ::getFileFormatName() const { 1279 switch(Header->e_ident[ELF::EI_CLASS]) { 1280 case ELF::ELFCLASS32: 1281 switch(Header->e_machine) { 1282 case ELF::EM_386: 1283 return "ELF32-i386"; 1284 case ELF::EM_X86_64: 1285 return "ELF32-x86-64"; 1286 case ELF::EM_ARM: 1287 return "ELF32-arm"; 1288 default: 1289 return "ELF32-unknown"; 1290 } 1291 case ELF::ELFCLASS64: 1292 switch(Header->e_machine) { 1293 case ELF::EM_386: 1294 return "ELF64-i386"; 1295 case ELF::EM_X86_64: 1296 return "ELF64-x86-64"; 1297 default: 1298 return "ELF64-unknown"; 1299 } 1300 default: 1301 // FIXME: Proper error handling. 1302 report_fatal_error("Invalid ELFCLASS!"); 1303 } 1304 } 1305 1306 template<support::endianness target_endianness, bool is64Bits> 1307 unsigned ELFObjectFile<target_endianness, is64Bits>::getArch() const { 1308 switch(Header->e_machine) { 1309 case ELF::EM_386: 1310 return Triple::x86; 1311 case ELF::EM_X86_64: 1312 return Triple::x86_64; 1313 case ELF::EM_ARM: 1314 return Triple::arm; 1315 default: 1316 return Triple::UnknownArch; 1317 } 1318 } 1319 1320 template<support::endianness target_endianness, bool is64Bits> 1321 uint64_t ELFObjectFile<target_endianness, is64Bits>::getNumSections() const { 1322 if (Header->e_shnum == ELF::SHN_UNDEF) 1323 return SectionHeaderTable->sh_size; 1324 return Header->e_shnum; 1325 } 1326 1327 template<support::endianness target_endianness, bool is64Bits> 1328 uint64_t 1329 ELFObjectFile<target_endianness, is64Bits>::getStringTableIndex() const { 1330 if (Header->e_shnum == ELF::SHN_UNDEF) { 1331 if (Header->e_shstrndx == ELF::SHN_HIRESERVE) 1332 return SectionHeaderTable->sh_link; 1333 if (Header->e_shstrndx >= getNumSections()) 1334 return 0; 1335 } 1336 return Header->e_shstrndx; 1337 } 1338 1339 1340 template<support::endianness target_endianness, bool is64Bits> 1341 template<typename T> 1342 inline const T * 1343 ELFObjectFile<target_endianness, is64Bits>::getEntry(uint16_t Section, 1344 uint32_t Entry) const { 1345 return getEntry<T>(getSection(Section), Entry); 1346 } 1347 1348 template<support::endianness target_endianness, bool is64Bits> 1349 template<typename T> 1350 inline const T * 1351 ELFObjectFile<target_endianness, is64Bits>::getEntry(const Elf_Shdr * Section, 1352 uint32_t Entry) const { 1353 return reinterpret_cast<const T *>( 1354 base() 1355 + Section->sh_offset 1356 + (Entry * Section->sh_entsize)); 1357 } 1358 1359 template<support::endianness target_endianness, bool is64Bits> 1360 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Sym * 1361 ELFObjectFile<target_endianness, is64Bits>::getSymbol(DataRefImpl Symb) const { 1362 return getEntry<Elf_Sym>(SymbolTableSections[Symb.d.b], Symb.d.a); 1363 } 1364 1365 template<support::endianness target_endianness, bool is64Bits> 1366 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Rel * 1367 ELFObjectFile<target_endianness, is64Bits>::getRel(DataRefImpl Rel) const { 1368 return getEntry<Elf_Rel>(Rel.w.b, Rel.w.c); 1369 } 1370 1371 template<support::endianness target_endianness, bool is64Bits> 1372 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Rela * 1373 ELFObjectFile<target_endianness, is64Bits>::getRela(DataRefImpl Rela) const { 1374 return getEntry<Elf_Rela>(Rela.w.b, Rela.w.c); 1375 } 1376 1377 template<support::endianness target_endianness, bool is64Bits> 1378 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Shdr * 1379 ELFObjectFile<target_endianness, is64Bits>::getSection(DataRefImpl Symb) const { 1380 const Elf_Shdr *sec = getSection(Symb.d.b); 1381 if (sec->sh_type != ELF::SHT_SYMTAB || sec->sh_type != ELF::SHT_DYNSYM) 1382 // FIXME: Proper error handling. 1383 report_fatal_error("Invalid symbol table section!"); 1384 return sec; 1385 } 1386 1387 template<support::endianness target_endianness, bool is64Bits> 1388 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Shdr * 1389 ELFObjectFile<target_endianness, is64Bits>::getSection(uint32_t index) const { 1390 if (index == 0) 1391 return 0; 1392 if (!SectionHeaderTable || index >= getNumSections()) 1393 // FIXME: Proper error handling. 1394 report_fatal_error("Invalid section index!"); 1395 1396 return reinterpret_cast<const Elf_Shdr *>( 1397 reinterpret_cast<const char *>(SectionHeaderTable) 1398 + (index * Header->e_shentsize)); 1399 } 1400 1401 template<support::endianness target_endianness, bool is64Bits> 1402 const char *ELFObjectFile<target_endianness, is64Bits> 1403 ::getString(uint32_t section, 1404 ELF::Elf32_Word offset) const { 1405 return getString(getSection(section), offset); 1406 } 1407 1408 template<support::endianness target_endianness, bool is64Bits> 1409 const char *ELFObjectFile<target_endianness, is64Bits> 1410 ::getString(const Elf_Shdr *section, 1411 ELF::Elf32_Word offset) const { 1412 assert(section && section->sh_type == ELF::SHT_STRTAB && "Invalid section!"); 1413 if (offset >= section->sh_size) 1414 // FIXME: Proper error handling. 1415 report_fatal_error("Symbol name offset outside of string table!"); 1416 return (const char *)base() + section->sh_offset + offset; 1417 } 1418 1419 template<support::endianness target_endianness, bool is64Bits> 1420 error_code ELFObjectFile<target_endianness, is64Bits> 1421 ::getSymbolName(const Elf_Sym *symb, 1422 StringRef &Result) const { 1423 if (symb->st_name == 0) { 1424 const Elf_Shdr *section = getSection(symb); 1425 if (!section) 1426 Result = ""; 1427 else 1428 Result = getString(dot_shstrtab_sec, section->sh_name); 1429 return object_error::success; 1430 } 1431 1432 // Use the default symbol table name section. 1433 Result = getString(dot_strtab_sec, symb->st_name); 1434 return object_error::success; 1435 } 1436 1437 // EI_CLASS, EI_DATA. 1438 static std::pair<unsigned char, unsigned char> 1439 getElfArchType(MemoryBuffer *Object) { 1440 if (Object->getBufferSize() < ELF::EI_NIDENT) 1441 return std::make_pair((uint8_t)ELF::ELFCLASSNONE,(uint8_t)ELF::ELFDATANONE); 1442 return std::make_pair( (uint8_t)Object->getBufferStart()[ELF::EI_CLASS] 1443 , (uint8_t)Object->getBufferStart()[ELF::EI_DATA]); 1444 } 1445 1446 namespace llvm { 1447 1448 ObjectFile *ObjectFile::createELFObjectFile(MemoryBuffer *Object) { 1449 std::pair<unsigned char, unsigned char> Ident = getElfArchType(Object); 1450 error_code ec; 1451 if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) 1452 return new ELFObjectFile<support::little, false>(Object, ec); 1453 else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) 1454 return new ELFObjectFile<support::big, false>(Object, ec); 1455 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) 1456 return new ELFObjectFile<support::little, true>(Object, ec); 1457 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) 1458 return new ELFObjectFile<support::big, true>(Object, ec); 1459 // FIXME: Proper error handling. 1460 report_fatal_error("Not an ELF object file!"); 1461 } 1462 1463 } // end namespace llvm 1464