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