ELFDumper.cpp revision 303975
1//===-- ELFDumper.cpp - ELF-specific dumper ---------------------*- 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/// \file 11/// \brief This file implements the ELF-specific dumper for llvm-readobj. 12/// 13//===----------------------------------------------------------------------===// 14 15#include "llvm-readobj.h" 16#include "ARMAttributeParser.h" 17#include "ARMEHABIPrinter.h" 18#include "Error.h" 19#include "ObjDumper.h" 20#include "StackMapPrinter.h" 21#include "StreamWriter.h" 22#include "llvm/ADT/Optional.h" 23#include "llvm/ADT/SmallString.h" 24#include "llvm/ADT/StringExtras.h" 25#include "llvm/Object/ELFObjectFile.h" 26#include "llvm/Support/ARMBuildAttributes.h" 27#include "llvm/Support/Compiler.h" 28#include "llvm/Support/Format.h" 29#include "llvm/Support/MathExtras.h" 30#include "llvm/Support/MipsABIFlags.h" 31#include "llvm/Support/raw_ostream.h" 32 33using namespace llvm; 34using namespace llvm::object; 35using namespace ELF; 36 37#define LLVM_READOBJ_ENUM_CASE(ns, enum) \ 38 case ns::enum: return #enum; 39 40namespace { 41 42template<typename ELFT> 43class ELFDumper : public ObjDumper { 44public: 45 ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer); 46 47 void printFileHeaders() override; 48 void printSections() override; 49 void printRelocations() override; 50 void printDynamicRelocations() override; 51 void printSymbols() override; 52 void printDynamicSymbols() override; 53 void printUnwindInfo() override; 54 55 void printDynamicTable() override; 56 void printNeededLibraries() override; 57 void printProgramHeaders() override; 58 void printHashTable() override; 59 void printGnuHashTable() override; 60 void printLoadName() override; 61 void printVersionInfo() override; 62 63 void printAttributes() override; 64 void printMipsPLTGOT() override; 65 void printMipsABIFlags() override; 66 void printMipsReginfo() override; 67 68 void printStackMap() const override; 69 70private: 71 typedef ELFFile<ELFT> ELFO; 72 typedef typename ELFO::Elf_Shdr Elf_Shdr; 73 typedef typename ELFO::Elf_Sym Elf_Sym; 74 typedef typename ELFO::Elf_Dyn Elf_Dyn; 75 typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range; 76 typedef typename ELFO::Elf_Rel Elf_Rel; 77 typedef typename ELFO::Elf_Rela Elf_Rela; 78 typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range; 79 typedef typename ELFO::Elf_Phdr Elf_Phdr; 80 typedef typename ELFO::Elf_Half Elf_Half; 81 typedef typename ELFO::Elf_Hash Elf_Hash; 82 typedef typename ELFO::Elf_GnuHash Elf_GnuHash; 83 typedef typename ELFO::Elf_Ehdr Elf_Ehdr; 84 typedef typename ELFO::Elf_Word Elf_Word; 85 typedef typename ELFO::uintX_t uintX_t; 86 typedef typename ELFO::Elf_Versym Elf_Versym; 87 typedef typename ELFO::Elf_Verneed Elf_Verneed; 88 typedef typename ELFO::Elf_Vernaux Elf_Vernaux; 89 typedef typename ELFO::Elf_Verdef Elf_Verdef; 90 typedef typename ELFO::Elf_Verdaux Elf_Verdaux; 91 92 /// \brief Represents a region described by entries in the .dynamic table. 93 struct DynRegionInfo { 94 DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {} 95 /// \brief Address in current address space. 96 const void *Addr; 97 /// \brief Size in bytes of the region. 98 uintX_t Size; 99 /// \brief Size of each entity in the region. 100 uintX_t EntSize; 101 }; 102 103 void printSymbolsHelper(bool IsDynamic); 104 void printSymbol(const Elf_Sym *Symbol, const Elf_Shdr *SymTab, 105 StringRef StrTable, bool IsDynamic); 106 107 void printRelocations(const Elf_Shdr *Sec); 108 void printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab); 109 void printValue(uint64_t Type, uint64_t Value); 110 111 const Elf_Rela *dyn_rela_begin() const; 112 const Elf_Rela *dyn_rela_end() const; 113 Elf_Rela_Range dyn_relas() const; 114 StringRef getDynamicString(uint64_t Offset) const; 115 const Elf_Dyn *dynamic_table_begin() const { 116 ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_begin(DynamicProgHeader); 117 error(Ret.getError()); 118 return *Ret; 119 } 120 const Elf_Dyn *dynamic_table_end() const { 121 ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_end(DynamicProgHeader); 122 error(Ret.getError()); 123 return *Ret; 124 } 125 StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb, 126 bool &IsDefault); 127 void LoadVersionMap(); 128 void LoadVersionNeeds(const Elf_Shdr *ec) const; 129 void LoadVersionDefs(const Elf_Shdr *sec) const; 130 131 const ELFO *Obj; 132 DynRegionInfo DynRelaRegion; 133 const Elf_Phdr *DynamicProgHeader = nullptr; 134 StringRef DynamicStringTable; 135 const Elf_Sym *DynSymStart = nullptr; 136 StringRef SOName; 137 const Elf_Hash *HashTable = nullptr; 138 const Elf_GnuHash *GnuHashTable = nullptr; 139 const Elf_Shdr *DotDynSymSec = nullptr; 140 const Elf_Shdr *DotSymtabSec = nullptr; 141 ArrayRef<Elf_Word> ShndxTable; 142 143 const Elf_Shdr *dot_gnu_version_sec = nullptr; // .gnu.version 144 const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r 145 const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d 146 147 // Records for each version index the corresponding Verdef or Vernaux entry. 148 // This is filled the first time LoadVersionMap() is called. 149 class VersionMapEntry : public PointerIntPair<const void *, 1> { 150 public: 151 // If the integer is 0, this is an Elf_Verdef*. 152 // If the integer is 1, this is an Elf_Vernaux*. 153 VersionMapEntry() : PointerIntPair<const void *, 1>(nullptr, 0) {} 154 VersionMapEntry(const Elf_Verdef *verdef) 155 : PointerIntPair<const void *, 1>(verdef, 0) {} 156 VersionMapEntry(const Elf_Vernaux *vernaux) 157 : PointerIntPair<const void *, 1>(vernaux, 1) {} 158 bool isNull() const { return getPointer() == nullptr; } 159 bool isVerdef() const { return !isNull() && getInt() == 0; } 160 bool isVernaux() const { return !isNull() && getInt() == 1; } 161 const Elf_Verdef *getVerdef() const { 162 return isVerdef() ? (const Elf_Verdef *)getPointer() : nullptr; 163 } 164 const Elf_Vernaux *getVernaux() const { 165 return isVernaux() ? (const Elf_Vernaux *)getPointer() : nullptr; 166 } 167 }; 168 mutable SmallVector<VersionMapEntry, 16> VersionMap; 169 170public: 171 Elf_Dyn_Range dynamic_table() const { 172 ErrorOr<Elf_Dyn_Range> Ret = Obj->dynamic_table(DynamicProgHeader); 173 error(Ret.getError()); 174 return *Ret; 175 } 176 177 std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable, 178 bool IsDynamic); 179 const Elf_Shdr *getDotDynSymSec() const { return DotDynSymSec; } 180 const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; } 181 ArrayRef<Elf_Word> getShndxTable() { return ShndxTable; } 182}; 183 184template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) { 185 if (!Val) { 186 error(Val.getError()); 187 return Default; 188 } 189 190 return *Val; 191} 192} // namespace 193 194namespace llvm { 195 196template <class ELFT> 197static std::error_code createELFDumper(const ELFFile<ELFT> *Obj, 198 StreamWriter &Writer, 199 std::unique_ptr<ObjDumper> &Result) { 200 Result.reset(new ELFDumper<ELFT>(Obj, Writer)); 201 return readobj_error::success; 202} 203 204std::error_code createELFDumper(const object::ObjectFile *Obj, 205 StreamWriter &Writer, 206 std::unique_ptr<ObjDumper> &Result) { 207 // Little-endian 32-bit 208 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) 209 return createELFDumper(ELFObj->getELFFile(), Writer, Result); 210 211 // Big-endian 32-bit 212 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj)) 213 return createELFDumper(ELFObj->getELFFile(), Writer, Result); 214 215 // Little-endian 64-bit 216 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj)) 217 return createELFDumper(ELFObj->getELFFile(), Writer, Result); 218 219 // Big-endian 64-bit 220 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj)) 221 return createELFDumper(ELFObj->getELFFile(), Writer, Result); 222 223 return readobj_error::unsupported_obj_file_format; 224} 225 226} // namespace llvm 227 228// Iterate through the versions needed section, and place each Elf_Vernaux 229// in the VersionMap according to its index. 230template <class ELFT> 231void ELFDumper<ELFT>::LoadVersionNeeds(const Elf_Shdr *sec) const { 232 unsigned vn_size = sec->sh_size; // Size of section in bytes 233 unsigned vn_count = sec->sh_info; // Number of Verneed entries 234 const char *sec_start = (const char *)Obj->base() + sec->sh_offset; 235 const char *sec_end = sec_start + vn_size; 236 // The first Verneed entry is at the start of the section. 237 const char *p = sec_start; 238 for (unsigned i = 0; i < vn_count; i++) { 239 if (p + sizeof(Elf_Verneed) > sec_end) 240 report_fatal_error("Section ended unexpectedly while scanning " 241 "version needed records."); 242 const Elf_Verneed *vn = reinterpret_cast<const Elf_Verneed *>(p); 243 if (vn->vn_version != ELF::VER_NEED_CURRENT) 244 report_fatal_error("Unexpected verneed version"); 245 // Iterate through the Vernaux entries 246 const char *paux = p + vn->vn_aux; 247 for (unsigned j = 0; j < vn->vn_cnt; j++) { 248 if (paux + sizeof(Elf_Vernaux) > sec_end) 249 report_fatal_error("Section ended unexpected while scanning auxiliary " 250 "version needed records."); 251 const Elf_Vernaux *vna = reinterpret_cast<const Elf_Vernaux *>(paux); 252 size_t index = vna->vna_other & ELF::VERSYM_VERSION; 253 if (index >= VersionMap.size()) 254 VersionMap.resize(index + 1); 255 VersionMap[index] = VersionMapEntry(vna); 256 paux += vna->vna_next; 257 } 258 p += vn->vn_next; 259 } 260} 261 262// Iterate through the version definitions, and place each Elf_Verdef 263// in the VersionMap according to its index. 264template <class ELFT> 265void ELFDumper<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const { 266 unsigned vd_size = sec->sh_size; // Size of section in bytes 267 unsigned vd_count = sec->sh_info; // Number of Verdef entries 268 const char *sec_start = (const char *)Obj->base() + sec->sh_offset; 269 const char *sec_end = sec_start + vd_size; 270 // The first Verdef entry is at the start of the section. 271 const char *p = sec_start; 272 for (unsigned i = 0; i < vd_count; i++) { 273 if (p + sizeof(Elf_Verdef) > sec_end) 274 report_fatal_error("Section ended unexpectedly while scanning " 275 "version definitions."); 276 const Elf_Verdef *vd = reinterpret_cast<const Elf_Verdef *>(p); 277 if (vd->vd_version != ELF::VER_DEF_CURRENT) 278 report_fatal_error("Unexpected verdef version"); 279 size_t index = vd->vd_ndx & ELF::VERSYM_VERSION; 280 if (index >= VersionMap.size()) 281 VersionMap.resize(index + 1); 282 VersionMap[index] = VersionMapEntry(vd); 283 p += vd->vd_next; 284 } 285} 286 287template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() { 288 // If there is no dynamic symtab or version table, there is nothing to do. 289 if (!DynSymStart || !dot_gnu_version_sec) 290 return; 291 292 // Has the VersionMap already been loaded? 293 if (VersionMap.size() > 0) 294 return; 295 296 // The first two version indexes are reserved. 297 // Index 0 is LOCAL, index 1 is GLOBAL. 298 VersionMap.push_back(VersionMapEntry()); 299 VersionMap.push_back(VersionMapEntry()); 300 301 if (dot_gnu_version_d_sec) 302 LoadVersionDefs(dot_gnu_version_d_sec); 303 304 if (dot_gnu_version_r_sec) 305 LoadVersionNeeds(dot_gnu_version_r_sec); 306} 307 308 309template <typename ELFO, class ELFT> 310static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper, 311 const ELFO *Obj, 312 const typename ELFO::Elf_Shdr *Sec, 313 StreamWriter &W) { 314 DictScope SS(W, "Version symbols"); 315 if (!Sec) 316 return; 317 StringRef Name = errorOrDefault(Obj->getSectionName(Sec)); 318 W.printNumber("Section Name", Name, Sec->sh_name); 319 W.printHex("Address", Sec->sh_addr); 320 W.printHex("Offset", Sec->sh_offset); 321 W.printNumber("Link", Sec->sh_link); 322 323 const typename ELFO::Elf_Shdr *DynSymSec = Dumper->getDotDynSymSec(); 324 const uint8_t *P = (const uint8_t *)Obj->base() + Sec->sh_offset; 325 ErrorOr<StringRef> StrTableOrErr = 326 Obj->getStringTableForSymtab(*DynSymSec); 327 error(StrTableOrErr.getError()); 328 329 // Same number of entries in the dynamic symbol table (DT_SYMTAB). 330 ListScope Syms(W, "Symbols"); 331 for (const typename ELFO::Elf_Sym &Sym : Obj->symbols(DynSymSec)) { 332 DictScope S(W, "Symbol"); 333 std::string FullSymbolName = 334 Dumper->getFullSymbolName(&Sym, *StrTableOrErr, true /* IsDynamic */); 335 W.printNumber("Version", *P); 336 W.printString("Name", FullSymbolName); 337 P += sizeof(typename ELFO::Elf_Half); 338 } 339} 340 341template <typename ELFO, class ELFT> 342static void printVersionDefinitionSection(ELFDumper<ELFT> *Dumper, 343 const ELFO *Obj, 344 const typename ELFO::Elf_Shdr *Sec, 345 StreamWriter &W) { 346 DictScope SD(W, "Version definition"); 347 if (!Sec) 348 return; 349 StringRef Name = errorOrDefault(Obj->getSectionName(Sec)); 350 W.printNumber("Section Name", Name, Sec->sh_name); 351 W.printHex("Address", Sec->sh_addr); 352 W.printHex("Offset", Sec->sh_offset); 353 W.printNumber("Link", Sec->sh_link); 354 355 unsigned verdef_entries = 0; 356 // The number of entries in the section SHT_GNU_verdef 357 // is determined by DT_VERDEFNUM tag. 358 for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) { 359 if (Dyn.d_tag == DT_VERDEFNUM) 360 verdef_entries = Dyn.d_un.d_val; 361 } 362 const uint8_t *SecStartAddress = 363 (const uint8_t *)Obj->base() + Sec->sh_offset; 364 const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size; 365 const uint8_t *P = SecStartAddress; 366 ErrorOr<const typename ELFO::Elf_Shdr *> StrTabOrErr = 367 Obj->getSection(Sec->sh_link); 368 error(StrTabOrErr.getError()); 369 370 ListScope Entries(W, "Entries"); 371 for (unsigned i = 0; i < verdef_entries; ++i) { 372 if (P + sizeof(typename ELFO::Elf_Verdef) > SecEndAddress) 373 report_fatal_error("invalid offset in the section"); 374 auto *VD = reinterpret_cast<const typename ELFO::Elf_Verdef *>(P); 375 DictScope Entry(W, "Entry"); 376 W.printHex("Offset", (uintptr_t)P - (uintptr_t)SecStartAddress); 377 W.printNumber("Rev", VD->vd_version); 378 // FIXME: print something more readable. 379 W.printNumber("Flags", VD->vd_flags); 380 W.printNumber("Index", VD->vd_ndx); 381 W.printNumber("Cnt", VD->vd_cnt); 382 W.printString("Name", StringRef((const char *)(Obj->base() + 383 (*StrTabOrErr)->sh_offset + 384 VD->getAux()->vda_name))); 385 P += VD->vd_next; 386 } 387} 388 389template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { 390 // Dump version symbol section. 391 printVersionSymbolSection(this, Obj, dot_gnu_version_sec, W); 392 393 // Dump version definition section. 394 printVersionDefinitionSection(this, Obj, dot_gnu_version_d_sec, W); 395} 396 397template <typename ELFT> 398StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab, 399 const Elf_Sym *symb, 400 bool &IsDefault) { 401 // This is a dynamic symbol. Look in the GNU symbol version table. 402 if (!dot_gnu_version_sec) { 403 // No version table. 404 IsDefault = false; 405 return StringRef(""); 406 } 407 408 // Determine the position in the symbol table of this entry. 409 size_t entry_index = (reinterpret_cast<uintptr_t>(symb) - 410 reinterpret_cast<uintptr_t>(DynSymStart)) / 411 sizeof(Elf_Sym); 412 413 // Get the corresponding version index entry 414 const Elf_Versym *vs = 415 Obj->template getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index); 416 size_t version_index = vs->vs_index & ELF::VERSYM_VERSION; 417 418 // Special markers for unversioned symbols. 419 if (version_index == ELF::VER_NDX_LOCAL || 420 version_index == ELF::VER_NDX_GLOBAL) { 421 IsDefault = false; 422 return StringRef(""); 423 } 424 425 // Lookup this symbol in the version table 426 LoadVersionMap(); 427 if (version_index >= VersionMap.size() || VersionMap[version_index].isNull()) 428 reportError("Invalid version entry"); 429 const VersionMapEntry &entry = VersionMap[version_index]; 430 431 // Get the version name string 432 size_t name_offset; 433 if (entry.isVerdef()) { 434 // The first Verdaux entry holds the name. 435 name_offset = entry.getVerdef()->getAux()->vda_name; 436 IsDefault = !(vs->vs_index & ELF::VERSYM_HIDDEN); 437 } else { 438 name_offset = entry.getVernaux()->vna_name; 439 IsDefault = false; 440 } 441 if (name_offset >= StrTab.size()) 442 reportError("Invalid string offset"); 443 return StringRef(StrTab.data() + name_offset); 444} 445 446template <typename ELFT> 447std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol, 448 StringRef StrTable, 449 bool IsDynamic) { 450 StringRef SymbolName = errorOrDefault(Symbol->getName(StrTable)); 451 if (!IsDynamic) 452 return SymbolName; 453 454 std::string FullSymbolName(SymbolName); 455 456 bool IsDefault; 457 StringRef Version = getSymbolVersion(StrTable, &*Symbol, IsDefault); 458 FullSymbolName += (IsDefault ? "@@" : "@"); 459 FullSymbolName += Version; 460 return FullSymbolName; 461} 462 463template <typename ELFO> 464static void 465getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol, 466 const typename ELFO::Elf_Shdr *SymTab, 467 ArrayRef<typename ELFO::Elf_Word> ShndxTable, 468 StringRef &SectionName, unsigned &SectionIndex) { 469 SectionIndex = Symbol->st_shndx; 470 if (Symbol->isUndefined()) 471 SectionName = "Undefined"; 472 else if (Symbol->isProcessorSpecific()) 473 SectionName = "Processor Specific"; 474 else if (Symbol->isOSSpecific()) 475 SectionName = "Operating System Specific"; 476 else if (Symbol->isAbsolute()) 477 SectionName = "Absolute"; 478 else if (Symbol->isCommon()) 479 SectionName = "Common"; 480 else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX) 481 SectionName = "Reserved"; 482 else { 483 if (SectionIndex == SHN_XINDEX) 484 SectionIndex = 485 Obj.getExtendedSymbolTableIndex(Symbol, SymTab, ShndxTable); 486 ErrorOr<const typename ELFO::Elf_Shdr *> Sec = Obj.getSection(SectionIndex); 487 error(Sec.getError()); 488 SectionName = errorOrDefault(Obj.getSectionName(*Sec)); 489 } 490} 491 492template <class ELFO> 493static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj, 494 uint64_t Addr) { 495 for (const auto &Shdr : Obj->sections()) 496 if (Shdr.sh_addr == Addr) 497 return &Shdr; 498 return nullptr; 499} 500 501template <class ELFO> 502static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj, 503 StringRef Name) { 504 for (const auto &Shdr : Obj.sections()) { 505 if (Name == errorOrDefault(Obj.getSectionName(&Shdr))) 506 return &Shdr; 507 } 508 return nullptr; 509} 510 511static const EnumEntry<unsigned> ElfClass[] = { 512 { "None", ELF::ELFCLASSNONE }, 513 { "32-bit", ELF::ELFCLASS32 }, 514 { "64-bit", ELF::ELFCLASS64 }, 515}; 516 517static const EnumEntry<unsigned> ElfDataEncoding[] = { 518 { "None", ELF::ELFDATANONE }, 519 { "LittleEndian", ELF::ELFDATA2LSB }, 520 { "BigEndian", ELF::ELFDATA2MSB }, 521}; 522 523static const EnumEntry<unsigned> ElfObjectFileType[] = { 524 { "None", ELF::ET_NONE }, 525 { "Relocatable", ELF::ET_REL }, 526 { "Executable", ELF::ET_EXEC }, 527 { "SharedObject", ELF::ET_DYN }, 528 { "Core", ELF::ET_CORE }, 529}; 530 531static const EnumEntry<unsigned> ElfOSABI[] = { 532 { "SystemV", ELF::ELFOSABI_NONE }, 533 { "HPUX", ELF::ELFOSABI_HPUX }, 534 { "NetBSD", ELF::ELFOSABI_NETBSD }, 535 { "GNU/Linux", ELF::ELFOSABI_LINUX }, 536 { "GNU/Hurd", ELF::ELFOSABI_HURD }, 537 { "Solaris", ELF::ELFOSABI_SOLARIS }, 538 { "AIX", ELF::ELFOSABI_AIX }, 539 { "IRIX", ELF::ELFOSABI_IRIX }, 540 { "FreeBSD", ELF::ELFOSABI_FREEBSD }, 541 { "TRU64", ELF::ELFOSABI_TRU64 }, 542 { "Modesto", ELF::ELFOSABI_MODESTO }, 543 { "OpenBSD", ELF::ELFOSABI_OPENBSD }, 544 { "OpenVMS", ELF::ELFOSABI_OPENVMS }, 545 { "NSK", ELF::ELFOSABI_NSK }, 546 { "AROS", ELF::ELFOSABI_AROS }, 547 { "FenixOS", ELF::ELFOSABI_FENIXOS }, 548 { "CloudABI", ELF::ELFOSABI_CLOUDABI }, 549 { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI }, 550 { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX }, 551 { "ARM", ELF::ELFOSABI_ARM }, 552 { "Standalone" , ELF::ELFOSABI_STANDALONE } 553}; 554 555static const EnumEntry<unsigned> ElfMachineType[] = { 556 LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE ), 557 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32 ), 558 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC ), 559 LLVM_READOBJ_ENUM_ENT(ELF, EM_386 ), 560 LLVM_READOBJ_ENUM_ENT(ELF, EM_68K ), 561 LLVM_READOBJ_ENUM_ENT(ELF, EM_88K ), 562 LLVM_READOBJ_ENUM_ENT(ELF, EM_IAMCU ), 563 LLVM_READOBJ_ENUM_ENT(ELF, EM_860 ), 564 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS ), 565 LLVM_READOBJ_ENUM_ENT(ELF, EM_S370 ), 566 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE ), 567 LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC ), 568 LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500 ), 569 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS ), 570 LLVM_READOBJ_ENUM_ENT(ELF, EM_960 ), 571 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC ), 572 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64 ), 573 LLVM_READOBJ_ENUM_ENT(ELF, EM_S390 ), 574 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU ), 575 LLVM_READOBJ_ENUM_ENT(ELF, EM_V800 ), 576 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20 ), 577 LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32 ), 578 LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE ), 579 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM ), 580 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA ), 581 LLVM_READOBJ_ENUM_ENT(ELF, EM_SH ), 582 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9 ), 583 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE ), 584 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC ), 585 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300 ), 586 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H ), 587 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S ), 588 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500 ), 589 LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64 ), 590 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X ), 591 LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE ), 592 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12 ), 593 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA ), 594 LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP ), 595 LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU ), 596 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1 ), 597 LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE ), 598 LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16 ), 599 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100 ), 600 LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ ), 601 LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64 ), 602 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP ), 603 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10 ), 604 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11 ), 605 LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66 ), 606 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS ), 607 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7 ), 608 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16 ), 609 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11 ), 610 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08 ), 611 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05 ), 612 LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX ), 613 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19 ), 614 LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX ), 615 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS ), 616 LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN ), 617 LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH ), 618 LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP ), 619 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX ), 620 LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY ), 621 LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM ), 622 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR ), 623 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30 ), 624 LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V ), 625 LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V ), 626 LLVM_READOBJ_ENUM_ENT(ELF, EM_V850 ), 627 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R ), 628 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300 ), 629 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200 ), 630 LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ ), 631 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC ), 632 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT ), 633 LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA ), 634 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE ), 635 LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP ), 636 LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K ), 637 LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC ), 638 LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K ), 639 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200 ), 640 LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K ), 641 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX ), 642 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR ), 643 LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16 ), 644 LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430 ), 645 LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN ), 646 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33 ), 647 LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP ), 648 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA ), 649 LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE ), 650 LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS ), 651 LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP ), 652 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ), 653 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX ), 654 LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE ), 655 LLVM_READOBJ_ENUM_ENT(ELF, EM_C166 ), 656 LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C ), 657 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F ), 658 LLVM_READOBJ_ENUM_ENT(ELF, EM_CE ), 659 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C ), 660 LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000 ), 661 LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08 ), 662 LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC ), 663 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2 ), 664 LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7 ), 665 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24 ), 666 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3 ), 667 LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32), 668 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17 ), 669 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000 ), 670 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000 ), 671 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500 ), 672 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS ), 673 LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C ), 674 LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C ), 675 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA ), 676 LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON ), 677 LLVM_READOBJ_ENUM_ENT(ELF, EM_8051 ), 678 LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X ), 679 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32 ), 680 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1 ), 681 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X ), 682 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30 ), 683 LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16 ), 684 LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK ), 685 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2 ), 686 LLVM_READOBJ_ENUM_ENT(ELF, EM_RX ), 687 LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG ), 688 LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS ), 689 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16 ), 690 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16 ), 691 LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU ), 692 LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X ), 693 LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M ), 694 LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M ), 695 LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64 ), 696 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32 ), 697 LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8 ), 698 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64 ), 699 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO ), 700 LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA ), 701 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX ), 702 LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD ), 703 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST ), 704 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND ), 705 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ), 706 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8 ), 707 LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78 ), 708 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5 ), 709 LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR ), 710 LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX ), 711 LLVM_READOBJ_ENUM_ENT(ELF, EM_AMDGPU ), 712 LLVM_READOBJ_ENUM_ENT(ELF, EM_WEBASSEMBLY ), 713}; 714 715static const EnumEntry<unsigned> ElfSymbolBindings[] = { 716 { "Local", ELF::STB_LOCAL }, 717 { "Global", ELF::STB_GLOBAL }, 718 { "Weak", ELF::STB_WEAK }, 719 { "Unique", ELF::STB_GNU_UNIQUE } 720}; 721 722static const EnumEntry<unsigned> ElfSymbolTypes[] = { 723 { "None", ELF::STT_NOTYPE }, 724 { "Object", ELF::STT_OBJECT }, 725 { "Function", ELF::STT_FUNC }, 726 { "Section", ELF::STT_SECTION }, 727 { "File", ELF::STT_FILE }, 728 { "Common", ELF::STT_COMMON }, 729 { "TLS", ELF::STT_TLS }, 730 { "GNU_IFunc", ELF::STT_GNU_IFUNC } 731}; 732 733static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { 734 { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL }, 735 { "AMDGPU_HSA_INDIRECT_FUNCTION", ELF::STT_AMDGPU_HSA_INDIRECT_FUNCTION }, 736 { "AMDGPU_HSA_METADATA", ELF::STT_AMDGPU_HSA_METADATA } 737}; 738 739static const char *getElfSectionType(unsigned Arch, unsigned Type) { 740 switch (Arch) { 741 case ELF::EM_ARM: 742 switch (Type) { 743 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX); 744 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP); 745 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES); 746 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY); 747 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION); 748 } 749 case ELF::EM_HEXAGON: 750 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); } 751 case ELF::EM_X86_64: 752 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); } 753 case ELF::EM_MIPS: 754 case ELF::EM_MIPS_RS3_LE: 755 switch (Type) { 756 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO); 757 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS); 758 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS); 759 } 760 } 761 762 switch (Type) { 763 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL ); 764 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS ); 765 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB ); 766 LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB ); 767 LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA ); 768 LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH ); 769 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC ); 770 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE ); 771 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS ); 772 LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL ); 773 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB ); 774 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM ); 775 LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY ); 776 LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY ); 777 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY ); 778 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP ); 779 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX ); 780 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES ); 781 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH ); 782 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef ); 783 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed ); 784 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym ); 785 default: return ""; 786 } 787} 788 789static const EnumEntry<unsigned> ElfSectionFlags[] = { 790 LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE ), 791 LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC ), 792 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE ), 793 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR ), 794 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE ), 795 LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS ), 796 LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK ), 797 LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER ), 798 LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING), 799 LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP ), 800 LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS ), 801 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION), 802 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION), 803 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP ), 804 LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_GLOBAL), 805 LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_READONLY), 806 LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_CODE), 807 LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_AGENT) 808}; 809 810static const char *getElfSegmentType(unsigned Arch, unsigned Type) { 811 // Check potentially overlapped processor-specific 812 // program header type. 813 switch (Arch) { 814 case ELF::EM_AMDGPU: 815 switch (Type) { 816 LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM); 817 LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT); 818 LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT); 819 LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT); 820 } 821 case ELF::EM_ARM: 822 switch (Type) { 823 LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX); 824 } 825 case ELF::EM_MIPS: 826 case ELF::EM_MIPS_RS3_LE: 827 switch (Type) { 828 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO); 829 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC); 830 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS); 831 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS); 832 } 833 } 834 835 switch (Type) { 836 LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL ); 837 LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD ); 838 LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC); 839 LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP ); 840 LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE ); 841 LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB ); 842 LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR ); 843 LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS ); 844 845 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME); 846 LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND); 847 848 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK); 849 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO); 850 default: return ""; 851 } 852} 853 854static const EnumEntry<unsigned> ElfSegmentFlags[] = { 855 LLVM_READOBJ_ENUM_ENT(ELF, PF_X), 856 LLVM_READOBJ_ENUM_ENT(ELF, PF_W), 857 LLVM_READOBJ_ENUM_ENT(ELF, PF_R) 858}; 859 860static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { 861 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER), 862 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC), 863 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC), 864 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2), 865 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE), 866 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64), 867 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008), 868 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32), 869 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64), 870 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32), 871 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64), 872 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900), 873 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010), 874 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100), 875 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650), 876 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120), 877 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111), 878 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1), 879 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON), 880 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR), 881 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2), 882 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3), 883 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400), 884 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900), 885 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500), 886 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000), 887 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E), 888 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F), 889 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A), 890 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS), 891 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16), 892 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX), 893 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1), 894 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2), 895 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3), 896 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4), 897 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5), 898 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32), 899 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64), 900 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2), 901 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2), 902 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6), 903 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6) 904}; 905 906template <typename ELFT> 907ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer) 908 : ObjDumper(Writer), Obj(Obj) { 909 910 SmallVector<const Elf_Phdr *, 4> LoadSegments; 911 for (const Elf_Phdr &Phdr : Obj->program_headers()) { 912 if (Phdr.p_type == ELF::PT_DYNAMIC) { 913 DynamicProgHeader = &Phdr; 914 continue; 915 } 916 if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0) 917 continue; 918 LoadSegments.push_back(&Phdr); 919 } 920 921 auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * { 922 const Elf_Phdr **I = std::upper_bound( 923 LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>); 924 if (I == LoadSegments.begin()) 925 report_fatal_error("Virtual address is not in any segment"); 926 --I; 927 const Elf_Phdr &Phdr = **I; 928 uint64_t Delta = VAddr - Phdr.p_vaddr; 929 if (Delta >= Phdr.p_filesz) 930 report_fatal_error("Virtual address is not in any segment"); 931 return Obj->base() + Phdr.p_offset + Delta; 932 }; 933 934 uint64_t SONameOffset = 0; 935 const char *StringTableBegin = nullptr; 936 uint64_t StringTableSize = 0; 937 for (const Elf_Dyn &Dyn : dynamic_table()) { 938 switch (Dyn.d_tag) { 939 case ELF::DT_HASH: 940 HashTable = 941 reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr())); 942 break; 943 case ELF::DT_GNU_HASH: 944 GnuHashTable = 945 reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr())); 946 break; 947 case ELF::DT_RELA: 948 DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr()); 949 break; 950 case ELF::DT_RELASZ: 951 DynRelaRegion.Size = Dyn.getVal(); 952 break; 953 case ELF::DT_RELAENT: 954 DynRelaRegion.EntSize = Dyn.getVal(); 955 break; 956 case ELF::DT_SONAME: 957 SONameOffset = Dyn.getVal(); 958 break; 959 case ELF::DT_STRTAB: 960 StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr()); 961 break; 962 case ELF::DT_STRSZ: 963 StringTableSize = Dyn.getVal(); 964 break; 965 case ELF::DT_SYMTAB: 966 DynSymStart = 967 reinterpret_cast<const Elf_Sym *>(toMappedAddr(Dyn.getPtr())); 968 break; 969 } 970 } 971 if (StringTableBegin) 972 DynamicStringTable = StringRef(StringTableBegin, StringTableSize); 973 if (SONameOffset) 974 SOName = getDynamicString(SONameOffset); 975 976 for (const Elf_Shdr &Sec : Obj->sections()) { 977 switch (Sec.sh_type) { 978 case ELF::SHT_GNU_versym: 979 if (dot_gnu_version_sec != nullptr) 980 reportError("Multiple SHT_GNU_versym"); 981 dot_gnu_version_sec = &Sec; 982 break; 983 case ELF::SHT_GNU_verdef: 984 if (dot_gnu_version_d_sec != nullptr) 985 reportError("Multiple SHT_GNU_verdef"); 986 dot_gnu_version_d_sec = &Sec; 987 break; 988 case ELF::SHT_GNU_verneed: 989 if (dot_gnu_version_r_sec != nullptr) 990 reportError("Multilpe SHT_GNU_verneed"); 991 dot_gnu_version_r_sec = &Sec; 992 break; 993 case ELF::SHT_DYNSYM: 994 if (DotDynSymSec != nullptr) 995 reportError("Multilpe SHT_DYNSYM"); 996 DotDynSymSec = &Sec; 997 break; 998 case ELF::SHT_SYMTAB: 999 if (DotSymtabSec != nullptr) 1000 reportError("Multilpe SHT_SYMTAB"); 1001 DotSymtabSec = &Sec; 1002 break; 1003 case ELF::SHT_SYMTAB_SHNDX: { 1004 ErrorOr<ArrayRef<Elf_Word>> TableOrErr = Obj->getSHNDXTable(Sec); 1005 error(TableOrErr.getError()); 1006 ShndxTable = *TableOrErr; 1007 break; 1008 } 1009 } 1010 } 1011} 1012 1013template <typename ELFT> 1014const typename ELFDumper<ELFT>::Elf_Rela * 1015ELFDumper<ELFT>::dyn_rela_begin() const { 1016 if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela)) 1017 report_fatal_error("Invalid relocation entry size"); 1018 return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr); 1019} 1020 1021template <typename ELFT> 1022const typename ELFDumper<ELFT>::Elf_Rela * 1023ELFDumper<ELFT>::dyn_rela_end() const { 1024 uint64_t Size = DynRelaRegion.Size; 1025 if (Size % sizeof(Elf_Rela)) 1026 report_fatal_error("Invalid relocation table size"); 1027 return dyn_rela_begin() + Size / sizeof(Elf_Rela); 1028} 1029 1030template <typename ELFT> 1031typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const { 1032 return make_range(dyn_rela_begin(), dyn_rela_end()); 1033} 1034 1035template<class ELFT> 1036void ELFDumper<ELFT>::printFileHeaders() { 1037 const Elf_Ehdr *Header = Obj->getHeader(); 1038 1039 { 1040 DictScope D(W, "ElfHeader"); 1041 { 1042 DictScope D(W, "Ident"); 1043 W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0, 1044 4)); 1045 W.printEnum ("Class", Header->e_ident[ELF::EI_CLASS], 1046 makeArrayRef(ElfClass)); 1047 W.printEnum ("DataEncoding", Header->e_ident[ELF::EI_DATA], 1048 makeArrayRef(ElfDataEncoding)); 1049 W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]); 1050 1051 // Handle architecture specific OS/ABI values. 1052 if (Header->e_machine == ELF::EM_AMDGPU && 1053 Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA) 1054 W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA); 1055 else 1056 W.printEnum ("OS/ABI", Header->e_ident[ELF::EI_OSABI], 1057 makeArrayRef(ElfOSABI)); 1058 W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]); 1059 W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD)); 1060 } 1061 1062 W.printEnum ("Type", Header->e_type, makeArrayRef(ElfObjectFileType)); 1063 W.printEnum ("Machine", Header->e_machine, makeArrayRef(ElfMachineType)); 1064 W.printNumber("Version", Header->e_version); 1065 W.printHex ("Entry", Header->e_entry); 1066 W.printHex ("ProgramHeaderOffset", Header->e_phoff); 1067 W.printHex ("SectionHeaderOffset", Header->e_shoff); 1068 if (Header->e_machine == EM_MIPS) 1069 W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags), 1070 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), 1071 unsigned(ELF::EF_MIPS_MACH)); 1072 else 1073 W.printFlags("Flags", Header->e_flags); 1074 W.printNumber("HeaderSize", Header->e_ehsize); 1075 W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize); 1076 W.printNumber("ProgramHeaderCount", Header->e_phnum); 1077 W.printNumber("SectionHeaderEntrySize", Header->e_shentsize); 1078 W.printNumber("SectionHeaderCount", Header->e_shnum); 1079 W.printNumber("StringTableSectionIndex", Header->e_shstrndx); 1080 } 1081} 1082 1083template<class ELFT> 1084void ELFDumper<ELFT>::printSections() { 1085 ListScope SectionsD(W, "Sections"); 1086 1087 int SectionIndex = -1; 1088 for (const Elf_Shdr &Sec : Obj->sections()) { 1089 ++SectionIndex; 1090 1091 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec)); 1092 1093 DictScope SectionD(W, "Section"); 1094 W.printNumber("Index", SectionIndex); 1095 W.printNumber("Name", Name, Sec.sh_name); 1096 W.printHex("Type", 1097 getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type), 1098 Sec.sh_type); 1099 W.printFlags("Flags", Sec.sh_flags, makeArrayRef(ElfSectionFlags)); 1100 W.printHex("Address", Sec.sh_addr); 1101 W.printHex("Offset", Sec.sh_offset); 1102 W.printNumber("Size", Sec.sh_size); 1103 W.printNumber("Link", Sec.sh_link); 1104 W.printNumber("Info", Sec.sh_info); 1105 W.printNumber("AddressAlignment", Sec.sh_addralign); 1106 W.printNumber("EntrySize", Sec.sh_entsize); 1107 1108 if (opts::SectionRelocations) { 1109 ListScope D(W, "Relocations"); 1110 printRelocations(&Sec); 1111 } 1112 1113 if (opts::SectionSymbols) { 1114 ListScope D(W, "Symbols"); 1115 const Elf_Shdr *Symtab = DotSymtabSec; 1116 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab); 1117 error(StrTableOrErr.getError()); 1118 StringRef StrTable = *StrTableOrErr; 1119 1120 for (const Elf_Sym &Sym : Obj->symbols(Symtab)) { 1121 ErrorOr<const Elf_Shdr *> SymSec = 1122 Obj->getSection(&Sym, Symtab, ShndxTable); 1123 if (!SymSec) 1124 continue; 1125 if (*SymSec == &Sec) 1126 printSymbol(&Sym, Symtab, StrTable, false); 1127 } 1128 } 1129 1130 if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { 1131 ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(&Sec)); 1132 W.printBinaryBlock("SectionData", 1133 StringRef((const char *)Data.data(), Data.size())); 1134 } 1135 } 1136} 1137 1138template<class ELFT> 1139void ELFDumper<ELFT>::printRelocations() { 1140 ListScope D(W, "Relocations"); 1141 1142 int SectionNumber = -1; 1143 for (const Elf_Shdr &Sec : Obj->sections()) { 1144 ++SectionNumber; 1145 1146 if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA) 1147 continue; 1148 1149 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec)); 1150 1151 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; 1152 W.indent(); 1153 1154 printRelocations(&Sec); 1155 1156 W.unindent(); 1157 W.startLine() << "}\n"; 1158 } 1159} 1160 1161template<class ELFT> 1162void ELFDumper<ELFT>::printDynamicRelocations() { 1163 W.startLine() << "Dynamic Relocations {\n"; 1164 W.indent(); 1165 for (const Elf_Rela &Rel : dyn_relas()) { 1166 SmallString<32> RelocName; 1167 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); 1168 StringRef SymbolName; 1169 uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL()); 1170 const Elf_Sym *Sym = DynSymStart + SymIndex; 1171 SymbolName = errorOrDefault(Sym->getName(DynamicStringTable)); 1172 if (opts::ExpandRelocs) { 1173 DictScope Group(W, "Relocation"); 1174 W.printHex("Offset", Rel.r_offset); 1175 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); 1176 W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-"); 1177 W.printHex("Addend", Rel.r_addend); 1178 } 1179 else { 1180 raw_ostream& OS = W.startLine(); 1181 OS << W.hex(Rel.r_offset) << " " << RelocName << " " 1182 << (SymbolName.size() > 0 ? SymbolName : "-") << " " 1183 << W.hex(Rel.r_addend) << "\n"; 1184 } 1185 } 1186 W.unindent(); 1187 W.startLine() << "}\n"; 1188} 1189 1190template <class ELFT> 1191void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) { 1192 ErrorOr<const Elf_Shdr *> SymTabOrErr = Obj->getSection(Sec->sh_link); 1193 error(SymTabOrErr.getError()); 1194 const Elf_Shdr *SymTab = *SymTabOrErr; 1195 1196 switch (Sec->sh_type) { 1197 case ELF::SHT_REL: 1198 for (const Elf_Rel &R : Obj->rels(Sec)) { 1199 Elf_Rela Rela; 1200 Rela.r_offset = R.r_offset; 1201 Rela.r_info = R.r_info; 1202 Rela.r_addend = 0; 1203 printRelocation(Rela, SymTab); 1204 } 1205 break; 1206 case ELF::SHT_RELA: 1207 for (const Elf_Rela &R : Obj->relas(Sec)) 1208 printRelocation(R, SymTab); 1209 break; 1210 } 1211} 1212 1213template <class ELFT> 1214void ELFDumper<ELFT>::printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab) { 1215 SmallString<32> RelocName; 1216 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); 1217 StringRef TargetName; 1218 const Elf_Sym *Sym = Obj->getRelocationSymbol(&Rel, SymTab); 1219 if (Sym && Sym->getType() == ELF::STT_SECTION) { 1220 ErrorOr<const Elf_Shdr *> Sec = Obj->getSection(Sym, SymTab, ShndxTable); 1221 error(Sec.getError()); 1222 ErrorOr<StringRef> SecName = Obj->getSectionName(*Sec); 1223 if (SecName) 1224 TargetName = SecName.get(); 1225 } else if (Sym) { 1226 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*SymTab); 1227 error(StrTableOrErr.getError()); 1228 TargetName = errorOrDefault(Sym->getName(*StrTableOrErr)); 1229 } 1230 1231 if (opts::ExpandRelocs) { 1232 DictScope Group(W, "Relocation"); 1233 W.printHex("Offset", Rel.r_offset); 1234 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); 1235 W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-", 1236 Rel.getSymbol(Obj->isMips64EL())); 1237 W.printHex("Addend", Rel.r_addend); 1238 } else { 1239 raw_ostream& OS = W.startLine(); 1240 OS << W.hex(Rel.r_offset) << " " << RelocName << " " 1241 << (TargetName.size() > 0 ? TargetName : "-") << " " 1242 << W.hex(Rel.r_addend) << "\n"; 1243 } 1244} 1245 1246template<class ELFT> 1247void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) { 1248 const Elf_Shdr *Symtab = (IsDynamic) ? DotDynSymSec : DotSymtabSec; 1249 if (!Symtab) 1250 return; 1251 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab); 1252 error(StrTableOrErr.getError()); 1253 StringRef StrTable = *StrTableOrErr; 1254 for (const Elf_Sym &Sym : Obj->symbols(Symtab)) 1255 printSymbol(&Sym, Symtab, StrTable, IsDynamic); 1256} 1257 1258template<class ELFT> 1259void ELFDumper<ELFT>::printSymbols() { 1260 ListScope Group(W, "Symbols"); 1261 printSymbolsHelper(false); 1262} 1263 1264template<class ELFT> 1265void ELFDumper<ELFT>::printDynamicSymbols() { 1266 ListScope Group(W, "DynamicSymbols"); 1267 printSymbolsHelper(true); 1268} 1269 1270template <class ELFT> 1271void ELFDumper<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Shdr *SymTab, 1272 StringRef StrTable, bool IsDynamic) { 1273 unsigned SectionIndex = 0; 1274 StringRef SectionName; 1275 getSectionNameIndex(*Obj, Symbol, SymTab, ShndxTable, SectionName, 1276 SectionIndex); 1277 std::string FullSymbolName = getFullSymbolName(Symbol, StrTable, IsDynamic); 1278 unsigned char SymbolType = Symbol->getType(); 1279 1280 DictScope D(W, "Symbol"); 1281 W.printNumber("Name", FullSymbolName, Symbol->st_name); 1282 W.printHex ("Value", Symbol->st_value); 1283 W.printNumber("Size", Symbol->st_size); 1284 W.printEnum ("Binding", Symbol->getBinding(), 1285 makeArrayRef(ElfSymbolBindings)); 1286 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && 1287 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) 1288 W.printEnum ("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); 1289 else 1290 W.printEnum ("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); 1291 W.printNumber("Other", Symbol->st_other); 1292 W.printHex("Section", SectionName, SectionIndex); 1293} 1294 1295#define LLVM_READOBJ_TYPE_CASE(name) \ 1296 case DT_##name: return #name 1297 1298static const char *getTypeString(uint64_t Type) { 1299 switch (Type) { 1300 LLVM_READOBJ_TYPE_CASE(BIND_NOW); 1301 LLVM_READOBJ_TYPE_CASE(DEBUG); 1302 LLVM_READOBJ_TYPE_CASE(FINI); 1303 LLVM_READOBJ_TYPE_CASE(FINI_ARRAY); 1304 LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ); 1305 LLVM_READOBJ_TYPE_CASE(FLAGS); 1306 LLVM_READOBJ_TYPE_CASE(FLAGS_1); 1307 LLVM_READOBJ_TYPE_CASE(HASH); 1308 LLVM_READOBJ_TYPE_CASE(INIT); 1309 LLVM_READOBJ_TYPE_CASE(INIT_ARRAY); 1310 LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ); 1311 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY); 1312 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ); 1313 LLVM_READOBJ_TYPE_CASE(JMPREL); 1314 LLVM_READOBJ_TYPE_CASE(NEEDED); 1315 LLVM_READOBJ_TYPE_CASE(NULL); 1316 LLVM_READOBJ_TYPE_CASE(PLTGOT); 1317 LLVM_READOBJ_TYPE_CASE(PLTREL); 1318 LLVM_READOBJ_TYPE_CASE(PLTRELSZ); 1319 LLVM_READOBJ_TYPE_CASE(REL); 1320 LLVM_READOBJ_TYPE_CASE(RELA); 1321 LLVM_READOBJ_TYPE_CASE(RELENT); 1322 LLVM_READOBJ_TYPE_CASE(RELSZ); 1323 LLVM_READOBJ_TYPE_CASE(RELAENT); 1324 LLVM_READOBJ_TYPE_CASE(RELASZ); 1325 LLVM_READOBJ_TYPE_CASE(RPATH); 1326 LLVM_READOBJ_TYPE_CASE(RUNPATH); 1327 LLVM_READOBJ_TYPE_CASE(SONAME); 1328 LLVM_READOBJ_TYPE_CASE(STRSZ); 1329 LLVM_READOBJ_TYPE_CASE(STRTAB); 1330 LLVM_READOBJ_TYPE_CASE(SYMBOLIC); 1331 LLVM_READOBJ_TYPE_CASE(SYMENT); 1332 LLVM_READOBJ_TYPE_CASE(SYMTAB); 1333 LLVM_READOBJ_TYPE_CASE(TEXTREL); 1334 LLVM_READOBJ_TYPE_CASE(VERDEF); 1335 LLVM_READOBJ_TYPE_CASE(VERDEFNUM); 1336 LLVM_READOBJ_TYPE_CASE(VERNEED); 1337 LLVM_READOBJ_TYPE_CASE(VERNEEDNUM); 1338 LLVM_READOBJ_TYPE_CASE(VERSYM); 1339 LLVM_READOBJ_TYPE_CASE(RELCOUNT); 1340 LLVM_READOBJ_TYPE_CASE(GNU_HASH); 1341 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION); 1342 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP_REL); 1343 LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS); 1344 LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS); 1345 LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO); 1346 LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO); 1347 LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO); 1348 LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM); 1349 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP); 1350 LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT); 1351 LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS); 1352 default: return "unknown"; 1353 } 1354} 1355 1356#undef LLVM_READOBJ_TYPE_CASE 1357 1358#define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ 1359 { #enum, prefix##_##enum } 1360 1361static const EnumEntry<unsigned> ElfDynamicDTFlags[] = { 1362 LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), 1363 LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), 1364 LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), 1365 LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), 1366 LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) 1367}; 1368 1369static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = { 1370 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), 1371 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), 1372 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), 1373 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), 1374 LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), 1375 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), 1376 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), 1377 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), 1378 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), 1379 LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), 1380 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), 1381 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), 1382 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), 1383 LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), 1384 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), 1385 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), 1386 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), 1387 LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), 1388 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), 1389 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), 1390 LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), 1391 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), 1392 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), 1393 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), 1394 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON) 1395}; 1396 1397static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = { 1398 LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), 1399 LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), 1400 LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), 1401 LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), 1402 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), 1403 LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), 1404 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), 1405 LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), 1406 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), 1407 LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), 1408 LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), 1409 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), 1410 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), 1411 LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), 1412 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), 1413 LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) 1414}; 1415 1416#undef LLVM_READOBJ_DT_FLAG_ENT 1417 1418template <typename T, typename TFlag> 1419void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) { 1420 typedef EnumEntry<TFlag> FlagEntry; 1421 typedef SmallVector<FlagEntry, 10> FlagVector; 1422 FlagVector SetFlags; 1423 1424 for (const auto &Flag : Flags) { 1425 if (Flag.Value == 0) 1426 continue; 1427 1428 if ((Value & Flag.Value) == Flag.Value) 1429 SetFlags.push_back(Flag); 1430 } 1431 1432 for (const auto &Flag : SetFlags) { 1433 OS << Flag.Name << " "; 1434 } 1435} 1436 1437template <class ELFT> 1438StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { 1439 if (Value >= DynamicStringTable.size()) 1440 reportError("Invalid dynamic string table reference"); 1441 return StringRef(DynamicStringTable.data() + Value); 1442} 1443 1444template <class ELFT> 1445void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) { 1446 raw_ostream &OS = W.getOStream(); 1447 switch (Type) { 1448 case DT_PLTREL: 1449 if (Value == DT_REL) { 1450 OS << "REL"; 1451 break; 1452 } else if (Value == DT_RELA) { 1453 OS << "RELA"; 1454 break; 1455 } 1456 // Fallthrough. 1457 case DT_PLTGOT: 1458 case DT_HASH: 1459 case DT_STRTAB: 1460 case DT_SYMTAB: 1461 case DT_RELA: 1462 case DT_INIT: 1463 case DT_FINI: 1464 case DT_REL: 1465 case DT_JMPREL: 1466 case DT_INIT_ARRAY: 1467 case DT_FINI_ARRAY: 1468 case DT_PREINIT_ARRAY: 1469 case DT_DEBUG: 1470 case DT_VERDEF: 1471 case DT_VERNEED: 1472 case DT_VERSYM: 1473 case DT_GNU_HASH: 1474 case DT_NULL: 1475 case DT_MIPS_BASE_ADDRESS: 1476 case DT_MIPS_GOTSYM: 1477 case DT_MIPS_RLD_MAP: 1478 case DT_MIPS_RLD_MAP_REL: 1479 case DT_MIPS_PLTGOT: 1480 case DT_MIPS_OPTIONS: 1481 OS << format("0x%" PRIX64, Value); 1482 break; 1483 case DT_RELCOUNT: 1484 case DT_VERDEFNUM: 1485 case DT_VERNEEDNUM: 1486 case DT_MIPS_RLD_VERSION: 1487 case DT_MIPS_LOCAL_GOTNO: 1488 case DT_MIPS_SYMTABNO: 1489 case DT_MIPS_UNREFEXTNO: 1490 OS << Value; 1491 break; 1492 case DT_PLTRELSZ: 1493 case DT_RELASZ: 1494 case DT_RELAENT: 1495 case DT_STRSZ: 1496 case DT_SYMENT: 1497 case DT_RELSZ: 1498 case DT_RELENT: 1499 case DT_INIT_ARRAYSZ: 1500 case DT_FINI_ARRAYSZ: 1501 case DT_PREINIT_ARRAYSZ: 1502 OS << Value << " (bytes)"; 1503 break; 1504 case DT_NEEDED: 1505 OS << "SharedLibrary (" << getDynamicString(Value) << ")"; 1506 break; 1507 case DT_SONAME: 1508 OS << "LibrarySoname (" << getDynamicString(Value) << ")"; 1509 break; 1510 case DT_RPATH: 1511 case DT_RUNPATH: 1512 OS << getDynamicString(Value); 1513 break; 1514 case DT_MIPS_FLAGS: 1515 printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS); 1516 break; 1517 case DT_FLAGS: 1518 printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS); 1519 break; 1520 case DT_FLAGS_1: 1521 printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS); 1522 break; 1523 default: 1524 OS << format("0x%" PRIX64, Value); 1525 break; 1526 } 1527} 1528 1529template<class ELFT> 1530void ELFDumper<ELFT>::printUnwindInfo() { 1531 W.startLine() << "UnwindInfo not implemented.\n"; 1532} 1533 1534namespace { 1535template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() { 1536 const unsigned Machine = Obj->getHeader()->e_machine; 1537 if (Machine == EM_ARM) { 1538 ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx( 1539 W, Obj, DotSymtabSec); 1540 return Ctx.PrintUnwindInformation(); 1541 } 1542 W.startLine() << "UnwindInfo not implemented.\n"; 1543} 1544} 1545 1546template<class ELFT> 1547void ELFDumper<ELFT>::printDynamicTable() { 1548 auto I = dynamic_table_begin(); 1549 auto E = dynamic_table_end(); 1550 1551 if (I == E) 1552 return; 1553 1554 --E; 1555 while (I != E && E->getTag() == ELF::DT_NULL) 1556 --E; 1557 if (E->getTag() != ELF::DT_NULL) 1558 ++E; 1559 ++E; 1560 1561 ptrdiff_t Total = std::distance(I, E); 1562 if (Total == 0) 1563 return; 1564 1565 raw_ostream &OS = W.getOStream(); 1566 W.startLine() << "DynamicSection [ (" << Total << " entries)\n"; 1567 1568 bool Is64 = ELFT::Is64Bits; 1569 1570 W.startLine() 1571 << " Tag" << (Is64 ? " " : " ") << "Type" 1572 << " " << "Name/Value\n"; 1573 while (I != E) { 1574 const Elf_Dyn &Entry = *I; 1575 uintX_t Tag = Entry.getTag(); 1576 ++I; 1577 W.startLine() << " " << format_hex(Tag, Is64 ? 18 : 10, true) << " " 1578 << format("%-21s", getTypeString(Tag)); 1579 printValue(Tag, Entry.getVal()); 1580 OS << "\n"; 1581 } 1582 1583 W.startLine() << "]\n"; 1584} 1585 1586template<class ELFT> 1587void ELFDumper<ELFT>::printNeededLibraries() { 1588 ListScope D(W, "NeededLibraries"); 1589 1590 typedef std::vector<StringRef> LibsTy; 1591 LibsTy Libs; 1592 1593 for (const auto &Entry : dynamic_table()) 1594 if (Entry.d_tag == ELF::DT_NEEDED) 1595 Libs.push_back(getDynamicString(Entry.d_un.d_val)); 1596 1597 std::stable_sort(Libs.begin(), Libs.end()); 1598 1599 for (const auto &L : Libs) { 1600 outs() << " " << L << "\n"; 1601 } 1602} 1603 1604template<class ELFT> 1605void ELFDumper<ELFT>::printProgramHeaders() { 1606 ListScope L(W, "ProgramHeaders"); 1607 1608 for (const Elf_Phdr &Phdr : Obj->program_headers()) { 1609 DictScope P(W, "ProgramHeader"); 1610 W.printHex("Type", 1611 getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type), 1612 Phdr.p_type); 1613 W.printHex("Offset", Phdr.p_offset); 1614 W.printHex("VirtualAddress", Phdr.p_vaddr); 1615 W.printHex("PhysicalAddress", Phdr.p_paddr); 1616 W.printNumber("FileSize", Phdr.p_filesz); 1617 W.printNumber("MemSize", Phdr.p_memsz); 1618 W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); 1619 W.printNumber("Alignment", Phdr.p_align); 1620 } 1621} 1622 1623template <typename ELFT> 1624void ELFDumper<ELFT>::printHashTable() { 1625 DictScope D(W, "HashTable"); 1626 if (!HashTable) 1627 return; 1628 W.printNumber("Num Buckets", HashTable->nbucket); 1629 W.printNumber("Num Chains", HashTable->nchain); 1630 W.printList("Buckets", HashTable->buckets()); 1631 W.printList("Chains", HashTable->chains()); 1632} 1633 1634template <typename ELFT> 1635void ELFDumper<ELFT>::printGnuHashTable() { 1636 DictScope D(W, "GnuHashTable"); 1637 if (!GnuHashTable) 1638 return; 1639 W.printNumber("Num Buckets", GnuHashTable->nbuckets); 1640 W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); 1641 W.printNumber("Num Mask Words", GnuHashTable->maskwords); 1642 W.printNumber("Shift Count", GnuHashTable->shift2); 1643 W.printHexList("Bloom Filter", GnuHashTable->filter()); 1644 W.printList("Buckets", GnuHashTable->buckets()); 1645 if (!DotDynSymSec) 1646 reportError("No dynamic symbol section"); 1647 W.printHexList("Values", 1648 GnuHashTable->values(DotDynSymSec->getEntityCount())); 1649} 1650 1651template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { 1652 outs() << "LoadName: " << SOName << '\n'; 1653} 1654 1655template <class ELFT> 1656void ELFDumper<ELFT>::printAttributes() { 1657 W.startLine() << "Attributes not implemented.\n"; 1658} 1659 1660namespace { 1661template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() { 1662 if (Obj->getHeader()->e_machine != EM_ARM) { 1663 W.startLine() << "Attributes not implemented.\n"; 1664 return; 1665 } 1666 1667 DictScope BA(W, "BuildAttributes"); 1668 for (const ELFO::Elf_Shdr &Sec : Obj->sections()) { 1669 if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES) 1670 continue; 1671 1672 ErrorOr<ArrayRef<uint8_t>> Contents = Obj->getSectionContents(&Sec); 1673 if (!Contents) 1674 continue; 1675 1676 if ((*Contents)[0] != ARMBuildAttrs::Format_Version) { 1677 errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0]) 1678 << '\n'; 1679 continue; 1680 } 1681 1682 W.printHex("FormatVersion", (*Contents)[0]); 1683 if (Contents->size() == 1) 1684 continue; 1685 1686 ARMAttributeParser(W).Parse(*Contents); 1687 } 1688} 1689} 1690 1691namespace { 1692template <class ELFT> class MipsGOTParser { 1693public: 1694 typedef object::ELFFile<ELFT> ELFO; 1695 typedef typename ELFO::Elf_Shdr Elf_Shdr; 1696 typedef typename ELFO::Elf_Sym Elf_Sym; 1697 typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range; 1698 typedef typename ELFO::Elf_Addr GOTEntry; 1699 typedef typename ELFO::Elf_Rel Elf_Rel; 1700 typedef typename ELFO::Elf_Rela Elf_Rela; 1701 1702 MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj, 1703 Elf_Dyn_Range DynTable, StreamWriter &W); 1704 1705 void parseGOT(); 1706 void parsePLT(); 1707 1708private: 1709 ELFDumper<ELFT> *Dumper; 1710 const ELFO *Obj; 1711 StreamWriter &W; 1712 llvm::Optional<uint64_t> DtPltGot; 1713 llvm::Optional<uint64_t> DtLocalGotNum; 1714 llvm::Optional<uint64_t> DtGotSym; 1715 llvm::Optional<uint64_t> DtMipsPltGot; 1716 llvm::Optional<uint64_t> DtJmpRel; 1717 1718 std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const; 1719 const GOTEntry *makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum); 1720 1721 void printGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt, 1722 const GOTEntry *It); 1723 void printGlobalGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt, 1724 const GOTEntry *It, const Elf_Sym *Sym, 1725 StringRef StrTable, bool IsDynamic); 1726 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt, 1727 const GOTEntry *It, StringRef Purpose); 1728 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt, 1729 const GOTEntry *It, StringRef StrTable, 1730 const Elf_Sym *Sym); 1731}; 1732} 1733 1734template <class ELFT> 1735MipsGOTParser<ELFT>::MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj, 1736 Elf_Dyn_Range DynTable, StreamWriter &W) 1737 : Dumper(Dumper), Obj(Obj), W(W) { 1738 for (const auto &Entry : DynTable) { 1739 switch (Entry.getTag()) { 1740 case ELF::DT_PLTGOT: 1741 DtPltGot = Entry.getVal(); 1742 break; 1743 case ELF::DT_MIPS_LOCAL_GOTNO: 1744 DtLocalGotNum = Entry.getVal(); 1745 break; 1746 case ELF::DT_MIPS_GOTSYM: 1747 DtGotSym = Entry.getVal(); 1748 break; 1749 case ELF::DT_MIPS_PLTGOT: 1750 DtMipsPltGot = Entry.getVal(); 1751 break; 1752 case ELF::DT_JMPREL: 1753 DtJmpRel = Entry.getVal(); 1754 break; 1755 } 1756 } 1757} 1758 1759template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() { 1760 // See "Global Offset Table" in Chapter 5 in the following document 1761 // for detailed GOT description. 1762 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 1763 if (!DtPltGot) { 1764 W.startLine() << "Cannot find PLTGOT dynamic table tag.\n"; 1765 return; 1766 } 1767 if (!DtLocalGotNum) { 1768 W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n"; 1769 return; 1770 } 1771 if (!DtGotSym) { 1772 W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n"; 1773 return; 1774 } 1775 1776 const Elf_Shdr *GOTShdr = findSectionByAddress(Obj, *DtPltGot); 1777 if (!GOTShdr) { 1778 W.startLine() << "There is no .got section in the file.\n"; 1779 return; 1780 } 1781 1782 ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(GOTShdr); 1783 if (!GOT) { 1784 W.startLine() << "The .got section is empty.\n"; 1785 return; 1786 } 1787 1788 if (*DtLocalGotNum > getGOTTotal(*GOT)) { 1789 W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n"; 1790 return; 1791 } 1792 1793 const Elf_Shdr *DynSymSec = Dumper->getDotDynSymSec(); 1794 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*DynSymSec); 1795 error(StrTable.getError()); 1796 const Elf_Sym *DynSymBegin = Obj->symbol_begin(DynSymSec); 1797 const Elf_Sym *DynSymEnd = Obj->symbol_end(DynSymSec); 1798 std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd)); 1799 1800 if (*DtGotSym > DynSymTotal) { 1801 W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n"; 1802 return; 1803 } 1804 1805 std::size_t GlobalGotNum = DynSymTotal - *DtGotSym; 1806 1807 if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) { 1808 W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n"; 1809 return; 1810 } 1811 1812 const GOTEntry *GotBegin = makeGOTIter(*GOT, 0); 1813 const GOTEntry *GotLocalEnd = makeGOTIter(*GOT, *DtLocalGotNum); 1814 const GOTEntry *It = GotBegin; 1815 1816 DictScope GS(W, "Primary GOT"); 1817 1818 W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0); 1819 { 1820 ListScope RS(W, "Reserved entries"); 1821 1822 { 1823 DictScope D(W, "Entry"); 1824 printGotEntry(GOTShdr->sh_addr, GotBegin, It++); 1825 W.printString("Purpose", StringRef("Lazy resolver")); 1826 } 1827 1828 if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) { 1829 DictScope D(W, "Entry"); 1830 printGotEntry(GOTShdr->sh_addr, GotBegin, It++); 1831 W.printString("Purpose", StringRef("Module pointer (GNU extension)")); 1832 } 1833 } 1834 { 1835 ListScope LS(W, "Local entries"); 1836 for (; It != GotLocalEnd; ++It) { 1837 DictScope D(W, "Entry"); 1838 printGotEntry(GOTShdr->sh_addr, GotBegin, It); 1839 } 1840 } 1841 { 1842 ListScope GS(W, "Global entries"); 1843 1844 const GOTEntry *GotGlobalEnd = 1845 makeGOTIter(*GOT, *DtLocalGotNum + GlobalGotNum); 1846 const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym; 1847 for (; It != GotGlobalEnd; ++It) { 1848 DictScope D(W, "Entry"); 1849 printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, 1850 *StrTable, true); 1851 } 1852 } 1853 1854 std::size_t SpecGotNum = getGOTTotal(*GOT) - *DtLocalGotNum - GlobalGotNum; 1855 W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum)); 1856} 1857 1858template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() { 1859 if (!DtMipsPltGot) { 1860 W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n"; 1861 return; 1862 } 1863 if (!DtJmpRel) { 1864 W.startLine() << "Cannot find JMPREL dynamic table tag.\n"; 1865 return; 1866 } 1867 1868 const Elf_Shdr *PLTShdr = findSectionByAddress(Obj, *DtMipsPltGot); 1869 if (!PLTShdr) { 1870 W.startLine() << "There is no .got.plt section in the file.\n"; 1871 return; 1872 } 1873 ErrorOr<ArrayRef<uint8_t>> PLT = Obj->getSectionContents(PLTShdr); 1874 if (!PLT) { 1875 W.startLine() << "The .got.plt section is empty.\n"; 1876 return; 1877 } 1878 1879 const Elf_Shdr *PLTRelShdr = findSectionByAddress(Obj, *DtJmpRel); 1880 if (!PLTShdr) { 1881 W.startLine() << "There is no .rel.plt section in the file.\n"; 1882 return; 1883 } 1884 ErrorOr<const Elf_Shdr *> SymTableOrErr = 1885 Obj->getSection(PLTRelShdr->sh_link); 1886 error(SymTableOrErr.getError()); 1887 const Elf_Shdr *SymTable = *SymTableOrErr; 1888 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*SymTable); 1889 error(StrTable.getError()); 1890 1891 const GOTEntry *PLTBegin = makeGOTIter(*PLT, 0); 1892 const GOTEntry *PLTEnd = makeGOTIter(*PLT, getGOTTotal(*PLT)); 1893 const GOTEntry *It = PLTBegin; 1894 1895 DictScope GS(W, "PLT GOT"); 1896 { 1897 ListScope RS(W, "Reserved entries"); 1898 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver"); 1899 if (It != PLTEnd) 1900 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer"); 1901 } 1902 { 1903 ListScope GS(W, "Entries"); 1904 1905 switch (PLTRelShdr->sh_type) { 1906 case ELF::SHT_REL: 1907 for (const Elf_Rel *RI = Obj->rel_begin(PLTRelShdr), 1908 *RE = Obj->rel_end(PLTRelShdr); 1909 RI != RE && It != PLTEnd; ++RI, ++It) { 1910 const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable); 1911 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym); 1912 } 1913 break; 1914 case ELF::SHT_RELA: 1915 for (const Elf_Rela *RI = Obj->rela_begin(PLTRelShdr), 1916 *RE = Obj->rela_end(PLTRelShdr); 1917 RI != RE && It != PLTEnd; ++RI, ++It) { 1918 const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable); 1919 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym); 1920 } 1921 break; 1922 } 1923 } 1924} 1925 1926template <class ELFT> 1927std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const { 1928 return GOT.size() / sizeof(GOTEntry); 1929} 1930 1931template <class ELFT> 1932const typename MipsGOTParser<ELFT>::GOTEntry * 1933MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) { 1934 const char *Data = reinterpret_cast<const char *>(GOT.data()); 1935 return reinterpret_cast<const GOTEntry *>(Data + EntryNum * sizeof(GOTEntry)); 1936} 1937 1938template <class ELFT> 1939void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr, 1940 const GOTEntry *BeginIt, 1941 const GOTEntry *It) { 1942 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry); 1943 W.printHex("Address", GotAddr + Offset); 1944 W.printNumber("Access", Offset - 0x7ff0); 1945 W.printHex("Initial", *It); 1946} 1947 1948template <class ELFT> 1949void MipsGOTParser<ELFT>::printGlobalGotEntry( 1950 uint64_t GotAddr, const GOTEntry *BeginIt, const GOTEntry *It, 1951 const Elf_Sym *Sym, StringRef StrTable, bool IsDynamic) { 1952 printGotEntry(GotAddr, BeginIt, It); 1953 1954 W.printHex("Value", Sym->st_value); 1955 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); 1956 1957 unsigned SectionIndex = 0; 1958 StringRef SectionName; 1959 getSectionNameIndex(*Obj, Sym, Dumper->getDotDynSymSec(), 1960 Dumper->getShndxTable(), SectionName, SectionIndex); 1961 W.printHex("Section", SectionName, SectionIndex); 1962 1963 std::string FullSymbolName = 1964 Dumper->getFullSymbolName(Sym, StrTable, IsDynamic); 1965 W.printNumber("Name", FullSymbolName, Sym->st_name); 1966} 1967 1968template <class ELFT> 1969void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr, 1970 const GOTEntry *BeginIt, 1971 const GOTEntry *It, StringRef Purpose) { 1972 DictScope D(W, "Entry"); 1973 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry); 1974 W.printHex("Address", PLTAddr + Offset); 1975 W.printHex("Initial", *It); 1976 W.printString("Purpose", Purpose); 1977} 1978 1979template <class ELFT> 1980void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr, 1981 const GOTEntry *BeginIt, 1982 const GOTEntry *It, StringRef StrTable, 1983 const Elf_Sym *Sym) { 1984 DictScope D(W, "Entry"); 1985 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry); 1986 W.printHex("Address", PLTAddr + Offset); 1987 W.printHex("Initial", *It); 1988 W.printHex("Value", Sym->st_value); 1989 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); 1990 1991 unsigned SectionIndex = 0; 1992 StringRef SectionName; 1993 getSectionNameIndex(*Obj, Sym, Dumper->getDotDynSymSec(), 1994 Dumper->getShndxTable(), SectionName, SectionIndex); 1995 W.printHex("Section", SectionName, SectionIndex); 1996 1997 std::string FullSymbolName = Dumper->getFullSymbolName(Sym, StrTable, true); 1998 W.printNumber("Name", FullSymbolName, Sym->st_name); 1999} 2000 2001template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() { 2002 if (Obj->getHeader()->e_machine != EM_MIPS) { 2003 W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n"; 2004 return; 2005 } 2006 2007 MipsGOTParser<ELFT> GOTParser(this, Obj, dynamic_table(), W); 2008 GOTParser.parseGOT(); 2009 GOTParser.parsePLT(); 2010} 2011 2012static const EnumEntry<unsigned> ElfMipsISAExtType[] = { 2013 {"None", Mips::AFL_EXT_NONE}, 2014 {"Broadcom SB-1", Mips::AFL_EXT_SB1}, 2015 {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, 2016 {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, 2017 {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, 2018 {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, 2019 {"LSI R4010", Mips::AFL_EXT_4010}, 2020 {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, 2021 {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, 2022 {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, 2023 {"MIPS R4650", Mips::AFL_EXT_4650}, 2024 {"MIPS R5900", Mips::AFL_EXT_5900}, 2025 {"MIPS R10000", Mips::AFL_EXT_10000}, 2026 {"NEC VR4100", Mips::AFL_EXT_4100}, 2027 {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, 2028 {"NEC VR4120", Mips::AFL_EXT_4120}, 2029 {"NEC VR5400", Mips::AFL_EXT_5400}, 2030 {"NEC VR5500", Mips::AFL_EXT_5500}, 2031 {"RMI Xlr", Mips::AFL_EXT_XLR}, 2032 {"Toshiba R3900", Mips::AFL_EXT_3900} 2033}; 2034 2035static const EnumEntry<unsigned> ElfMipsASEFlags[] = { 2036 {"DSP", Mips::AFL_ASE_DSP}, 2037 {"DSPR2", Mips::AFL_ASE_DSPR2}, 2038 {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, 2039 {"MCU", Mips::AFL_ASE_MCU}, 2040 {"MDMX", Mips::AFL_ASE_MDMX}, 2041 {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, 2042 {"MT", Mips::AFL_ASE_MT}, 2043 {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, 2044 {"VZ", Mips::AFL_ASE_VIRT}, 2045 {"MSA", Mips::AFL_ASE_MSA}, 2046 {"MIPS16", Mips::AFL_ASE_MIPS16}, 2047 {"microMIPS", Mips::AFL_ASE_MICROMIPS}, 2048 {"XPA", Mips::AFL_ASE_XPA} 2049}; 2050 2051static const EnumEntry<unsigned> ElfMipsFpABIType[] = { 2052 {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, 2053 {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, 2054 {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, 2055 {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, 2056 {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", 2057 Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, 2058 {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, 2059 {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, 2060 {"Hard float compat (32-bit CPU, 64-bit FPU)", 2061 Mips::Val_GNU_MIPS_ABI_FP_64A} 2062}; 2063 2064static const EnumEntry<unsigned> ElfMipsFlags1[] { 2065 {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, 2066}; 2067 2068static int getMipsRegisterSize(uint8_t Flag) { 2069 switch (Flag) { 2070 case Mips::AFL_REG_NONE: 2071 return 0; 2072 case Mips::AFL_REG_32: 2073 return 32; 2074 case Mips::AFL_REG_64: 2075 return 64; 2076 case Mips::AFL_REG_128: 2077 return 128; 2078 default: 2079 return -1; 2080 } 2081} 2082 2083template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() { 2084 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags"); 2085 if (!Shdr) { 2086 W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; 2087 return; 2088 } 2089 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr); 2090 if (!Sec) { 2091 W.startLine() << "The .MIPS.abiflags section is empty.\n"; 2092 return; 2093 } 2094 if (Sec->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) { 2095 W.startLine() << "The .MIPS.abiflags section has a wrong size.\n"; 2096 return; 2097 } 2098 2099 auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec->data()); 2100 2101 raw_ostream &OS = W.getOStream(); 2102 DictScope GS(W, "MIPS ABI Flags"); 2103 2104 W.printNumber("Version", Flags->version); 2105 W.startLine() << "ISA: "; 2106 if (Flags->isa_rev <= 1) 2107 OS << format("MIPS%u", Flags->isa_level); 2108 else 2109 OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); 2110 OS << "\n"; 2111 W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)); 2112 W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags)); 2113 W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)); 2114 W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); 2115 W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); 2116 W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); 2117 W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1)); 2118 W.printHex("Flags 2", Flags->flags2); 2119} 2120 2121template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { 2122 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo"); 2123 if (!Shdr) { 2124 W.startLine() << "There is no .reginfo section in the file.\n"; 2125 return; 2126 } 2127 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr); 2128 if (!Sec) { 2129 W.startLine() << "The .reginfo section is empty.\n"; 2130 return; 2131 } 2132 if (Sec->size() != sizeof(Elf_Mips_RegInfo<ELFT>)) { 2133 W.startLine() << "The .reginfo section has a wrong size.\n"; 2134 return; 2135 } 2136 2137 auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec->data()); 2138 2139 DictScope GS(W, "MIPS RegInfo"); 2140 W.printHex("GP", Reginfo->ri_gp_value); 2141 W.printHex("General Mask", Reginfo->ri_gprmask); 2142 W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]); 2143 W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]); 2144 W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]); 2145 W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]); 2146} 2147 2148template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { 2149 const Elf_Shdr *StackMapSection = nullptr; 2150 for (const auto &Sec : Obj->sections()) { 2151 ErrorOr<StringRef> Name = Obj->getSectionName(&Sec); 2152 if (*Name == ".llvm_stackmaps") { 2153 StackMapSection = &Sec; 2154 break; 2155 } 2156 } 2157 2158 if (!StackMapSection) 2159 return; 2160 2161 StringRef StackMapContents; 2162 ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray = 2163 Obj->getSectionContents(StackMapSection); 2164 2165 prettyPrintStackMap( 2166 llvm::outs(), 2167 StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray)); 2168} 2169