1 //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// This file implements the ELF-specific dumper for llvm-readobj. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "ARMEHABIPrinter.h" 15 #include "DwarfCFIEHPrinter.h" 16 #include "Error.h" 17 #include "ObjDumper.h" 18 #include "StackMapPrinter.h" 19 #include "llvm-readobj.h" 20 #include "llvm/ADT/ArrayRef.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/ADT/DenseSet.h" 23 #include "llvm/ADT/MapVector.h" 24 #include "llvm/ADT/Optional.h" 25 #include "llvm/ADT/PointerIntPair.h" 26 #include "llvm/ADT/STLExtras.h" 27 #include "llvm/ADT/SmallString.h" 28 #include "llvm/ADT/SmallVector.h" 29 #include "llvm/ADT/StringExtras.h" 30 #include "llvm/ADT/StringRef.h" 31 #include "llvm/ADT/Twine.h" 32 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h" 33 #include "llvm/BinaryFormat/ELF.h" 34 #include "llvm/Demangle/Demangle.h" 35 #include "llvm/Object/ELF.h" 36 #include "llvm/Object/ELFObjectFile.h" 37 #include "llvm/Object/ELFTypes.h" 38 #include "llvm/Object/Error.h" 39 #include "llvm/Object/ObjectFile.h" 40 #include "llvm/Object/RelocationResolver.h" 41 #include "llvm/Object/StackMapParser.h" 42 #include "llvm/Support/AMDGPUMetadata.h" 43 #include "llvm/Support/ARMAttributeParser.h" 44 #include "llvm/Support/ARMBuildAttributes.h" 45 #include "llvm/Support/Casting.h" 46 #include "llvm/Support/Compiler.h" 47 #include "llvm/Support/Endian.h" 48 #include "llvm/Support/ErrorHandling.h" 49 #include "llvm/Support/Format.h" 50 #include "llvm/Support/FormatVariadic.h" 51 #include "llvm/Support/FormattedStream.h" 52 #include "llvm/Support/LEB128.h" 53 #include "llvm/Support/MathExtras.h" 54 #include "llvm/Support/MipsABIFlags.h" 55 #include "llvm/Support/RISCVAttributeParser.h" 56 #include "llvm/Support/RISCVAttributes.h" 57 #include "llvm/Support/ScopedPrinter.h" 58 #include "llvm/Support/raw_ostream.h" 59 #include <algorithm> 60 #include <cinttypes> 61 #include <cstddef> 62 #include <cstdint> 63 #include <cstdlib> 64 #include <iterator> 65 #include <memory> 66 #include <string> 67 #include <system_error> 68 #include <unordered_set> 69 #include <vector> 70 71 using namespace llvm; 72 using namespace llvm::object; 73 using namespace ELF; 74 75 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \ 76 case ns::enum: \ 77 return #enum; 78 79 #define ENUM_ENT(enum, altName) \ 80 { #enum, altName, ELF::enum } 81 82 #define ENUM_ENT_1(enum) \ 83 { #enum, #enum, ELF::enum } 84 85 #define LLVM_READOBJ_PHDR_ENUM(ns, enum) \ 86 case ns::enum: \ 87 return std::string(#enum).substr(3); 88 89 #define TYPEDEF_ELF_TYPES(ELFT) \ 90 using ELFO = ELFFile<ELFT>; \ 91 using Elf_Addr = typename ELFT::Addr; \ 92 using Elf_Shdr = typename ELFT::Shdr; \ 93 using Elf_Sym = typename ELFT::Sym; \ 94 using Elf_Dyn = typename ELFT::Dyn; \ 95 using Elf_Dyn_Range = typename ELFT::DynRange; \ 96 using Elf_Rel = typename ELFT::Rel; \ 97 using Elf_Rela = typename ELFT::Rela; \ 98 using Elf_Relr = typename ELFT::Relr; \ 99 using Elf_Rel_Range = typename ELFT::RelRange; \ 100 using Elf_Rela_Range = typename ELFT::RelaRange; \ 101 using Elf_Relr_Range = typename ELFT::RelrRange; \ 102 using Elf_Phdr = typename ELFT::Phdr; \ 103 using Elf_Half = typename ELFT::Half; \ 104 using Elf_Ehdr = typename ELFT::Ehdr; \ 105 using Elf_Word = typename ELFT::Word; \ 106 using Elf_Hash = typename ELFT::Hash; \ 107 using Elf_GnuHash = typename ELFT::GnuHash; \ 108 using Elf_Note = typename ELFT::Note; \ 109 using Elf_Sym_Range = typename ELFT::SymRange; \ 110 using Elf_Versym = typename ELFT::Versym; \ 111 using Elf_Verneed = typename ELFT::Verneed; \ 112 using Elf_Vernaux = typename ELFT::Vernaux; \ 113 using Elf_Verdef = typename ELFT::Verdef; \ 114 using Elf_Verdaux = typename ELFT::Verdaux; \ 115 using Elf_CGProfile = typename ELFT::CGProfile; \ 116 using uintX_t = typename ELFT::uint; 117 118 namespace { 119 120 template <class ELFT> class DumpStyle; 121 122 /// Represents a contiguous uniform range in the file. We cannot just create a 123 /// range directly because when creating one of these from the .dynamic table 124 /// the size, entity size and virtual address are different entries in arbitrary 125 /// order (DT_REL, DT_RELSZ, DT_RELENT for example). 126 struct DynRegionInfo { 127 DynRegionInfo(StringRef ObjName) : FileName(ObjName) {} 128 DynRegionInfo(const void *A, uint64_t S, uint64_t ES, StringRef ObjName) 129 : Addr(A), Size(S), EntSize(ES), FileName(ObjName) {} 130 131 /// Address in current address space. 132 const void *Addr = nullptr; 133 /// Size in bytes of the region. 134 uint64_t Size = 0; 135 /// Size of each entity in the region. 136 uint64_t EntSize = 0; 137 138 /// Name of the file. Used for error reporting. 139 StringRef FileName; 140 /// Error prefix. Used for error reporting to provide more information. 141 std::string Context; 142 /// Region size name. Used for error reporting. 143 StringRef SizePrintName = "size"; 144 /// Entry size name. Used for error reporting. If this field is empty, errors 145 /// will not mention the entry size. 146 StringRef EntSizePrintName = "entry size"; 147 148 template <typename Type> ArrayRef<Type> getAsArrayRef() const { 149 const Type *Start = reinterpret_cast<const Type *>(Addr); 150 if (!Start) 151 return {Start, Start}; 152 if (EntSize == sizeof(Type) && (Size % EntSize == 0)) 153 return {Start, Start + (Size / EntSize)}; 154 155 std::string Msg; 156 if (!Context.empty()) 157 Msg += Context + " has "; 158 159 Msg += ("invalid " + SizePrintName + " (0x" + Twine::utohexstr(Size) + ")") 160 .str(); 161 if (!EntSizePrintName.empty()) 162 Msg += 163 (" or " + EntSizePrintName + " (0x" + Twine::utohexstr(EntSize) + ")") 164 .str(); 165 166 reportWarning(createError(Msg.c_str()), FileName); 167 return {Start, Start}; 168 } 169 }; 170 171 namespace { 172 struct VerdAux { 173 unsigned Offset; 174 std::string Name; 175 }; 176 177 struct VerDef { 178 unsigned Offset; 179 unsigned Version; 180 unsigned Flags; 181 unsigned Ndx; 182 unsigned Cnt; 183 unsigned Hash; 184 std::string Name; 185 std::vector<VerdAux> AuxV; 186 }; 187 188 struct VernAux { 189 unsigned Hash; 190 unsigned Flags; 191 unsigned Other; 192 unsigned Offset; 193 std::string Name; 194 }; 195 196 struct VerNeed { 197 unsigned Version; 198 unsigned Cnt; 199 unsigned Offset; 200 std::string File; 201 std::vector<VernAux> AuxV; 202 }; 203 204 } // namespace 205 206 template <typename ELFT> class ELFDumper : public ObjDumper { 207 public: 208 ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, ScopedPrinter &Writer); 209 210 void printFileHeaders() override; 211 void printSectionHeaders() override; 212 void printRelocations() override; 213 void printDependentLibs() override; 214 void printDynamicRelocations() override; 215 void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; 216 void printHashSymbols() override; 217 void printUnwindInfo() override; 218 219 void printDynamicTable() override; 220 void printNeededLibraries() override; 221 void printProgramHeaders(bool PrintProgramHeaders, 222 cl::boolOrDefault PrintSectionMapping) override; 223 void printHashTable() override; 224 void printGnuHashTable(const object::ObjectFile *Obj) override; 225 void printLoadName() override; 226 void printVersionInfo() override; 227 void printGroupSections() override; 228 229 void printArchSpecificInfo() override; 230 231 void printStackMap() const override; 232 233 void printHashHistograms() override; 234 235 void printCGProfile() override; 236 void printAddrsig() override; 237 238 void printNotes() override; 239 240 void printELFLinkerOptions() override; 241 void printStackSizes() override; 242 243 const object::ELFObjectFile<ELFT> *getElfObject() const { return ObjF; }; 244 245 private: 246 std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle; 247 248 TYPEDEF_ELF_TYPES(ELFT) 249 250 DynRegionInfo checkDRI(DynRegionInfo DRI) { 251 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 252 if (DRI.Addr < Obj->base() || 253 reinterpret_cast<const uint8_t *>(DRI.Addr) + DRI.Size > 254 Obj->base() + Obj->getBufSize()) 255 reportError(errorCodeToError(llvm::object::object_error::parse_failed), 256 ObjF->getFileName()); 257 return DRI; 258 } 259 260 DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) { 261 return checkDRI({ObjF->getELFFile()->base() + P->p_offset, P->p_filesz, 262 EntSize, ObjF->getFileName()}); 263 } 264 265 DynRegionInfo createDRIFrom(const Elf_Shdr *S) { 266 return checkDRI({ObjF->getELFFile()->base() + S->sh_offset, S->sh_size, 267 S->sh_entsize, ObjF->getFileName()}); 268 } 269 270 void printAttributes(); 271 void printMipsReginfo(); 272 void printMipsOptions(); 273 274 std::pair<const Elf_Phdr *, const Elf_Shdr *> 275 findDynamic(const ELFFile<ELFT> *Obj); 276 void loadDynamicTable(const ELFFile<ELFT> *Obj); 277 void parseDynamicTable(const ELFFile<ELFT> *Obj); 278 279 Expected<StringRef> getSymbolVersion(const Elf_Sym *symb, 280 bool &IsDefault) const; 281 Error LoadVersionMap() const; 282 283 const object::ELFObjectFile<ELFT> *ObjF; 284 DynRegionInfo DynRelRegion; 285 DynRegionInfo DynRelaRegion; 286 DynRegionInfo DynRelrRegion; 287 DynRegionInfo DynPLTRelRegion; 288 Optional<DynRegionInfo> DynSymRegion; 289 DynRegionInfo DynamicTable; 290 StringRef DynamicStringTable; 291 StringRef SOName = "<Not found>"; 292 const Elf_Hash *HashTable = nullptr; 293 const Elf_GnuHash *GnuHashTable = nullptr; 294 const Elf_Shdr *DotSymtabSec = nullptr; 295 const Elf_Shdr *DotDynsymSec = nullptr; 296 const Elf_Shdr *DotCGProfileSec = nullptr; 297 const Elf_Shdr *DotAddrsigSec = nullptr; 298 ArrayRef<Elf_Word> ShndxTable; 299 300 const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version 301 const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r 302 const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d 303 304 struct VersionEntry { 305 std::string Name; 306 bool IsVerDef; 307 }; 308 mutable SmallVector<Optional<VersionEntry>, 16> VersionMap; 309 310 std::unordered_set<std::string> Warnings; 311 312 std::string describe(const Elf_Shdr &Sec) const; 313 314 public: 315 Elf_Dyn_Range dynamic_table() const { 316 // A valid .dynamic section contains an array of entries terminated 317 // with a DT_NULL entry. However, sometimes the section content may 318 // continue past the DT_NULL entry, so to dump the section correctly, 319 // we first find the end of the entries by iterating over them. 320 Elf_Dyn_Range Table = DynamicTable.getAsArrayRef<Elf_Dyn>(); 321 322 size_t Size = 0; 323 while (Size < Table.size()) 324 if (Table[Size++].getTag() == DT_NULL) 325 break; 326 327 return Table.slice(0, Size); 328 } 329 330 Optional<DynRegionInfo> getDynSymRegion() const { return DynSymRegion; } 331 332 Elf_Sym_Range dynamic_symbols() const { 333 if (!DynSymRegion) 334 return Elf_Sym_Range(); 335 return DynSymRegion->getAsArrayRef<Elf_Sym>(); 336 } 337 338 Elf_Rel_Range dyn_rels() const; 339 Elf_Rela_Range dyn_relas() const; 340 Elf_Relr_Range dyn_relrs() const; 341 std::string getFullSymbolName(const Elf_Sym *Symbol, 342 Optional<StringRef> StrTable, 343 bool IsDynamic) const; 344 Expected<unsigned> getSymbolSectionIndex(const Elf_Sym *Symbol, 345 const Elf_Sym *FirstSym) const; 346 Expected<StringRef> getSymbolSectionName(const Elf_Sym *Symbol, 347 unsigned SectionIndex) const; 348 std::string getStaticSymbolName(uint32_t Index) const; 349 StringRef getDynamicString(uint64_t Value) const; 350 Expected<StringRef> getSymbolVersionByIndex(uint32_t VersionSymbolIndex, 351 bool &IsDefault) const; 352 353 void printSymbolsHelper(bool IsDynamic) const; 354 std::string getDynamicEntry(uint64_t Type, uint64_t Value) const; 355 356 const Elf_Shdr *findSectionByName(StringRef Name) const; 357 358 const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; } 359 const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; } 360 const Elf_Shdr *getDotAddrsigSec() const { return DotAddrsigSec; } 361 ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; } 362 StringRef getDynamicStringTable() const { return DynamicStringTable; } 363 const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; } 364 const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; } 365 const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; } 366 const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; } 367 const DynRegionInfo &getDynamicTableRegion() const { return DynamicTable; } 368 const Elf_Hash *getHashTable() const { return HashTable; } 369 const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; } 370 371 Expected<ArrayRef<Elf_Versym>> getVersionTable(const Elf_Shdr *Sec, 372 ArrayRef<Elf_Sym> *SymTab, 373 StringRef *StrTab) const; 374 Expected<std::vector<VerDef>> 375 getVersionDefinitions(const Elf_Shdr *Sec) const; 376 Expected<std::vector<VerNeed>> 377 getVersionDependencies(const Elf_Shdr *Sec) const; 378 379 template <class RelTy> 380 Expected<std::pair<const Elf_Sym *, std::string>> 381 getRelocationTarget(const Elf_Shdr *SymTab, const RelTy &R) const; 382 383 std::function<Error(const Twine &Msg)> WarningHandler; 384 void reportUniqueWarning(Error Err) const; 385 }; 386 387 template <class ELFT> 388 static std::string describe(const ELFFile<ELFT> *Obj, 389 const typename ELFT::Shdr &Sec) { 390 unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front(); 391 return (object::getELFSectionTypeName(Obj->getHeader()->e_machine, 392 Sec.sh_type) + 393 " section with index " + Twine(SecNdx)) 394 .str(); 395 } 396 397 template <class ELFT> 398 std::string ELFDumper<ELFT>::describe(const Elf_Shdr &Sec) const { 399 return ::describe(ObjF->getELFFile(), Sec); 400 } 401 402 template <class ELFT> 403 static Expected<StringRef> getLinkAsStrtab(const ELFFile<ELFT> *Obj, 404 const typename ELFT::Shdr *Sec) { 405 Expected<const typename ELFT::Shdr *> StrTabSecOrErr = 406 Obj->getSection(Sec->sh_link); 407 if (!StrTabSecOrErr) 408 return createError("invalid section linked to " + describe(Obj, *Sec) + 409 ": " + toString(StrTabSecOrErr.takeError())); 410 411 Expected<StringRef> StrTabOrErr = Obj->getStringTable(*StrTabSecOrErr); 412 if (!StrTabOrErr) 413 return createError("invalid string table linked to " + describe(Obj, *Sec) + 414 ": " + toString(StrTabOrErr.takeError())); 415 return *StrTabOrErr; 416 } 417 418 // Returns the linked symbol table and associated string table for a given section. 419 template <class ELFT> 420 static Expected<std::pair<typename ELFT::SymRange, StringRef>> 421 getLinkAsSymtab(const ELFFile<ELFT> *Obj, const typename ELFT::Shdr *Sec, 422 unsigned ExpectedType) { 423 Expected<const typename ELFT::Shdr *> SymtabOrErr = 424 Obj->getSection(Sec->sh_link); 425 if (!SymtabOrErr) 426 return createError("invalid section linked to " + describe(Obj, *Sec) + 427 ": " + toString(SymtabOrErr.takeError())); 428 429 if ((*SymtabOrErr)->sh_type != ExpectedType) 430 return createError( 431 "invalid section linked to " + describe(Obj, *Sec) + ": expected " + 432 object::getELFSectionTypeName(Obj->getHeader()->e_machine, 433 ExpectedType) + 434 ", but got " + 435 object::getELFSectionTypeName(Obj->getHeader()->e_machine, 436 (*SymtabOrErr)->sh_type)); 437 438 Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, *SymtabOrErr); 439 if (!StrTabOrErr) 440 return createError( 441 "can't get a string table for the symbol table linked to " + 442 describe(Obj, *Sec) + ": " + toString(StrTabOrErr.takeError())); 443 444 Expected<typename ELFT::SymRange> SymsOrErr = Obj->symbols(*SymtabOrErr); 445 if (!SymsOrErr) 446 return createError("unable to read symbols from the " + 447 describe(Obj, *Sec) + ": " + 448 toString(SymsOrErr.takeError())); 449 450 return std::make_pair(*SymsOrErr, *StrTabOrErr); 451 } 452 453 template <class ELFT> 454 Expected<ArrayRef<typename ELFT::Versym>> 455 ELFDumper<ELFT>::getVersionTable(const Elf_Shdr *Sec, ArrayRef<Elf_Sym> *SymTab, 456 StringRef *StrTab) const { 457 assert((!SymTab && !StrTab) || (SymTab && StrTab)); 458 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 459 460 if (uintptr_t(Obj->base() + Sec->sh_offset) % sizeof(uint16_t) != 0) 461 return createError("the " + describe(*Sec) + " is misaligned"); 462 463 Expected<ArrayRef<Elf_Versym>> VersionsOrErr = 464 Obj->template getSectionContentsAsArray<Elf_Versym>(Sec); 465 if (!VersionsOrErr) 466 return createError("cannot read content of " + describe(*Sec) + ": " + 467 toString(VersionsOrErr.takeError())); 468 469 Expected<std::pair<ArrayRef<Elf_Sym>, StringRef>> SymTabOrErr = 470 getLinkAsSymtab(Obj, Sec, SHT_DYNSYM); 471 if (!SymTabOrErr) { 472 reportUniqueWarning(SymTabOrErr.takeError()); 473 return *VersionsOrErr; 474 } 475 476 if (SymTabOrErr->first.size() != VersionsOrErr->size()) 477 reportUniqueWarning( 478 createError(describe(*Sec) + ": the number of entries (" + 479 Twine(VersionsOrErr->size()) + 480 ") does not match the number of symbols (" + 481 Twine(SymTabOrErr->first.size()) + 482 ") in the symbol table with index " + Twine(Sec->sh_link))); 483 484 if (SymTab) 485 std::tie(*SymTab, *StrTab) = *SymTabOrErr; 486 return *VersionsOrErr; 487 } 488 489 template <class ELFT> 490 Expected<std::vector<VerDef>> 491 ELFDumper<ELFT>::getVersionDefinitions(const Elf_Shdr *Sec) const { 492 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 493 494 Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, Sec); 495 if (!StrTabOrErr) 496 return StrTabOrErr.takeError(); 497 498 Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(Sec); 499 if (!ContentsOrErr) 500 return createError("cannot read content of " + describe(*Sec) + ": " + 501 toString(ContentsOrErr.takeError())); 502 503 const uint8_t *Start = ContentsOrErr->data(); 504 const uint8_t *End = Start + ContentsOrErr->size(); 505 506 auto ExtractNextAux = [&](const uint8_t *&VerdauxBuf, 507 unsigned VerDefNdx) -> Expected<VerdAux> { 508 if (VerdauxBuf + sizeof(Elf_Verdaux) > End) 509 return createError("invalid " + describe(*Sec) + ": version definition " + 510 Twine(VerDefNdx) + 511 " refers to an auxiliary entry that goes past the end " 512 "of the section"); 513 514 auto *Verdaux = reinterpret_cast<const Elf_Verdaux *>(VerdauxBuf); 515 VerdauxBuf += Verdaux->vda_next; 516 517 VerdAux Aux; 518 Aux.Offset = VerdauxBuf - Start; 519 if (Verdaux->vda_name <= StrTabOrErr->size()) 520 Aux.Name = std::string(StrTabOrErr->drop_front(Verdaux->vda_name)); 521 else 522 Aux.Name = "<invalid vda_name: " + to_string(Verdaux->vda_name) + ">"; 523 return Aux; 524 }; 525 526 std::vector<VerDef> Ret; 527 const uint8_t *VerdefBuf = Start; 528 for (unsigned I = 1; I <= /*VerDefsNum=*/Sec->sh_info; ++I) { 529 if (VerdefBuf + sizeof(Elf_Verdef) > End) 530 return createError("invalid " + describe(*Sec) + ": version definition " + 531 Twine(I) + " goes past the end of the section"); 532 533 if (uintptr_t(VerdefBuf) % sizeof(uint32_t) != 0) 534 return createError( 535 "invalid " + describe(*Sec) + 536 ": found a misaligned version definition entry at offset 0x" + 537 Twine::utohexstr(VerdefBuf - Start)); 538 539 unsigned Version = *reinterpret_cast<const Elf_Half *>(VerdefBuf); 540 if (Version != 1) 541 return createError("unable to dump " + describe(*Sec) + ": version " + 542 Twine(Version) + " is not yet supported"); 543 544 const Elf_Verdef *D = reinterpret_cast<const Elf_Verdef *>(VerdefBuf); 545 VerDef &VD = *Ret.emplace(Ret.end()); 546 VD.Offset = VerdefBuf - Start; 547 VD.Version = D->vd_version; 548 VD.Flags = D->vd_flags; 549 VD.Ndx = D->vd_ndx; 550 VD.Cnt = D->vd_cnt; 551 VD.Hash = D->vd_hash; 552 553 const uint8_t *VerdauxBuf = VerdefBuf + D->vd_aux; 554 for (unsigned J = 0; J < D->vd_cnt; ++J) { 555 if (uintptr_t(VerdauxBuf) % sizeof(uint32_t) != 0) 556 return createError("invalid " + describe(*Sec) + 557 ": found a misaligned auxiliary entry at offset 0x" + 558 Twine::utohexstr(VerdauxBuf - Start)); 559 560 Expected<VerdAux> AuxOrErr = ExtractNextAux(VerdauxBuf, I); 561 if (!AuxOrErr) 562 return AuxOrErr.takeError(); 563 564 if (J == 0) 565 VD.Name = AuxOrErr->Name; 566 else 567 VD.AuxV.push_back(*AuxOrErr); 568 } 569 570 VerdefBuf += D->vd_next; 571 } 572 573 return Ret; 574 } 575 576 template <class ELFT> 577 Expected<std::vector<VerNeed>> 578 ELFDumper<ELFT>::getVersionDependencies(const Elf_Shdr *Sec) const { 579 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 580 StringRef StrTab; 581 Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, Sec); 582 if (!StrTabOrErr) 583 reportUniqueWarning(StrTabOrErr.takeError()); 584 else 585 StrTab = *StrTabOrErr; 586 587 Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(Sec); 588 if (!ContentsOrErr) 589 return createError("cannot read content of " + describe(*Sec) + ": " + 590 toString(ContentsOrErr.takeError())); 591 592 const uint8_t *Start = ContentsOrErr->data(); 593 const uint8_t *End = Start + ContentsOrErr->size(); 594 const uint8_t *VerneedBuf = Start; 595 596 std::vector<VerNeed> Ret; 597 for (unsigned I = 1; I <= /*VerneedNum=*/Sec->sh_info; ++I) { 598 if (VerneedBuf + sizeof(Elf_Verdef) > End) 599 return createError("invalid " + describe(*Sec) + ": version dependency " + 600 Twine(I) + " goes past the end of the section"); 601 602 if (uintptr_t(VerneedBuf) % sizeof(uint32_t) != 0) 603 return createError( 604 "invalid " + describe(*Sec) + 605 ": found a misaligned version dependency entry at offset 0x" + 606 Twine::utohexstr(VerneedBuf - Start)); 607 608 unsigned Version = *reinterpret_cast<const Elf_Half *>(VerneedBuf); 609 if (Version != 1) 610 return createError("unable to dump " + describe(*Sec) + ": version " + 611 Twine(Version) + " is not yet supported"); 612 613 const Elf_Verneed *Verneed = 614 reinterpret_cast<const Elf_Verneed *>(VerneedBuf); 615 616 VerNeed &VN = *Ret.emplace(Ret.end()); 617 VN.Version = Verneed->vn_version; 618 VN.Cnt = Verneed->vn_cnt; 619 VN.Offset = VerneedBuf - Start; 620 621 if (Verneed->vn_file < StrTab.size()) 622 VN.File = std::string(StrTab.drop_front(Verneed->vn_file)); 623 else 624 VN.File = "<corrupt vn_file: " + to_string(Verneed->vn_file) + ">"; 625 626 const uint8_t *VernauxBuf = VerneedBuf + Verneed->vn_aux; 627 for (unsigned J = 0; J < Verneed->vn_cnt; ++J) { 628 if (uintptr_t(VernauxBuf) % sizeof(uint32_t) != 0) 629 return createError("invalid " + describe(*Sec) + 630 ": found a misaligned auxiliary entry at offset 0x" + 631 Twine::utohexstr(VernauxBuf - Start)); 632 633 if (VernauxBuf + sizeof(Elf_Vernaux) > End) 634 return createError( 635 "invalid " + describe(*Sec) + ": version dependency " + Twine(I) + 636 " refers to an auxiliary entry that goes past the end " 637 "of the section"); 638 639 const Elf_Vernaux *Vernaux = 640 reinterpret_cast<const Elf_Vernaux *>(VernauxBuf); 641 642 VernAux &Aux = *VN.AuxV.emplace(VN.AuxV.end()); 643 Aux.Hash = Vernaux->vna_hash; 644 Aux.Flags = Vernaux->vna_flags; 645 Aux.Other = Vernaux->vna_other; 646 Aux.Offset = VernauxBuf - Start; 647 if (StrTab.size() <= Vernaux->vna_name) 648 Aux.Name = "<corrupt>"; 649 else 650 Aux.Name = std::string(StrTab.drop_front(Vernaux->vna_name)); 651 652 VernauxBuf += Vernaux->vna_next; 653 } 654 VerneedBuf += Verneed->vn_next; 655 } 656 return Ret; 657 } 658 659 template <class ELFT> 660 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const { 661 Optional<StringRef> StrTable; 662 size_t Entries = 0; 663 Elf_Sym_Range Syms(nullptr, nullptr); 664 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 665 const Elf_Shdr *SymtabSec = IsDynamic ? DotDynsymSec : DotSymtabSec; 666 667 if (IsDynamic) { 668 StrTable = DynamicStringTable; 669 Syms = dynamic_symbols(); 670 Entries = Syms.size(); 671 } else if (DotSymtabSec) { 672 if (Expected<StringRef> StrTableOrErr = 673 Obj->getStringTableForSymtab(*DotSymtabSec)) 674 StrTable = *StrTableOrErr; 675 else 676 reportUniqueWarning(createError( 677 "unable to get the string table for the SHT_SYMTAB section: " + 678 toString(StrTableOrErr.takeError()))); 679 680 if (Expected<Elf_Sym_Range> SymsOrErr = Obj->symbols(DotSymtabSec)) 681 Syms = *SymsOrErr; 682 else 683 reportUniqueWarning( 684 createError("unable to read symbols from the SHT_SYMTAB section: " + 685 toString(SymsOrErr.takeError()))); 686 Entries = DotSymtabSec->getEntityCount(); 687 } 688 if (Syms.begin() == Syms.end()) 689 return; 690 691 // The st_other field has 2 logical parts. The first two bits hold the symbol 692 // visibility (STV_*) and the remainder hold other platform-specific values. 693 bool NonVisibilityBitsUsed = llvm::find_if(Syms, [](const Elf_Sym &S) { 694 return S.st_other & ~0x3; 695 }) != Syms.end(); 696 697 ELFDumperStyle->printSymtabMessage(Obj, SymtabSec, Entries, 698 NonVisibilityBitsUsed); 699 for (const auto &Sym : Syms) 700 ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic, 701 NonVisibilityBitsUsed); 702 } 703 704 template <class ELFT> class MipsGOTParser; 705 706 template <typename ELFT> class DumpStyle { 707 public: 708 TYPEDEF_ELF_TYPES(ELFT) 709 710 DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) { 711 FileName = this->Dumper->getElfObject()->getFileName(); 712 } 713 714 virtual ~DumpStyle() = default; 715 716 virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0; 717 virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0; 718 virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0; 719 virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0; 720 virtual void printSymbols(const ELFFile<ELFT> *Obj, bool PrintSymbols, 721 bool PrintDynamicSymbols) = 0; 722 virtual void printHashSymbols(const ELFFile<ELFT> *Obj) {} 723 virtual void printDependentLibs(const ELFFile<ELFT> *Obj) = 0; 724 virtual void printDynamic(const ELFFile<ELFT> *Obj) {} 725 virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0; 726 virtual void printSymtabMessage(const ELFFile<ELFT> *Obj, 727 const Elf_Shdr *Symtab, size_t Offset, 728 bool NonVisibilityBitsUsed) {} 729 virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol, 730 const Elf_Sym *FirstSym, 731 Optional<StringRef> StrTable, bool IsDynamic, 732 bool NonVisibilityBitsUsed) = 0; 733 virtual void printProgramHeaders(const ELFFile<ELFT> *Obj, 734 bool PrintProgramHeaders, 735 cl::boolOrDefault PrintSectionMapping) = 0; 736 virtual void printVersionSymbolSection(const ELFFile<ELFT> *Obj, 737 const Elf_Shdr *Sec) = 0; 738 virtual void printVersionDefinitionSection(const ELFFile<ELFT> *Obj, 739 const Elf_Shdr *Sec) = 0; 740 virtual void printVersionDependencySection(const ELFFile<ELFT> *Obj, 741 const Elf_Shdr *Sec) = 0; 742 virtual void printHashHistograms(const ELFFile<ELFT> *Obj) = 0; 743 virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0; 744 virtual void printAddrsig(const ELFFile<ELFT> *Obj) = 0; 745 virtual void printNotes(const ELFFile<ELFT> *Obj) = 0; 746 virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0; 747 virtual void printStackSizes(const ELFObjectFile<ELFT> *Obj) = 0; 748 void printNonRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj, 749 std::function<void()> PrintHeader); 750 void printRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj, 751 std::function<void()> PrintHeader); 752 void printFunctionStackSize(const ELFObjectFile<ELFT> *Obj, uint64_t SymValue, 753 Optional<SectionRef> FunctionSec, 754 const StringRef SectionName, DataExtractor Data, 755 uint64_t *Offset); 756 void printStackSize(const ELFObjectFile<ELFT> *Obj, RelocationRef Rel, 757 SectionRef FunctionSec, 758 const StringRef &StackSizeSectionName, 759 const RelocationResolver &Resolver, DataExtractor Data); 760 virtual void printStackSizeEntry(uint64_t Size, StringRef FuncName) = 0; 761 virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0; 762 virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0; 763 virtual void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) = 0; 764 const ELFDumper<ELFT> *dumper() const { return Dumper; } 765 766 protected: 767 void printDependentLibsHelper( 768 const ELFFile<ELFT> *Obj, 769 function_ref<void(const Elf_Shdr &)> OnSectionStart, 770 function_ref<void(StringRef, uint64_t)> OnSectionEntry); 771 772 virtual void printRelReloc(const ELFO *Obj, unsigned SecIndex, 773 const Elf_Shdr *SymTab, const Elf_Rel &R, 774 unsigned RelIndex) = 0; 775 virtual void printRelaReloc(const ELFO *Obj, unsigned SecIndex, 776 const Elf_Shdr *SymTab, const Elf_Rela &R, 777 unsigned RelIndex) = 0; 778 virtual void printRelrReloc(const Elf_Relr &R) = 0; 779 void printRelocationsHelper(const ELFFile<ELFT> *Obj, const Elf_Shdr &Sec); 780 781 StringRef getPrintableSectionName(const ELFFile<ELFT> *Obj, 782 const Elf_Shdr &Sec) const; 783 784 void reportUniqueWarning(Error Err) const; 785 StringRef FileName; 786 787 private: 788 const ELFDumper<ELFT> *Dumper; 789 }; 790 791 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> { 792 formatted_raw_ostream &OS; 793 794 public: 795 TYPEDEF_ELF_TYPES(ELFT) 796 797 GNUStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper) 798 : DumpStyle<ELFT>(Dumper), 799 OS(static_cast<formatted_raw_ostream&>(W.getOStream())) { 800 assert (&W.getOStream() == &llvm::fouts()); 801 } 802 803 void printFileHeaders(const ELFO *Obj) override; 804 void printGroupSections(const ELFFile<ELFT> *Obj) override; 805 void printRelocations(const ELFO *Obj) override; 806 void printSectionHeaders(const ELFO *Obj) override; 807 void printSymbols(const ELFO *Obj, bool PrintSymbols, 808 bool PrintDynamicSymbols) override; 809 void printHashSymbols(const ELFO *Obj) override; 810 void printDependentLibs(const ELFFile<ELFT> *Obj) override; 811 void printDynamic(const ELFFile<ELFT> *Obj) override; 812 void printDynamicRelocations(const ELFO *Obj) override; 813 void printSymtabMessage(const ELFO *Obj, const Elf_Shdr *Symtab, 814 size_t Offset, bool NonVisibilityBitsUsed) override; 815 void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders, 816 cl::boolOrDefault PrintSectionMapping) override; 817 void printVersionSymbolSection(const ELFFile<ELFT> *Obj, 818 const Elf_Shdr *Sec) override; 819 void printVersionDefinitionSection(const ELFFile<ELFT> *Obj, 820 const Elf_Shdr *Sec) override; 821 void printVersionDependencySection(const ELFFile<ELFT> *Obj, 822 const Elf_Shdr *Sec) override; 823 void printHashHistograms(const ELFFile<ELFT> *Obj) override; 824 void printCGProfile(const ELFFile<ELFT> *Obj) override; 825 void printAddrsig(const ELFFile<ELFT> *Obj) override; 826 void printNotes(const ELFFile<ELFT> *Obj) override; 827 void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override; 828 void printStackSizes(const ELFObjectFile<ELFT> *Obj) override; 829 void printStackSizeEntry(uint64_t Size, StringRef FuncName) override; 830 void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; 831 void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; 832 void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) override; 833 834 private: 835 void printHashHistogram(const Elf_Hash &HashTable); 836 void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable); 837 838 void printHashTableSymbols(const ELFO *Obj, const Elf_Hash &HashTable); 839 void printGnuHashTableSymbols(const ELFO *Obj, 840 const Elf_GnuHash &GnuHashTable); 841 842 struct Field { 843 std::string Str; 844 unsigned Column; 845 846 Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {} 847 Field(unsigned Col) : Column(Col) {} 848 }; 849 850 template <typename T, typename TEnum> 851 std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) { 852 for (const auto &EnumItem : EnumValues) 853 if (EnumItem.Value == Value) 854 return std::string(EnumItem.AltName); 855 return to_hexString(Value, false); 856 } 857 858 template <typename T, typename TEnum> 859 std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues, 860 TEnum EnumMask1 = {}, TEnum EnumMask2 = {}, 861 TEnum EnumMask3 = {}) { 862 std::string Str; 863 for (const auto &Flag : EnumValues) { 864 if (Flag.Value == 0) 865 continue; 866 867 TEnum EnumMask{}; 868 if (Flag.Value & EnumMask1) 869 EnumMask = EnumMask1; 870 else if (Flag.Value & EnumMask2) 871 EnumMask = EnumMask2; 872 else if (Flag.Value & EnumMask3) 873 EnumMask = EnumMask3; 874 bool IsEnum = (Flag.Value & EnumMask) != 0; 875 if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || 876 (IsEnum && (Value & EnumMask) == Flag.Value)) { 877 if (!Str.empty()) 878 Str += ", "; 879 Str += Flag.AltName; 880 } 881 } 882 return Str; 883 } 884 885 formatted_raw_ostream &printField(struct Field F) { 886 if (F.Column != 0) 887 OS.PadToColumn(F.Column); 888 OS << F.Str; 889 OS.flush(); 890 return OS; 891 } 892 void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym, 893 StringRef StrTable, uint32_t Bucket); 894 void printRelocHeader(unsigned SType); 895 896 void printRelReloc(const ELFO *Obj, unsigned SecIndex, const Elf_Shdr *SymTab, 897 const Elf_Rel &R, unsigned RelIndex) override; 898 void printRelaReloc(const ELFO *Obj, unsigned SecIndex, 899 const Elf_Shdr *SymTab, const Elf_Rela &R, 900 unsigned RelIndex) override; 901 void printRelrReloc(const Elf_Relr &R) override; 902 903 template <class RelTy> 904 void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex, 905 const Elf_Shdr *SymTab, const RelTy &R, 906 unsigned RelIndex); 907 template <class RelTy> 908 void printRelRelaReloc(const ELFO *Obj, const Elf_Sym *Sym, 909 StringRef SymbolName, const RelTy &R); 910 void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, 911 Optional<StringRef> StrTable, bool IsDynamic, 912 bool NonVisibilityBitsUsed) override; 913 std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol, 914 const Elf_Sym *FirstSym); 915 template <class RelTy> 916 void printDynamicRelocation(const ELFO *Obj, const RelTy &R); 917 void printProgramHeaders(const ELFO *Obj); 918 void printSectionMapping(const ELFO *Obj); 919 void printGNUVersionSectionProlog(const ELFFile<ELFT> *Obj, 920 const typename ELFT::Shdr *Sec, 921 const Twine &Label, unsigned EntriesNum); 922 }; 923 924 template <class ELFT> 925 void ELFDumper<ELFT>::reportUniqueWarning(Error Err) const { 926 handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { 927 cantFail(WarningHandler(EI.message()), 928 "WarningHandler should always return ErrorSuccess"); 929 }); 930 } 931 932 template <class ELFT> 933 void DumpStyle<ELFT>::reportUniqueWarning(Error Err) const { 934 this->dumper()->reportUniqueWarning(std::move(Err)); 935 } 936 937 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> { 938 public: 939 TYPEDEF_ELF_TYPES(ELFT) 940 941 LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper) 942 : DumpStyle<ELFT>(Dumper), W(W) {} 943 944 void printFileHeaders(const ELFO *Obj) override; 945 void printGroupSections(const ELFFile<ELFT> *Obj) override; 946 void printRelocations(const ELFO *Obj) override; 947 void printSectionHeaders(const ELFO *Obj) override; 948 void printSymbols(const ELFO *Obj, bool PrintSymbols, 949 bool PrintDynamicSymbols) override; 950 void printDependentLibs(const ELFFile<ELFT> *Obj) override; 951 void printDynamic(const ELFFile<ELFT> *Obj) override; 952 void printDynamicRelocations(const ELFO *Obj) override; 953 void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders, 954 cl::boolOrDefault PrintSectionMapping) override; 955 void printVersionSymbolSection(const ELFFile<ELFT> *Obj, 956 const Elf_Shdr *Sec) override; 957 void printVersionDefinitionSection(const ELFFile<ELFT> *Obj, 958 const Elf_Shdr *Sec) override; 959 void printVersionDependencySection(const ELFFile<ELFT> *Obj, 960 const Elf_Shdr *Sec) override; 961 void printHashHistograms(const ELFFile<ELFT> *Obj) override; 962 void printCGProfile(const ELFFile<ELFT> *Obj) override; 963 void printAddrsig(const ELFFile<ELFT> *Obj) override; 964 void printNotes(const ELFFile<ELFT> *Obj) override; 965 void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override; 966 void printStackSizes(const ELFObjectFile<ELFT> *Obj) override; 967 void printStackSizeEntry(uint64_t Size, StringRef FuncName) override; 968 void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override; 969 void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override; 970 void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) override; 971 972 private: 973 void printRelReloc(const ELFO *Obj, unsigned SecIndex, const Elf_Shdr *SymTab, 974 const Elf_Rel &R, unsigned RelIndex) override; 975 void printRelaReloc(const ELFO *Obj, unsigned SecIndex, 976 const Elf_Shdr *SymTab, const Elf_Rela &R, 977 unsigned RelIndex) override; 978 void printRelrReloc(const Elf_Relr &R) override; 979 template <class RelTy> 980 void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex, const RelTy &Rel, 981 unsigned RelIndex, const Elf_Shdr *SymTab); 982 template <class RelTy> 983 void printDynamicRelocation(const ELFO *Obj, const RelTy& Rel); 984 985 void printSymbols(const ELFO *Obj); 986 void printDynamicSymbols(const ELFO *Obj); 987 void printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First); 988 void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, 989 Optional<StringRef> StrTable, bool IsDynamic, 990 bool /*NonVisibilityBitsUsed*/) override; 991 void printProgramHeaders(const ELFO *Obj); 992 void printSectionMapping(const ELFO *Obj) {} 993 994 ScopedPrinter &W; 995 }; 996 997 } // end anonymous namespace 998 999 namespace llvm { 1000 1001 template <class ELFT> 1002 static std::error_code createELFDumper(const ELFObjectFile<ELFT> *Obj, 1003 ScopedPrinter &Writer, 1004 std::unique_ptr<ObjDumper> &Result) { 1005 Result.reset(new ELFDumper<ELFT>(Obj, Writer)); 1006 return readobj_error::success; 1007 } 1008 1009 std::error_code createELFDumper(const object::ObjectFile *Obj, 1010 ScopedPrinter &Writer, 1011 std::unique_ptr<ObjDumper> &Result) { 1012 // Little-endian 32-bit 1013 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) 1014 return createELFDumper(ELFObj, Writer, Result); 1015 1016 // Big-endian 32-bit 1017 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj)) 1018 return createELFDumper(ELFObj, Writer, Result); 1019 1020 // Little-endian 64-bit 1021 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj)) 1022 return createELFDumper(ELFObj, Writer, Result); 1023 1024 // Big-endian 64-bit 1025 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj)) 1026 return createELFDumper(ELFObj, Writer, Result); 1027 1028 return readobj_error::unsupported_obj_file_format; 1029 } 1030 1031 } // end namespace llvm 1032 1033 template <class ELFT> Error ELFDumper<ELFT>::LoadVersionMap() const { 1034 // If there is no dynamic symtab or version table, there is nothing to do. 1035 if (!DynSymRegion || !SymbolVersionSection) 1036 return Error::success(); 1037 1038 // Has the VersionMap already been loaded? 1039 if (!VersionMap.empty()) 1040 return Error::success(); 1041 1042 // The first two version indexes are reserved. 1043 // Index 0 is LOCAL, index 1 is GLOBAL. 1044 VersionMap.push_back(VersionEntry()); 1045 VersionMap.push_back(VersionEntry()); 1046 1047 auto InsertEntry = [this](unsigned N, StringRef Version, bool IsVerdef) { 1048 if (N >= VersionMap.size()) 1049 VersionMap.resize(N + 1); 1050 VersionMap[N] = {std::string(Version), IsVerdef}; 1051 }; 1052 1053 if (SymbolVersionDefSection) { 1054 Expected<std::vector<VerDef>> Defs = 1055 this->getVersionDefinitions(SymbolVersionDefSection); 1056 if (!Defs) 1057 return Defs.takeError(); 1058 for (const VerDef &Def : *Defs) 1059 InsertEntry(Def.Ndx & ELF::VERSYM_VERSION, Def.Name, true); 1060 } 1061 1062 if (SymbolVersionNeedSection) { 1063 Expected<std::vector<VerNeed>> Deps = 1064 this->getVersionDependencies(SymbolVersionNeedSection); 1065 if (!Deps) 1066 return Deps.takeError(); 1067 for (const VerNeed &Dep : *Deps) 1068 for (const VernAux &Aux : Dep.AuxV) 1069 InsertEntry(Aux.Other & ELF::VERSYM_VERSION, Aux.Name, false); 1070 } 1071 1072 return Error::success(); 1073 } 1074 1075 template <typename ELFT> 1076 Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym *Sym, 1077 bool &IsDefault) const { 1078 // This is a dynamic symbol. Look in the GNU symbol version table. 1079 if (!SymbolVersionSection) { 1080 // No version table. 1081 IsDefault = false; 1082 return ""; 1083 } 1084 1085 assert(DynSymRegion && "DynSymRegion has not been initialised"); 1086 // Determine the position in the symbol table of this entry. 1087 size_t EntryIndex = (reinterpret_cast<uintptr_t>(Sym) - 1088 reinterpret_cast<uintptr_t>(DynSymRegion->Addr)) / 1089 sizeof(Elf_Sym); 1090 1091 // Get the corresponding version index entry. 1092 if (Expected<const Elf_Versym *> EntryOrErr = 1093 ObjF->getELFFile()->template getEntry<Elf_Versym>( 1094 SymbolVersionSection, EntryIndex)) 1095 return this->getSymbolVersionByIndex((*EntryOrErr)->vs_index, IsDefault); 1096 else 1097 return EntryOrErr.takeError(); 1098 } 1099 1100 template <typename ELFT> 1101 template <class RelTy> 1102 Expected<std::pair<const typename ELFT::Sym *, std::string>> 1103 ELFDumper<ELFT>::getRelocationTarget(const Elf_Shdr *SymTab, 1104 const RelTy &R) const { 1105 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 1106 Expected<const Elf_Sym *> SymOrErr = Obj->getRelocationSymbol(&R, SymTab); 1107 if (!SymOrErr) 1108 return SymOrErr.takeError(); 1109 const Elf_Sym *Sym = *SymOrErr; 1110 if (!Sym) 1111 return std::make_pair(nullptr, ""); 1112 1113 // The st_name field of a STT_SECTION is usually 0 (empty string). 1114 // This code block returns the section name. 1115 if (Sym->getType() == ELF::STT_SECTION) { 1116 Expected<const Elf_Shdr *> SecOrErr = 1117 Obj->getSection(Sym, SymTab, ShndxTable); 1118 if (!SecOrErr) 1119 return SecOrErr.takeError(); 1120 // A section symbol describes the section at index 0. 1121 if (*SecOrErr == nullptr) 1122 return std::make_pair(Sym, ""); 1123 1124 Expected<StringRef> NameOrErr = Obj->getSectionName(*SecOrErr); 1125 if (!NameOrErr) 1126 return NameOrErr.takeError(); 1127 return std::make_pair(Sym, NameOrErr->str()); 1128 } 1129 1130 Expected<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*SymTab); 1131 if (!StrTableOrErr) 1132 return StrTableOrErr.takeError(); 1133 1134 std::string SymbolName = 1135 getFullSymbolName(Sym, *StrTableOrErr, SymTab->sh_type == SHT_DYNSYM); 1136 return std::make_pair(Sym, SymbolName); 1137 } 1138 1139 static std::string maybeDemangle(StringRef Name) { 1140 return opts::Demangle ? demangle(std::string(Name)) : Name.str(); 1141 } 1142 1143 template <typename ELFT> 1144 std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const { 1145 auto Warn = [&](Error E) -> std::string { 1146 this->reportUniqueWarning( 1147 createError("unable to read the name of symbol with index " + 1148 Twine(Index) + ": " + toString(std::move(E)))); 1149 return "<?>"; 1150 }; 1151 1152 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 1153 Expected<const typename ELFT::Sym *> SymOrErr = 1154 Obj->getSymbol(DotSymtabSec, Index); 1155 if (!SymOrErr) 1156 return Warn(SymOrErr.takeError()); 1157 1158 Expected<StringRef> StrTabOrErr = Obj->getStringTableForSymtab(*DotSymtabSec); 1159 if (!StrTabOrErr) 1160 return Warn(StrTabOrErr.takeError()); 1161 1162 Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr); 1163 if (!NameOrErr) 1164 return Warn(NameOrErr.takeError()); 1165 return maybeDemangle(*NameOrErr); 1166 } 1167 1168 template <typename ELFT> 1169 Expected<StringRef> 1170 ELFDumper<ELFT>::getSymbolVersionByIndex(uint32_t SymbolVersionIndex, 1171 bool &IsDefault) const { 1172 size_t VersionIndex = SymbolVersionIndex & VERSYM_VERSION; 1173 1174 // Special markers for unversioned symbols. 1175 if (VersionIndex == VER_NDX_LOCAL || VersionIndex == VER_NDX_GLOBAL) { 1176 IsDefault = false; 1177 return ""; 1178 } 1179 1180 // Lookup this symbol in the version table. 1181 if (Error E = LoadVersionMap()) 1182 return std::move(E); 1183 if (VersionIndex >= VersionMap.size() || !VersionMap[VersionIndex]) 1184 return createError("SHT_GNU_versym section refers to a version index " + 1185 Twine(VersionIndex) + " which is missing"); 1186 1187 const VersionEntry &Entry = *VersionMap[VersionIndex]; 1188 if (Entry.IsVerDef) 1189 IsDefault = !(SymbolVersionIndex & VERSYM_HIDDEN); 1190 else 1191 IsDefault = false; 1192 return Entry.Name.c_str(); 1193 } 1194 1195 template <typename ELFT> 1196 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol, 1197 Optional<StringRef> StrTable, 1198 bool IsDynamic) const { 1199 if (!StrTable) 1200 return "<?>"; 1201 1202 std::string SymbolName; 1203 if (Expected<StringRef> NameOrErr = Symbol->getName(*StrTable)) { 1204 SymbolName = maybeDemangle(*NameOrErr); 1205 } else { 1206 reportUniqueWarning(NameOrErr.takeError()); 1207 return "<?>"; 1208 } 1209 1210 if (SymbolName.empty() && Symbol->getType() == ELF::STT_SECTION) { 1211 Elf_Sym_Range Syms = unwrapOrError( 1212 ObjF->getFileName(), ObjF->getELFFile()->symbols(DotSymtabSec)); 1213 Expected<unsigned> SectionIndex = 1214 getSymbolSectionIndex(Symbol, Syms.begin()); 1215 if (!SectionIndex) { 1216 reportUniqueWarning(SectionIndex.takeError()); 1217 return "<?>"; 1218 } 1219 Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex); 1220 if (!NameOrErr) { 1221 reportUniqueWarning(NameOrErr.takeError()); 1222 return ("<section " + Twine(*SectionIndex) + ">").str(); 1223 } 1224 return std::string(*NameOrErr); 1225 } 1226 1227 if (!IsDynamic) 1228 return SymbolName; 1229 1230 bool IsDefault; 1231 Expected<StringRef> VersionOrErr = getSymbolVersion(&*Symbol, IsDefault); 1232 if (!VersionOrErr) { 1233 reportUniqueWarning(VersionOrErr.takeError()); 1234 return SymbolName + "@<corrupt>"; 1235 } 1236 1237 if (!VersionOrErr->empty()) { 1238 SymbolName += (IsDefault ? "@@" : "@"); 1239 SymbolName += *VersionOrErr; 1240 } 1241 return SymbolName; 1242 } 1243 1244 template <typename ELFT> 1245 Expected<unsigned> 1246 ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym *Symbol, 1247 const Elf_Sym *FirstSym) const { 1248 return Symbol->st_shndx == SHN_XINDEX 1249 ? object::getExtendedSymbolTableIndex<ELFT>(Symbol, FirstSym, 1250 ShndxTable) 1251 : Symbol->st_shndx; 1252 } 1253 1254 // If the Symbol has a reserved st_shndx other than SHN_XINDEX, return a 1255 // descriptive interpretation of the st_shndx value. Otherwise, return the name 1256 // of the section with index SectionIndex. This function assumes that if the 1257 // Symbol has st_shndx == SHN_XINDEX the SectionIndex will be the value derived 1258 // from the SHT_SYMTAB_SHNDX section. 1259 template <typename ELFT> 1260 Expected<StringRef> 1261 ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym *Symbol, 1262 unsigned SectionIndex) const { 1263 if (Symbol->isUndefined()) 1264 return "Undefined"; 1265 if (Symbol->isProcessorSpecific()) 1266 return "Processor Specific"; 1267 if (Symbol->isOSSpecific()) 1268 return "Operating System Specific"; 1269 if (Symbol->isAbsolute()) 1270 return "Absolute"; 1271 if (Symbol->isCommon()) 1272 return "Common"; 1273 if (Symbol->isReserved() && Symbol->st_shndx != SHN_XINDEX) 1274 return "Reserved"; 1275 1276 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 1277 Expected<const Elf_Shdr *> SecOrErr = 1278 Obj->getSection(SectionIndex); 1279 if (!SecOrErr) 1280 return SecOrErr.takeError(); 1281 return Obj->getSectionName(*SecOrErr); 1282 } 1283 1284 template <class ELFO> 1285 static const typename ELFO::Elf_Shdr * 1286 findNotEmptySectionByAddress(const ELFO *Obj, StringRef FileName, 1287 uint64_t Addr) { 1288 for (const typename ELFO::Elf_Shdr &Shdr : cantFail(Obj->sections())) 1289 if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) 1290 return &Shdr; 1291 return nullptr; 1292 } 1293 1294 static const EnumEntry<unsigned> ElfClass[] = { 1295 {"None", "none", ELF::ELFCLASSNONE}, 1296 {"32-bit", "ELF32", ELF::ELFCLASS32}, 1297 {"64-bit", "ELF64", ELF::ELFCLASS64}, 1298 }; 1299 1300 static const EnumEntry<unsigned> ElfDataEncoding[] = { 1301 {"None", "none", ELF::ELFDATANONE}, 1302 {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, 1303 {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, 1304 }; 1305 1306 static const EnumEntry<unsigned> ElfObjectFileType[] = { 1307 {"None", "NONE (none)", ELF::ET_NONE}, 1308 {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, 1309 {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, 1310 {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, 1311 {"Core", "CORE (Core file)", ELF::ET_CORE}, 1312 }; 1313 1314 static const EnumEntry<unsigned> ElfOSABI[] = { 1315 {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, 1316 {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, 1317 {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, 1318 {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, 1319 {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, 1320 {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, 1321 {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, 1322 {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, 1323 {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, 1324 {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, 1325 {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, 1326 {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, 1327 {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, 1328 {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, 1329 {"AROS", "AROS", ELF::ELFOSABI_AROS}, 1330 {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, 1331 {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, 1332 {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} 1333 }; 1334 1335 static const EnumEntry<unsigned> SymVersionFlags[] = { 1336 {"Base", "BASE", VER_FLG_BASE}, 1337 {"Weak", "WEAK", VER_FLG_WEAK}, 1338 {"Info", "INFO", VER_FLG_INFO}}; 1339 1340 static const EnumEntry<unsigned> AMDGPUElfOSABI[] = { 1341 {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA}, 1342 {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}, 1343 {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D} 1344 }; 1345 1346 static const EnumEntry<unsigned> ARMElfOSABI[] = { 1347 {"ARM", "ARM", ELF::ELFOSABI_ARM} 1348 }; 1349 1350 static const EnumEntry<unsigned> C6000ElfOSABI[] = { 1351 {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, 1352 {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX} 1353 }; 1354 1355 static const EnumEntry<unsigned> ElfMachineType[] = { 1356 ENUM_ENT(EM_NONE, "None"), 1357 ENUM_ENT(EM_M32, "WE32100"), 1358 ENUM_ENT(EM_SPARC, "Sparc"), 1359 ENUM_ENT(EM_386, "Intel 80386"), 1360 ENUM_ENT(EM_68K, "MC68000"), 1361 ENUM_ENT(EM_88K, "MC88000"), 1362 ENUM_ENT(EM_IAMCU, "EM_IAMCU"), 1363 ENUM_ENT(EM_860, "Intel 80860"), 1364 ENUM_ENT(EM_MIPS, "MIPS R3000"), 1365 ENUM_ENT(EM_S370, "IBM System/370"), 1366 ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"), 1367 ENUM_ENT(EM_PARISC, "HPPA"), 1368 ENUM_ENT(EM_VPP500, "Fujitsu VPP500"), 1369 ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"), 1370 ENUM_ENT(EM_960, "Intel 80960"), 1371 ENUM_ENT(EM_PPC, "PowerPC"), 1372 ENUM_ENT(EM_PPC64, "PowerPC64"), 1373 ENUM_ENT(EM_S390, "IBM S/390"), 1374 ENUM_ENT(EM_SPU, "SPU"), 1375 ENUM_ENT(EM_V800, "NEC V800 series"), 1376 ENUM_ENT(EM_FR20, "Fujistsu FR20"), 1377 ENUM_ENT(EM_RH32, "TRW RH-32"), 1378 ENUM_ENT(EM_RCE, "Motorola RCE"), 1379 ENUM_ENT(EM_ARM, "ARM"), 1380 ENUM_ENT(EM_ALPHA, "EM_ALPHA"), 1381 ENUM_ENT(EM_SH, "Hitachi SH"), 1382 ENUM_ENT(EM_SPARCV9, "Sparc v9"), 1383 ENUM_ENT(EM_TRICORE, "Siemens Tricore"), 1384 ENUM_ENT(EM_ARC, "ARC"), 1385 ENUM_ENT(EM_H8_300, "Hitachi H8/300"), 1386 ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"), 1387 ENUM_ENT(EM_H8S, "Hitachi H8S"), 1388 ENUM_ENT(EM_H8_500, "Hitachi H8/500"), 1389 ENUM_ENT(EM_IA_64, "Intel IA-64"), 1390 ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"), 1391 ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"), 1392 ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"), 1393 ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"), 1394 ENUM_ENT(EM_PCP, "Siemens PCP"), 1395 ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"), 1396 ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"), 1397 ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"), 1398 ENUM_ENT(EM_ME16, "Toyota ME16 processor"), 1399 ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"), 1400 ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"), 1401 ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"), 1402 ENUM_ENT(EM_PDSP, "Sony DSP processor"), 1403 ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"), 1404 ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"), 1405 ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"), 1406 ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"), 1407 ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"), 1408 ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"), 1409 ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"), 1410 ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"), 1411 ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"), 1412 ENUM_ENT(EM_SVX, "Silicon Graphics SVx"), 1413 ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"), 1414 ENUM_ENT(EM_VAX, "Digital VAX"), 1415 ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"), 1416 ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"), 1417 ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"), 1418 ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"), 1419 ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"), 1420 ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"), 1421 ENUM_ENT(EM_PRISM, "Vitesse Prism"), 1422 ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"), 1423 ENUM_ENT(EM_FR30, "Fujitsu FR30"), 1424 ENUM_ENT(EM_D10V, "Mitsubishi D10V"), 1425 ENUM_ENT(EM_D30V, "Mitsubishi D30V"), 1426 ENUM_ENT(EM_V850, "NEC v850"), 1427 ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"), 1428 ENUM_ENT(EM_MN10300, "Matsushita MN10300"), 1429 ENUM_ENT(EM_MN10200, "Matsushita MN10200"), 1430 ENUM_ENT(EM_PJ, "picoJava"), 1431 ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"), 1432 ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"), 1433 ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"), 1434 ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"), 1435 ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"), 1436 ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"), 1437 ENUM_ENT(EM_TPC, "Tenor Network TPC processor"), 1438 ENUM_ENT(EM_SNP1K, "EM_SNP1K"), 1439 ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"), 1440 ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"), 1441 ENUM_ENT(EM_MAX, "MAX Processor"), 1442 ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"), 1443 ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"), 1444 ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"), 1445 ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"), 1446 ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"), 1447 ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"), 1448 ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"), 1449 ENUM_ENT(EM_UNICORE, "Unicore"), 1450 ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"), 1451 ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"), 1452 ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"), 1453 ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"), 1454 ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"), 1455 ENUM_ENT(EM_C166, "Infineon Technologies xc16x"), 1456 ENUM_ENT(EM_M16C, "Renesas M16C"), 1457 ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"), 1458 ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"), 1459 ENUM_ENT(EM_M32C, "Renesas M32C"), 1460 ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"), 1461 ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"), 1462 ENUM_ENT(EM_SHARC, "EM_SHARC"), 1463 ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"), 1464 ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"), 1465 ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"), 1466 ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"), 1467 ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"), 1468 ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"), 1469 ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"), 1470 ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"), 1471 ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"), 1472 ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"), 1473 ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"), 1474 ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"), 1475 ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"), 1476 ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"), 1477 ENUM_ENT(EM_8051, "Intel 8051 and variants"), 1478 ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"), 1479 ENUM_ENT(EM_NDS32, "Andes Technology compact code size embedded RISC processor family"), 1480 ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"), 1481 // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has 1482 // an identical number to EM_ECOG1. 1483 ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"), 1484 ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"), 1485 ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"), 1486 ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"), 1487 ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"), 1488 ENUM_ENT(EM_RX, "Renesas RX"), 1489 ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"), 1490 ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"), 1491 ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"), 1492 ENUM_ENT(EM_CR16, "Xilinx MicroBlaze"), 1493 ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"), 1494 ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"), 1495 ENUM_ENT(EM_L10M, "EM_L10M"), 1496 ENUM_ENT(EM_K10M, "EM_K10M"), 1497 ENUM_ENT(EM_AARCH64, "AArch64"), 1498 ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"), 1499 ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"), 1500 ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"), 1501 ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"), 1502 ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"), 1503 ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"), 1504 ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"), 1505 ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"), 1506 ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"), 1507 ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"), 1508 ENUM_ENT(EM_OPEN8, "EM_OPEN8"), 1509 ENUM_ENT(EM_RL78, "Renesas RL78"), 1510 ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"), 1511 ENUM_ENT(EM_78KOR, "EM_78KOR"), 1512 ENUM_ENT(EM_56800EX, "EM_56800EX"), 1513 ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"), 1514 ENUM_ENT(EM_RISCV, "RISC-V"), 1515 ENUM_ENT(EM_LANAI, "EM_LANAI"), 1516 ENUM_ENT(EM_BPF, "EM_BPF"), 1517 ENUM_ENT(EM_VE, "NEC SX-Aurora Vector Engine"), 1518 }; 1519 1520 static const EnumEntry<unsigned> ElfSymbolBindings[] = { 1521 {"Local", "LOCAL", ELF::STB_LOCAL}, 1522 {"Global", "GLOBAL", ELF::STB_GLOBAL}, 1523 {"Weak", "WEAK", ELF::STB_WEAK}, 1524 {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; 1525 1526 static const EnumEntry<unsigned> ElfSymbolVisibilities[] = { 1527 {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, 1528 {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, 1529 {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, 1530 {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; 1531 1532 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = { 1533 { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL } 1534 }; 1535 1536 static const char *getGroupType(uint32_t Flag) { 1537 if (Flag & ELF::GRP_COMDAT) 1538 return "COMDAT"; 1539 else 1540 return "(unknown)"; 1541 } 1542 1543 static const EnumEntry<unsigned> ElfSectionFlags[] = { 1544 ENUM_ENT(SHF_WRITE, "W"), 1545 ENUM_ENT(SHF_ALLOC, "A"), 1546 ENUM_ENT(SHF_EXECINSTR, "X"), 1547 ENUM_ENT(SHF_MERGE, "M"), 1548 ENUM_ENT(SHF_STRINGS, "S"), 1549 ENUM_ENT(SHF_INFO_LINK, "I"), 1550 ENUM_ENT(SHF_LINK_ORDER, "L"), 1551 ENUM_ENT(SHF_OS_NONCONFORMING, "O"), 1552 ENUM_ENT(SHF_GROUP, "G"), 1553 ENUM_ENT(SHF_TLS, "T"), 1554 ENUM_ENT(SHF_COMPRESSED, "C"), 1555 ENUM_ENT(SHF_EXCLUDE, "E"), 1556 }; 1557 1558 static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = { 1559 ENUM_ENT(XCORE_SHF_CP_SECTION, ""), 1560 ENUM_ENT(XCORE_SHF_DP_SECTION, "") 1561 }; 1562 1563 static const EnumEntry<unsigned> ElfARMSectionFlags[] = { 1564 ENUM_ENT(SHF_ARM_PURECODE, "y") 1565 }; 1566 1567 static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = { 1568 ENUM_ENT(SHF_HEX_GPREL, "") 1569 }; 1570 1571 static const EnumEntry<unsigned> ElfMipsSectionFlags[] = { 1572 ENUM_ENT(SHF_MIPS_NODUPES, ""), 1573 ENUM_ENT(SHF_MIPS_NAMES, ""), 1574 ENUM_ENT(SHF_MIPS_LOCAL, ""), 1575 ENUM_ENT(SHF_MIPS_NOSTRIP, ""), 1576 ENUM_ENT(SHF_MIPS_GPREL, ""), 1577 ENUM_ENT(SHF_MIPS_MERGE, ""), 1578 ENUM_ENT(SHF_MIPS_ADDR, ""), 1579 ENUM_ENT(SHF_MIPS_STRING, "") 1580 }; 1581 1582 static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = { 1583 ENUM_ENT(SHF_X86_64_LARGE, "l") 1584 }; 1585 1586 static std::vector<EnumEntry<unsigned>> 1587 getSectionFlagsForTarget(unsigned EMachine) { 1588 std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags), 1589 std::end(ElfSectionFlags)); 1590 switch (EMachine) { 1591 case EM_ARM: 1592 Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags), 1593 std::end(ElfARMSectionFlags)); 1594 break; 1595 case EM_HEXAGON: 1596 Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags), 1597 std::end(ElfHexagonSectionFlags)); 1598 break; 1599 case EM_MIPS: 1600 Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags), 1601 std::end(ElfMipsSectionFlags)); 1602 break; 1603 case EM_X86_64: 1604 Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags), 1605 std::end(ElfX86_64SectionFlags)); 1606 break; 1607 case EM_XCORE: 1608 Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags), 1609 std::end(ElfXCoreSectionFlags)); 1610 break; 1611 default: 1612 break; 1613 } 1614 return Ret; 1615 } 1616 1617 static std::string getGNUFlags(unsigned EMachine, uint64_t Flags) { 1618 // Here we are trying to build the flags string in the same way as GNU does. 1619 // It is not that straightforward. Imagine we have sh_flags == 0x90000000. 1620 // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000. 1621 // GNU readelf will not print "E" or "Ep" in this case, but will print just 1622 // "p". It only will print "E" when no other processor flag is set. 1623 std::string Str; 1624 bool HasUnknownFlag = false; 1625 bool HasOSFlag = false; 1626 bool HasProcFlag = false; 1627 std::vector<EnumEntry<unsigned>> FlagsList = 1628 getSectionFlagsForTarget(EMachine); 1629 while (Flags) { 1630 // Take the least significant bit as a flag. 1631 uint64_t Flag = Flags & -Flags; 1632 Flags -= Flag; 1633 1634 // Find the flag in the known flags list. 1635 auto I = llvm::find_if(FlagsList, [=](const EnumEntry<unsigned> &E) { 1636 // Flags with empty names are not printed in GNU style output. 1637 return E.Value == Flag && !E.AltName.empty(); 1638 }); 1639 if (I != FlagsList.end()) { 1640 Str += I->AltName; 1641 continue; 1642 } 1643 1644 // If we did not find a matching regular flag, then we deal with an OS 1645 // specific flag, processor specific flag or an unknown flag. 1646 if (Flag & ELF::SHF_MASKOS) { 1647 HasOSFlag = true; 1648 Flags &= ~ELF::SHF_MASKOS; 1649 } else if (Flag & ELF::SHF_MASKPROC) { 1650 HasProcFlag = true; 1651 // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE 1652 // bit if set so that it doesn't also get printed. 1653 Flags &= ~ELF::SHF_MASKPROC; 1654 } else { 1655 HasUnknownFlag = true; 1656 } 1657 } 1658 1659 // "o", "p" and "x" are printed last. 1660 if (HasOSFlag) 1661 Str += "o"; 1662 if (HasProcFlag) 1663 Str += "p"; 1664 if (HasUnknownFlag) 1665 Str += "x"; 1666 return Str; 1667 } 1668 1669 static const char *getElfSegmentType(unsigned Arch, unsigned Type) { 1670 // Check potentially overlapped processor-specific 1671 // program header type. 1672 switch (Arch) { 1673 case ELF::EM_ARM: 1674 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX); } 1675 break; 1676 case ELF::EM_MIPS: 1677 case ELF::EM_MIPS_RS3_LE: 1678 switch (Type) { 1679 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO); 1680 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC); 1681 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS); 1682 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS); 1683 } 1684 break; 1685 } 1686 1687 switch (Type) { 1688 LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL ); 1689 LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD ); 1690 LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC); 1691 LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP ); 1692 LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE ); 1693 LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB ); 1694 LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR ); 1695 LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS ); 1696 1697 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME); 1698 LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND); 1699 1700 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK); 1701 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO); 1702 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_PROPERTY); 1703 1704 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE); 1705 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED); 1706 LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA); 1707 1708 default: 1709 return ""; 1710 } 1711 } 1712 1713 static std::string getElfPtType(unsigned Arch, unsigned Type) { 1714 switch (Type) { 1715 LLVM_READOBJ_PHDR_ENUM(ELF, PT_NULL) 1716 LLVM_READOBJ_PHDR_ENUM(ELF, PT_LOAD) 1717 LLVM_READOBJ_PHDR_ENUM(ELF, PT_DYNAMIC) 1718 LLVM_READOBJ_PHDR_ENUM(ELF, PT_INTERP) 1719 LLVM_READOBJ_PHDR_ENUM(ELF, PT_NOTE) 1720 LLVM_READOBJ_PHDR_ENUM(ELF, PT_SHLIB) 1721 LLVM_READOBJ_PHDR_ENUM(ELF, PT_PHDR) 1722 LLVM_READOBJ_PHDR_ENUM(ELF, PT_TLS) 1723 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_EH_FRAME) 1724 LLVM_READOBJ_PHDR_ENUM(ELF, PT_SUNW_UNWIND) 1725 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK) 1726 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO) 1727 LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_PROPERTY) 1728 default: 1729 // All machine specific PT_* types 1730 switch (Arch) { 1731 case ELF::EM_ARM: 1732 if (Type == ELF::PT_ARM_EXIDX) 1733 return "EXIDX"; 1734 break; 1735 case ELF::EM_MIPS: 1736 case ELF::EM_MIPS_RS3_LE: 1737 switch (Type) { 1738 case PT_MIPS_REGINFO: 1739 return "REGINFO"; 1740 case PT_MIPS_RTPROC: 1741 return "RTPROC"; 1742 case PT_MIPS_OPTIONS: 1743 return "OPTIONS"; 1744 case PT_MIPS_ABIFLAGS: 1745 return "ABIFLAGS"; 1746 } 1747 break; 1748 } 1749 } 1750 return std::string("<unknown>: ") + to_string(format_hex(Type, 1)); 1751 } 1752 1753 static const EnumEntry<unsigned> ElfSegmentFlags[] = { 1754 LLVM_READOBJ_ENUM_ENT(ELF, PF_X), 1755 LLVM_READOBJ_ENUM_ENT(ELF, PF_W), 1756 LLVM_READOBJ_ENUM_ENT(ELF, PF_R) 1757 }; 1758 1759 static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = { 1760 ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"), 1761 ENUM_ENT(EF_MIPS_PIC, "pic"), 1762 ENUM_ENT(EF_MIPS_CPIC, "cpic"), 1763 ENUM_ENT(EF_MIPS_ABI2, "abi2"), 1764 ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"), 1765 ENUM_ENT(EF_MIPS_FP64, "fp64"), 1766 ENUM_ENT(EF_MIPS_NAN2008, "nan2008"), 1767 ENUM_ENT(EF_MIPS_ABI_O32, "o32"), 1768 ENUM_ENT(EF_MIPS_ABI_O64, "o64"), 1769 ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"), 1770 ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"), 1771 ENUM_ENT(EF_MIPS_MACH_3900, "3900"), 1772 ENUM_ENT(EF_MIPS_MACH_4010, "4010"), 1773 ENUM_ENT(EF_MIPS_MACH_4100, "4100"), 1774 ENUM_ENT(EF_MIPS_MACH_4650, "4650"), 1775 ENUM_ENT(EF_MIPS_MACH_4120, "4120"), 1776 ENUM_ENT(EF_MIPS_MACH_4111, "4111"), 1777 ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"), 1778 ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"), 1779 ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"), 1780 ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"), 1781 ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"), 1782 ENUM_ENT(EF_MIPS_MACH_5400, "5400"), 1783 ENUM_ENT(EF_MIPS_MACH_5900, "5900"), 1784 ENUM_ENT(EF_MIPS_MACH_5500, "5500"), 1785 ENUM_ENT(EF_MIPS_MACH_9000, "9000"), 1786 ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"), 1787 ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"), 1788 ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"), 1789 ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"), 1790 ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"), 1791 ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"), 1792 ENUM_ENT(EF_MIPS_ARCH_1, "mips1"), 1793 ENUM_ENT(EF_MIPS_ARCH_2, "mips2"), 1794 ENUM_ENT(EF_MIPS_ARCH_3, "mips3"), 1795 ENUM_ENT(EF_MIPS_ARCH_4, "mips4"), 1796 ENUM_ENT(EF_MIPS_ARCH_5, "mips5"), 1797 ENUM_ENT(EF_MIPS_ARCH_32, "mips32"), 1798 ENUM_ENT(EF_MIPS_ARCH_64, "mips64"), 1799 ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"), 1800 ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"), 1801 ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"), 1802 ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6") 1803 }; 1804 1805 static const EnumEntry<unsigned> ElfHeaderAMDGPUFlags[] = { 1806 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE), 1807 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600), 1808 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630), 1809 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880), 1810 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670), 1811 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710), 1812 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730), 1813 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770), 1814 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR), 1815 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS), 1816 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER), 1817 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD), 1818 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO), 1819 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS), 1820 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS), 1821 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN), 1822 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS), 1823 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600), 1824 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601), 1825 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700), 1826 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701), 1827 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702), 1828 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703), 1829 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704), 1830 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801), 1831 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802), 1832 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803), 1833 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810), 1834 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900), 1835 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902), 1836 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904), 1837 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906), 1838 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908), 1839 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909), 1840 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010), 1841 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011), 1842 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012), 1843 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030), 1844 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_XNACK), 1845 LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_SRAM_ECC) 1846 }; 1847 1848 static const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = { 1849 ENUM_ENT(EF_RISCV_RVC, "RVC"), 1850 ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"), 1851 ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"), 1852 ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"), 1853 ENUM_ENT(EF_RISCV_RVE, "RVE") 1854 }; 1855 1856 static const EnumEntry<unsigned> ElfSymOtherFlags[] = { 1857 LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL), 1858 LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN), 1859 LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED) 1860 }; 1861 1862 static const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = { 1863 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), 1864 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), 1865 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC), 1866 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS) 1867 }; 1868 1869 static const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = { 1870 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), 1871 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), 1872 LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16) 1873 }; 1874 1875 static const char *getElfMipsOptionsOdkType(unsigned Odk) { 1876 switch (Odk) { 1877 LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL); 1878 LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO); 1879 LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS); 1880 LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD); 1881 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH); 1882 LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL); 1883 LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS); 1884 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND); 1885 LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR); 1886 LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP); 1887 LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT); 1888 LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE); 1889 default: 1890 return "Unknown"; 1891 } 1892 } 1893 1894 template <typename ELFT> 1895 std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *> 1896 ELFDumper<ELFT>::findDynamic(const ELFFile<ELFT> *Obj) { 1897 // Try to locate the PT_DYNAMIC header. 1898 const Elf_Phdr *DynamicPhdr = nullptr; 1899 if (Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers()) { 1900 for (const Elf_Phdr &Phdr : *PhdrsOrErr) { 1901 if (Phdr.p_type != ELF::PT_DYNAMIC) 1902 continue; 1903 DynamicPhdr = &Phdr; 1904 break; 1905 } 1906 } else { 1907 this->reportUniqueWarning(createError( 1908 "unable to read program headers to locate the PT_DYNAMIC segment: " + 1909 toString(PhdrsOrErr.takeError()))); 1910 } 1911 1912 // Try to locate the .dynamic section in the sections header table. 1913 const Elf_Shdr *DynamicSec = nullptr; 1914 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 1915 if (Sec.sh_type != ELF::SHT_DYNAMIC) 1916 continue; 1917 DynamicSec = &Sec; 1918 break; 1919 } 1920 1921 if (DynamicPhdr && DynamicPhdr->p_offset + DynamicPhdr->p_filesz > 1922 ObjF->getMemoryBufferRef().getBufferSize()) { 1923 reportWarning( 1924 createError( 1925 "PT_DYNAMIC segment offset + size exceeds the size of the file"), 1926 ObjF->getFileName()); 1927 // Don't use the broken dynamic header. 1928 DynamicPhdr = nullptr; 1929 } 1930 1931 if (DynamicPhdr && DynamicSec) { 1932 StringRef Name = 1933 unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DynamicSec)); 1934 if (DynamicSec->sh_addr + DynamicSec->sh_size > 1935 DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz || 1936 DynamicSec->sh_addr < DynamicPhdr->p_vaddr) 1937 reportWarning(createError("The SHT_DYNAMIC section '" + Name + 1938 "' is not contained within the " 1939 "PT_DYNAMIC segment"), 1940 ObjF->getFileName()); 1941 1942 if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr) 1943 reportWarning(createError("The SHT_DYNAMIC section '" + Name + 1944 "' is not at the start of " 1945 "PT_DYNAMIC segment"), 1946 ObjF->getFileName()); 1947 } 1948 1949 return std::make_pair(DynamicPhdr, DynamicSec); 1950 } 1951 1952 template <typename ELFT> 1953 void ELFDumper<ELFT>::loadDynamicTable(const ELFFile<ELFT> *Obj) { 1954 const Elf_Phdr *DynamicPhdr; 1955 const Elf_Shdr *DynamicSec; 1956 std::tie(DynamicPhdr, DynamicSec) = findDynamic(Obj); 1957 if (!DynamicPhdr && !DynamicSec) 1958 return; 1959 1960 DynRegionInfo FromPhdr(ObjF->getFileName()); 1961 bool IsPhdrTableValid = false; 1962 if (DynamicPhdr) { 1963 FromPhdr = createDRIFrom(DynamicPhdr, sizeof(Elf_Dyn)); 1964 FromPhdr.SizePrintName = "PT_DYNAMIC size"; 1965 FromPhdr.EntSizePrintName = ""; 1966 1967 IsPhdrTableValid = !FromPhdr.getAsArrayRef<Elf_Dyn>().empty(); 1968 } 1969 1970 // Locate the dynamic table described in a section header. 1971 // Ignore sh_entsize and use the expected value for entry size explicitly. 1972 // This allows us to dump dynamic sections with a broken sh_entsize 1973 // field. 1974 DynRegionInfo FromSec(ObjF->getFileName()); 1975 bool IsSecTableValid = false; 1976 if (DynamicSec) { 1977 FromSec = 1978 checkDRI({ObjF->getELFFile()->base() + DynamicSec->sh_offset, 1979 DynamicSec->sh_size, sizeof(Elf_Dyn), ObjF->getFileName()}); 1980 FromSec.Context = describe(*DynamicSec); 1981 FromSec.EntSizePrintName = ""; 1982 1983 IsSecTableValid = !FromSec.getAsArrayRef<Elf_Dyn>().empty(); 1984 } 1985 1986 // When we only have information from one of the SHT_DYNAMIC section header or 1987 // PT_DYNAMIC program header, just use that. 1988 if (!DynamicPhdr || !DynamicSec) { 1989 if ((DynamicPhdr && IsPhdrTableValid) || (DynamicSec && IsSecTableValid)) { 1990 DynamicTable = DynamicPhdr ? FromPhdr : FromSec; 1991 parseDynamicTable(Obj); 1992 } else { 1993 reportWarning(createError("no valid dynamic table was found"), 1994 ObjF->getFileName()); 1995 } 1996 return; 1997 } 1998 1999 // At this point we have tables found from the section header and from the 2000 // dynamic segment. Usually they match, but we have to do sanity checks to 2001 // verify that. 2002 2003 if (FromPhdr.Addr != FromSec.Addr) 2004 reportWarning(createError("SHT_DYNAMIC section header and PT_DYNAMIC " 2005 "program header disagree about " 2006 "the location of the dynamic table"), 2007 ObjF->getFileName()); 2008 2009 if (!IsPhdrTableValid && !IsSecTableValid) { 2010 reportWarning(createError("no valid dynamic table was found"), 2011 ObjF->getFileName()); 2012 return; 2013 } 2014 2015 // Information in the PT_DYNAMIC program header has priority over the information 2016 // in a section header. 2017 if (IsPhdrTableValid) { 2018 if (!IsSecTableValid) 2019 reportWarning( 2020 createError( 2021 "SHT_DYNAMIC dynamic table is invalid: PT_DYNAMIC will be used"), 2022 ObjF->getFileName()); 2023 DynamicTable = FromPhdr; 2024 } else { 2025 reportWarning( 2026 createError( 2027 "PT_DYNAMIC dynamic table is invalid: SHT_DYNAMIC will be used"), 2028 ObjF->getFileName()); 2029 DynamicTable = FromSec; 2030 } 2031 2032 parseDynamicTable(Obj); 2033 } 2034 2035 template <typename ELFT> 2036 ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, 2037 ScopedPrinter &Writer) 2038 : ObjDumper(Writer), ObjF(ObjF), DynRelRegion(ObjF->getFileName()), 2039 DynRelaRegion(ObjF->getFileName()), DynRelrRegion(ObjF->getFileName()), 2040 DynPLTRelRegion(ObjF->getFileName()), DynamicTable(ObjF->getFileName()) { 2041 // Dumper reports all non-critical errors as warnings. 2042 // It does not print the same warning more than once. 2043 WarningHandler = [this](const Twine &Msg) { 2044 if (Warnings.insert(Msg.str()).second) 2045 reportWarning(createError(Msg), this->ObjF->getFileName()); 2046 return Error::success(); 2047 }; 2048 2049 if (opts::Output == opts::GNU) 2050 ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this)); 2051 else 2052 ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this)); 2053 2054 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 2055 typename ELFT::ShdrRange Sections = cantFail(Obj->sections()); 2056 for (const Elf_Shdr &Sec : Sections) { 2057 switch (Sec.sh_type) { 2058 case ELF::SHT_SYMTAB: 2059 if (!DotSymtabSec) 2060 DotSymtabSec = &Sec; 2061 break; 2062 case ELF::SHT_DYNSYM: 2063 if (!DotDynsymSec) 2064 DotDynsymSec = &Sec; 2065 2066 if (!DynSymRegion) { 2067 DynSymRegion = createDRIFrom(&Sec); 2068 DynSymRegion->Context = describe(Sec); 2069 2070 if (Expected<StringRef> E = Obj->getStringTableForSymtab(Sec)) 2071 DynamicStringTable = *E; 2072 else 2073 reportWarning(E.takeError(), ObjF->getFileName()); 2074 } 2075 break; 2076 case ELF::SHT_SYMTAB_SHNDX: 2077 ShndxTable = unwrapOrError(ObjF->getFileName(), Obj->getSHNDXTable(Sec)); 2078 break; 2079 case ELF::SHT_GNU_versym: 2080 if (!SymbolVersionSection) 2081 SymbolVersionSection = &Sec; 2082 break; 2083 case ELF::SHT_GNU_verdef: 2084 if (!SymbolVersionDefSection) 2085 SymbolVersionDefSection = &Sec; 2086 break; 2087 case ELF::SHT_GNU_verneed: 2088 if (!SymbolVersionNeedSection) 2089 SymbolVersionNeedSection = &Sec; 2090 break; 2091 case ELF::SHT_LLVM_CALL_GRAPH_PROFILE: 2092 if (!DotCGProfileSec) 2093 DotCGProfileSec = &Sec; 2094 break; 2095 case ELF::SHT_LLVM_ADDRSIG: 2096 if (!DotAddrsigSec) 2097 DotAddrsigSec = &Sec; 2098 break; 2099 } 2100 } 2101 2102 loadDynamicTable(Obj); 2103 } 2104 2105 template <typename ELFT> 2106 void ELFDumper<ELFT>::parseDynamicTable(const ELFFile<ELFT> *Obj) { 2107 auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * { 2108 auto MappedAddrOrError = ObjF->getELFFile()->toMappedAddr(VAddr); 2109 if (!MappedAddrOrError) { 2110 Error Err = 2111 createError("Unable to parse DT_" + Obj->getDynamicTagAsString(Tag) + 2112 ": " + llvm::toString(MappedAddrOrError.takeError())); 2113 2114 reportWarning(std::move(Err), ObjF->getFileName()); 2115 return nullptr; 2116 } 2117 return MappedAddrOrError.get(); 2118 }; 2119 2120 uint64_t SONameOffset = 0; 2121 const char *StringTableBegin = nullptr; 2122 uint64_t StringTableSize = 0; 2123 Optional<DynRegionInfo> DynSymFromTable; 2124 for (const Elf_Dyn &Dyn : dynamic_table()) { 2125 switch (Dyn.d_tag) { 2126 case ELF::DT_HASH: 2127 HashTable = reinterpret_cast<const Elf_Hash *>( 2128 toMappedAddr(Dyn.getTag(), Dyn.getPtr())); 2129 break; 2130 case ELF::DT_GNU_HASH: 2131 GnuHashTable = reinterpret_cast<const Elf_GnuHash *>( 2132 toMappedAddr(Dyn.getTag(), Dyn.getPtr())); 2133 break; 2134 case ELF::DT_STRTAB: 2135 StringTableBegin = reinterpret_cast<const char *>( 2136 toMappedAddr(Dyn.getTag(), Dyn.getPtr())); 2137 break; 2138 case ELF::DT_STRSZ: 2139 StringTableSize = Dyn.getVal(); 2140 break; 2141 case ELF::DT_SYMTAB: { 2142 // If we can't map the DT_SYMTAB value to an address (e.g. when there are 2143 // no program headers), we ignore its value. 2144 if (const uint8_t *VA = toMappedAddr(Dyn.getTag(), Dyn.getPtr())) { 2145 DynSymFromTable.emplace(ObjF->getFileName()); 2146 DynSymFromTable->Addr = VA; 2147 DynSymFromTable->EntSize = sizeof(Elf_Sym); 2148 DynSymFromTable->EntSizePrintName = ""; 2149 } 2150 break; 2151 } 2152 case ELF::DT_SYMENT: { 2153 uint64_t Val = Dyn.getVal(); 2154 if (Val != sizeof(Elf_Sym)) 2155 reportWarning(createError("DT_SYMENT value of 0x" + 2156 Twine::utohexstr(Val) + 2157 " is not the size of a symbol (0x" + 2158 Twine::utohexstr(sizeof(Elf_Sym)) + ")"), 2159 ObjF->getFileName()); 2160 break; 2161 } 2162 case ELF::DT_RELA: 2163 DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); 2164 break; 2165 case ELF::DT_RELASZ: 2166 DynRelaRegion.Size = Dyn.getVal(); 2167 DynRelaRegion.SizePrintName = "DT_RELASZ value"; 2168 break; 2169 case ELF::DT_RELAENT: 2170 DynRelaRegion.EntSize = Dyn.getVal(); 2171 DynRelaRegion.EntSizePrintName = "DT_RELAENT value"; 2172 break; 2173 case ELF::DT_SONAME: 2174 SONameOffset = Dyn.getVal(); 2175 break; 2176 case ELF::DT_REL: 2177 DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); 2178 break; 2179 case ELF::DT_RELSZ: 2180 DynRelRegion.Size = Dyn.getVal(); 2181 DynRelRegion.SizePrintName = "DT_RELSZ value"; 2182 break; 2183 case ELF::DT_RELENT: 2184 DynRelRegion.EntSize = Dyn.getVal(); 2185 DynRelRegion.EntSizePrintName = "DT_RELENT value"; 2186 break; 2187 case ELF::DT_RELR: 2188 case ELF::DT_ANDROID_RELR: 2189 DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); 2190 break; 2191 case ELF::DT_RELRSZ: 2192 case ELF::DT_ANDROID_RELRSZ: 2193 DynRelrRegion.Size = Dyn.getVal(); 2194 DynRelrRegion.SizePrintName = Dyn.d_tag == ELF::DT_RELRSZ 2195 ? "DT_RELRSZ value" 2196 : "DT_ANDROID_RELRSZ value"; 2197 break; 2198 case ELF::DT_RELRENT: 2199 case ELF::DT_ANDROID_RELRENT: 2200 DynRelrRegion.EntSize = Dyn.getVal(); 2201 DynRelrRegion.EntSizePrintName = Dyn.d_tag == ELF::DT_RELRENT 2202 ? "DT_RELRENT value" 2203 : "DT_ANDROID_RELRENT value"; 2204 break; 2205 case ELF::DT_PLTREL: 2206 if (Dyn.getVal() == DT_REL) 2207 DynPLTRelRegion.EntSize = sizeof(Elf_Rel); 2208 else if (Dyn.getVal() == DT_RELA) 2209 DynPLTRelRegion.EntSize = sizeof(Elf_Rela); 2210 else 2211 reportError(createError(Twine("unknown DT_PLTREL value of ") + 2212 Twine((uint64_t)Dyn.getVal())), 2213 ObjF->getFileName()); 2214 DynPLTRelRegion.EntSizePrintName = ""; 2215 break; 2216 case ELF::DT_JMPREL: 2217 DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); 2218 break; 2219 case ELF::DT_PLTRELSZ: 2220 DynPLTRelRegion.Size = Dyn.getVal(); 2221 DynPLTRelRegion.SizePrintName = "DT_PLTRELSZ value"; 2222 break; 2223 } 2224 } 2225 2226 if (StringTableBegin) { 2227 const uint64_t FileSize = ObjF->getELFFile()->getBufSize(); 2228 const uint64_t Offset = 2229 (const uint8_t *)StringTableBegin - ObjF->getELFFile()->base(); 2230 if (StringTableSize > FileSize - Offset) 2231 reportUniqueWarning(createError( 2232 "the dynamic string table at 0x" + Twine::utohexstr(Offset) + 2233 " goes past the end of the file (0x" + Twine::utohexstr(FileSize) + 2234 ") with DT_STRSZ = 0x" + Twine::utohexstr(StringTableSize))); 2235 else 2236 DynamicStringTable = StringRef(StringTableBegin, StringTableSize); 2237 } 2238 2239 SOName = getDynamicString(SONameOffset); 2240 2241 if (DynSymRegion) { 2242 // Often we find the information about the dynamic symbol table 2243 // location in the SHT_DYNSYM section header. However, the value in 2244 // DT_SYMTAB has priority, because it is used by dynamic loaders to 2245 // locate .dynsym at runtime. The location we find in the section header 2246 // and the location we find here should match. 2247 if (DynSymFromTable && DynSymFromTable->Addr != DynSymRegion->Addr) 2248 reportUniqueWarning( 2249 createError("SHT_DYNSYM section header and DT_SYMTAB disagree about " 2250 "the location of the dynamic symbol table")); 2251 2252 // According to the ELF gABI: "The number of symbol table entries should 2253 // equal nchain". Check to see if the DT_HASH hash table nchain value 2254 // conflicts with the number of symbols in the dynamic symbol table 2255 // according to the section header. 2256 if (HashTable) { 2257 if (DynSymRegion->EntSize == 0) 2258 reportUniqueWarning( 2259 createError("SHT_DYNSYM section has sh_entsize == 0")); 2260 else if (HashTable->nchain != DynSymRegion->Size / DynSymRegion->EntSize) 2261 reportUniqueWarning(createError( 2262 "hash table nchain (" + Twine(HashTable->nchain) + 2263 ") differs from symbol count derived from SHT_DYNSYM section " 2264 "header (" + 2265 Twine(DynSymRegion->Size / DynSymRegion->EntSize) + ")")); 2266 } 2267 } 2268 2269 // Delay the creation of the actual dynamic symbol table until now, so that 2270 // checks can always be made against the section header-based properties, 2271 // without worrying about tag order. 2272 if (DynSymFromTable) { 2273 if (!DynSymRegion) { 2274 DynSymRegion = DynSymFromTable; 2275 } else { 2276 DynSymRegion->Addr = DynSymFromTable->Addr; 2277 DynSymRegion->EntSize = DynSymFromTable->EntSize; 2278 DynSymRegion->EntSizePrintName = DynSymFromTable->EntSizePrintName; 2279 } 2280 } 2281 2282 // Derive the dynamic symbol table size from the DT_HASH hash table, if 2283 // present. 2284 if (HashTable && DynSymRegion) 2285 DynSymRegion->Size = HashTable->nchain * DynSymRegion->EntSize; 2286 } 2287 2288 template <typename ELFT> 2289 typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const { 2290 return DynRelRegion.getAsArrayRef<Elf_Rel>(); 2291 } 2292 2293 template <typename ELFT> 2294 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const { 2295 return DynRelaRegion.getAsArrayRef<Elf_Rela>(); 2296 } 2297 2298 template <typename ELFT> 2299 typename ELFDumper<ELFT>::Elf_Relr_Range ELFDumper<ELFT>::dyn_relrs() const { 2300 return DynRelrRegion.getAsArrayRef<Elf_Relr>(); 2301 } 2302 2303 template <class ELFT> void ELFDumper<ELFT>::printFileHeaders() { 2304 ELFDumperStyle->printFileHeaders(ObjF->getELFFile()); 2305 } 2306 2307 template <class ELFT> void ELFDumper<ELFT>::printSectionHeaders() { 2308 ELFDumperStyle->printSectionHeaders(ObjF->getELFFile()); 2309 } 2310 2311 template <class ELFT> void ELFDumper<ELFT>::printRelocations() { 2312 ELFDumperStyle->printRelocations(ObjF->getELFFile()); 2313 } 2314 2315 template <class ELFT> 2316 void ELFDumper<ELFT>::printProgramHeaders( 2317 bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { 2318 ELFDumperStyle->printProgramHeaders(ObjF->getELFFile(), PrintProgramHeaders, 2319 PrintSectionMapping); 2320 } 2321 2322 template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() { 2323 // Dump version symbol section. 2324 ELFDumperStyle->printVersionSymbolSection(ObjF->getELFFile(), 2325 SymbolVersionSection); 2326 2327 // Dump version definition section. 2328 ELFDumperStyle->printVersionDefinitionSection(ObjF->getELFFile(), 2329 SymbolVersionDefSection); 2330 2331 // Dump version dependency section. 2332 ELFDumperStyle->printVersionDependencySection(ObjF->getELFFile(), 2333 SymbolVersionNeedSection); 2334 } 2335 2336 template <class ELFT> void ELFDumper<ELFT>::printDependentLibs() { 2337 ELFDumperStyle->printDependentLibs(ObjF->getELFFile()); 2338 } 2339 2340 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() { 2341 ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile()); 2342 } 2343 2344 template <class ELFT> 2345 void ELFDumper<ELFT>::printSymbols(bool PrintSymbols, 2346 bool PrintDynamicSymbols) { 2347 ELFDumperStyle->printSymbols(ObjF->getELFFile(), PrintSymbols, 2348 PrintDynamicSymbols); 2349 } 2350 2351 template <class ELFT> void ELFDumper<ELFT>::printHashSymbols() { 2352 ELFDumperStyle->printHashSymbols(ObjF->getELFFile()); 2353 } 2354 2355 template <class ELFT> void ELFDumper<ELFT>::printHashHistograms() { 2356 ELFDumperStyle->printHashHistograms(ObjF->getELFFile()); 2357 } 2358 2359 template <class ELFT> void ELFDumper<ELFT>::printCGProfile() { 2360 ELFDumperStyle->printCGProfile(ObjF->getELFFile()); 2361 } 2362 2363 template <class ELFT> void ELFDumper<ELFT>::printNotes() { 2364 ELFDumperStyle->printNotes(ObjF->getELFFile()); 2365 } 2366 2367 template <class ELFT> void ELFDumper<ELFT>::printELFLinkerOptions() { 2368 ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile()); 2369 } 2370 2371 template <class ELFT> void ELFDumper<ELFT>::printStackSizes() { 2372 ELFDumperStyle->printStackSizes(ObjF); 2373 } 2374 2375 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ 2376 { #enum, prefix##_##enum } 2377 2378 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = { 2379 LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), 2380 LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), 2381 LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), 2382 LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), 2383 LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) 2384 }; 2385 2386 static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = { 2387 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), 2388 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), 2389 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), 2390 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), 2391 LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), 2392 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), 2393 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), 2394 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), 2395 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), 2396 LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), 2397 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), 2398 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), 2399 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), 2400 LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), 2401 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), 2402 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), 2403 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND), 2404 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), 2405 LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), 2406 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), 2407 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), 2408 LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), 2409 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), 2410 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), 2411 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), 2412 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON), 2413 LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE), 2414 }; 2415 2416 static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = { 2417 LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), 2418 LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), 2419 LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), 2420 LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), 2421 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), 2422 LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), 2423 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), 2424 LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), 2425 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), 2426 LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), 2427 LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), 2428 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), 2429 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), 2430 LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), 2431 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), 2432 LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) 2433 }; 2434 2435 #undef LLVM_READOBJ_DT_FLAG_ENT 2436 2437 template <typename T, typename TFlag> 2438 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) { 2439 using FlagEntry = EnumEntry<TFlag>; 2440 using FlagVector = SmallVector<FlagEntry, 10>; 2441 FlagVector SetFlags; 2442 2443 for (const auto &Flag : Flags) { 2444 if (Flag.Value == 0) 2445 continue; 2446 2447 if ((Value & Flag.Value) == Flag.Value) 2448 SetFlags.push_back(Flag); 2449 } 2450 2451 for (const auto &Flag : SetFlags) { 2452 OS << Flag.Name << " "; 2453 } 2454 } 2455 2456 template <class ELFT> 2457 const typename ELFT::Shdr * 2458 ELFDumper<ELFT>::findSectionByName(StringRef Name) const { 2459 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 2460 for (const Elf_Shdr &Shdr : cantFail(Obj->sections())) { 2461 if (Expected<StringRef> NameOrErr = Obj->getSectionName(&Shdr)) { 2462 if (*NameOrErr == Name) 2463 return &Shdr; 2464 } else { 2465 reportUniqueWarning(createError("unable to read the name of " + 2466 describe(Shdr) + ": " + 2467 toString(NameOrErr.takeError()))); 2468 } 2469 } 2470 return nullptr; 2471 } 2472 2473 template <class ELFT> 2474 std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type, 2475 uint64_t Value) const { 2476 auto FormatHexValue = [](uint64_t V) { 2477 std::string Str; 2478 raw_string_ostream OS(Str); 2479 const char *ConvChar = 2480 (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64; 2481 OS << format(ConvChar, V); 2482 return OS.str(); 2483 }; 2484 2485 auto FormatFlags = [](uint64_t V, 2486 llvm::ArrayRef<llvm::EnumEntry<unsigned int>> Array) { 2487 std::string Str; 2488 raw_string_ostream OS(Str); 2489 printFlags(V, Array, OS); 2490 return OS.str(); 2491 }; 2492 2493 // Handle custom printing of architecture specific tags 2494 switch (ObjF->getELFFile()->getHeader()->e_machine) { 2495 case EM_AARCH64: 2496 switch (Type) { 2497 case DT_AARCH64_BTI_PLT: 2498 case DT_AARCH64_PAC_PLT: 2499 return std::to_string(Value); 2500 default: 2501 break; 2502 } 2503 break; 2504 case EM_HEXAGON: 2505 switch (Type) { 2506 case DT_HEXAGON_VER: 2507 return std::to_string(Value); 2508 case DT_HEXAGON_SYMSZ: 2509 case DT_HEXAGON_PLT: 2510 return FormatHexValue(Value); 2511 default: 2512 break; 2513 } 2514 break; 2515 case EM_MIPS: 2516 switch (Type) { 2517 case DT_MIPS_RLD_VERSION: 2518 case DT_MIPS_LOCAL_GOTNO: 2519 case DT_MIPS_SYMTABNO: 2520 case DT_MIPS_UNREFEXTNO: 2521 return std::to_string(Value); 2522 case DT_MIPS_TIME_STAMP: 2523 case DT_MIPS_ICHECKSUM: 2524 case DT_MIPS_IVERSION: 2525 case DT_MIPS_BASE_ADDRESS: 2526 case DT_MIPS_MSYM: 2527 case DT_MIPS_CONFLICT: 2528 case DT_MIPS_LIBLIST: 2529 case DT_MIPS_CONFLICTNO: 2530 case DT_MIPS_LIBLISTNO: 2531 case DT_MIPS_GOTSYM: 2532 case DT_MIPS_HIPAGENO: 2533 case DT_MIPS_RLD_MAP: 2534 case DT_MIPS_DELTA_CLASS: 2535 case DT_MIPS_DELTA_CLASS_NO: 2536 case DT_MIPS_DELTA_INSTANCE: 2537 case DT_MIPS_DELTA_RELOC: 2538 case DT_MIPS_DELTA_RELOC_NO: 2539 case DT_MIPS_DELTA_SYM: 2540 case DT_MIPS_DELTA_SYM_NO: 2541 case DT_MIPS_DELTA_CLASSSYM: 2542 case DT_MIPS_DELTA_CLASSSYM_NO: 2543 case DT_MIPS_CXX_FLAGS: 2544 case DT_MIPS_PIXIE_INIT: 2545 case DT_MIPS_SYMBOL_LIB: 2546 case DT_MIPS_LOCALPAGE_GOTIDX: 2547 case DT_MIPS_LOCAL_GOTIDX: 2548 case DT_MIPS_HIDDEN_GOTIDX: 2549 case DT_MIPS_PROTECTED_GOTIDX: 2550 case DT_MIPS_OPTIONS: 2551 case DT_MIPS_INTERFACE: 2552 case DT_MIPS_DYNSTR_ALIGN: 2553 case DT_MIPS_INTERFACE_SIZE: 2554 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: 2555 case DT_MIPS_PERF_SUFFIX: 2556 case DT_MIPS_COMPACT_SIZE: 2557 case DT_MIPS_GP_VALUE: 2558 case DT_MIPS_AUX_DYNAMIC: 2559 case DT_MIPS_PLTGOT: 2560 case DT_MIPS_RWPLT: 2561 case DT_MIPS_RLD_MAP_REL: 2562 return FormatHexValue(Value); 2563 case DT_MIPS_FLAGS: 2564 return FormatFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags)); 2565 default: 2566 break; 2567 } 2568 break; 2569 default: 2570 break; 2571 } 2572 2573 switch (Type) { 2574 case DT_PLTREL: 2575 if (Value == DT_REL) 2576 return "REL"; 2577 if (Value == DT_RELA) 2578 return "RELA"; 2579 LLVM_FALLTHROUGH; 2580 case DT_PLTGOT: 2581 case DT_HASH: 2582 case DT_STRTAB: 2583 case DT_SYMTAB: 2584 case DT_RELA: 2585 case DT_INIT: 2586 case DT_FINI: 2587 case DT_REL: 2588 case DT_JMPREL: 2589 case DT_INIT_ARRAY: 2590 case DT_FINI_ARRAY: 2591 case DT_PREINIT_ARRAY: 2592 case DT_DEBUG: 2593 case DT_VERDEF: 2594 case DT_VERNEED: 2595 case DT_VERSYM: 2596 case DT_GNU_HASH: 2597 case DT_NULL: 2598 return FormatHexValue(Value); 2599 case DT_RELACOUNT: 2600 case DT_RELCOUNT: 2601 case DT_VERDEFNUM: 2602 case DT_VERNEEDNUM: 2603 return std::to_string(Value); 2604 case DT_PLTRELSZ: 2605 case DT_RELASZ: 2606 case DT_RELAENT: 2607 case DT_STRSZ: 2608 case DT_SYMENT: 2609 case DT_RELSZ: 2610 case DT_RELENT: 2611 case DT_INIT_ARRAYSZ: 2612 case DT_FINI_ARRAYSZ: 2613 case DT_PREINIT_ARRAYSZ: 2614 case DT_ANDROID_RELSZ: 2615 case DT_ANDROID_RELASZ: 2616 return std::to_string(Value) + " (bytes)"; 2617 case DT_NEEDED: 2618 case DT_SONAME: 2619 case DT_AUXILIARY: 2620 case DT_USED: 2621 case DT_FILTER: 2622 case DT_RPATH: 2623 case DT_RUNPATH: { 2624 const std::map<uint64_t, const char *> TagNames = { 2625 {DT_NEEDED, "Shared library"}, {DT_SONAME, "Library soname"}, 2626 {DT_AUXILIARY, "Auxiliary library"}, {DT_USED, "Not needed object"}, 2627 {DT_FILTER, "Filter library"}, {DT_RPATH, "Library rpath"}, 2628 {DT_RUNPATH, "Library runpath"}, 2629 }; 2630 2631 return (Twine(TagNames.at(Type)) + ": [" + getDynamicString(Value) + "]") 2632 .str(); 2633 } 2634 case DT_FLAGS: 2635 return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags)); 2636 case DT_FLAGS_1: 2637 return FormatFlags(Value, makeArrayRef(ElfDynamicDTFlags1)); 2638 default: 2639 return FormatHexValue(Value); 2640 } 2641 } 2642 2643 template <class ELFT> 2644 StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const { 2645 if (DynamicStringTable.empty() && !DynamicStringTable.data()) { 2646 reportUniqueWarning(createError("string table was not found")); 2647 return "<?>"; 2648 } 2649 2650 auto WarnAndReturn = [this](const Twine &Msg, uint64_t Offset) { 2651 reportUniqueWarning(createError("string table at offset 0x" + 2652 Twine::utohexstr(Offset) + Msg)); 2653 return "<?>"; 2654 }; 2655 2656 const uint64_t FileSize = ObjF->getELFFile()->getBufSize(); 2657 const uint64_t Offset = 2658 (const uint8_t *)DynamicStringTable.data() - ObjF->getELFFile()->base(); 2659 if (DynamicStringTable.size() > FileSize - Offset) 2660 return WarnAndReturn(" with size 0x" + 2661 Twine::utohexstr(DynamicStringTable.size()) + 2662 " goes past the end of the file (0x" + 2663 Twine::utohexstr(FileSize) + ")", 2664 Offset); 2665 2666 if (Value >= DynamicStringTable.size()) 2667 return WarnAndReturn( 2668 ": unable to read the string at 0x" + Twine::utohexstr(Offset + Value) + 2669 ": it goes past the end of the table (0x" + 2670 Twine::utohexstr(Offset + DynamicStringTable.size()) + ")", 2671 Offset); 2672 2673 if (DynamicStringTable.back() != '\0') 2674 return WarnAndReturn(": unable to read the string at 0x" + 2675 Twine::utohexstr(Offset + Value) + 2676 ": the string table is not null-terminated", 2677 Offset); 2678 2679 return DynamicStringTable.data() + Value; 2680 } 2681 2682 template <class ELFT> void ELFDumper<ELFT>::printUnwindInfo() { 2683 DwarfCFIEH::PrinterContext<ELFT> Ctx(W, ObjF); 2684 Ctx.printUnwindInformation(); 2685 } 2686 2687 namespace { 2688 2689 template <> void ELFDumper<ELF32LE>::printUnwindInfo() { 2690 const ELFFile<ELF32LE> *Obj = ObjF->getELFFile(); 2691 const unsigned Machine = Obj->getHeader()->e_machine; 2692 if (Machine == EM_ARM) { 2693 ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF->getFileName(), 2694 DotSymtabSec); 2695 Ctx.PrintUnwindInformation(); 2696 } 2697 DwarfCFIEH::PrinterContext<ELF32LE> Ctx(W, ObjF); 2698 Ctx.printUnwindInformation(); 2699 } 2700 2701 } // end anonymous namespace 2702 2703 template <class ELFT> void ELFDumper<ELFT>::printDynamicTable() { 2704 ELFDumperStyle->printDynamic(ObjF->getELFFile()); 2705 } 2706 2707 template <class ELFT> void ELFDumper<ELFT>::printNeededLibraries() { 2708 ListScope D(W, "NeededLibraries"); 2709 2710 std::vector<StringRef> Libs; 2711 for (const auto &Entry : dynamic_table()) 2712 if (Entry.d_tag == ELF::DT_NEEDED) 2713 Libs.push_back(getDynamicString(Entry.d_un.d_val)); 2714 2715 llvm::sort(Libs); 2716 2717 for (StringRef L : Libs) 2718 W.startLine() << L << "\n"; 2719 } 2720 2721 template <class ELFT> 2722 static Error checkHashTable(const ELFFile<ELFT> *Obj, 2723 const typename ELFT::Hash *H, 2724 bool *IsHeaderValid = nullptr) { 2725 auto MakeError = [&](uint64_t Off, const Twine &Msg = "") { 2726 return createError("the hash table at offset 0x" + Twine::utohexstr(Off) + 2727 " goes past the end of the file (0x" + 2728 Twine::utohexstr(Obj->getBufSize()) + ")" + Msg); 2729 }; 2730 2731 // Each SHT_HASH section starts from two 32-bit fields: nbucket and nchain. 2732 const unsigned HeaderSize = 2 * sizeof(typename ELFT::Word); 2733 const uint64_t SecOffset = (const uint8_t *)H - Obj->base(); 2734 2735 if (IsHeaderValid) 2736 *IsHeaderValid = Obj->getBufSize() - SecOffset >= HeaderSize; 2737 2738 if (Obj->getBufSize() - SecOffset < HeaderSize) 2739 return MakeError(SecOffset); 2740 2741 if (Obj->getBufSize() - SecOffset - HeaderSize < 2742 ((uint64_t)H->nbucket + H->nchain) * sizeof(typename ELFT::Word)) 2743 return MakeError(SecOffset, ", nbucket = " + Twine(H->nbucket) + 2744 ", nchain = " + Twine(H->nchain)); 2745 return Error::success(); 2746 } 2747 2748 template <class ELFT> 2749 static Error checkGNUHashTable(const ELFFile<ELFT> *Obj, 2750 const typename ELFT::GnuHash *GnuHashTable, 2751 bool *IsHeaderValid = nullptr) { 2752 const uint8_t *TableData = reinterpret_cast<const uint8_t *>(GnuHashTable); 2753 assert(TableData >= Obj->base() && 2754 TableData < Obj->base() + Obj->getBufSize() && 2755 "GnuHashTable must always point to a location inside the file"); 2756 2757 uint64_t TableOffset = TableData - Obj->base(); 2758 if (IsHeaderValid) 2759 *IsHeaderValid = TableOffset + /*Header size:*/ 16 < Obj->getBufSize(); 2760 if (TableOffset + 16 + (uint64_t)GnuHashTable->nbuckets * 4 + 2761 (uint64_t)GnuHashTable->maskwords * sizeof(typename ELFT::Off) >= 2762 Obj->getBufSize()) 2763 return createError("unable to dump the SHT_GNU_HASH " 2764 "section at 0x" + 2765 Twine::utohexstr(TableOffset) + 2766 ": it goes past the end of the file"); 2767 return Error::success(); 2768 } 2769 2770 template <typename ELFT> void ELFDumper<ELFT>::printHashTable() { 2771 DictScope D(W, "HashTable"); 2772 if (!HashTable) 2773 return; 2774 2775 bool IsHeaderValid; 2776 Error Err = checkHashTable(ObjF->getELFFile(), HashTable, &IsHeaderValid); 2777 if (IsHeaderValid) { 2778 W.printNumber("Num Buckets", HashTable->nbucket); 2779 W.printNumber("Num Chains", HashTable->nchain); 2780 } 2781 2782 if (Err) { 2783 reportUniqueWarning(std::move(Err)); 2784 return; 2785 } 2786 2787 W.printList("Buckets", HashTable->buckets()); 2788 W.printList("Chains", HashTable->chains()); 2789 } 2790 2791 template <class ELFT> 2792 static Expected<ArrayRef<typename ELFT::Word>> 2793 getGnuHashTableChains(Optional<DynRegionInfo> DynSymRegion, 2794 const typename ELFT::GnuHash *GnuHashTable) { 2795 if (!DynSymRegion) 2796 return createError("no dynamic symbol table found"); 2797 2798 ArrayRef<typename ELFT::Sym> DynSymTable = 2799 DynSymRegion->getAsArrayRef<typename ELFT::Sym>(); 2800 size_t NumSyms = DynSymTable.size(); 2801 if (!NumSyms) 2802 return createError("the dynamic symbol table is empty"); 2803 2804 if (GnuHashTable->symndx < NumSyms) 2805 return GnuHashTable->values(NumSyms); 2806 2807 // A normal empty GNU hash table section produced by linker might have 2808 // symndx set to the number of dynamic symbols + 1 (for the zero symbol) 2809 // and have dummy null values in the Bloom filter and in the buckets 2810 // vector (or no values at all). It happens because the value of symndx is not 2811 // important for dynamic loaders when the GNU hash table is empty. They just 2812 // skip the whole object during symbol lookup. In such cases, the symndx value 2813 // is irrelevant and we should not report a warning. 2814 ArrayRef<typename ELFT::Word> Buckets = GnuHashTable->buckets(); 2815 if (!llvm::all_of(Buckets, [](typename ELFT::Word V) { return V == 0; })) 2816 return createError("the first hashed symbol index (" + 2817 Twine(GnuHashTable->symndx) + 2818 ") is larger than the number of dynamic symbols (" + 2819 Twine(NumSyms) + ")"); 2820 // There is no way to represent an array of (dynamic symbols count - symndx) 2821 // length. 2822 return ArrayRef<typename ELFT::Word>(); 2823 } 2824 2825 template <typename ELFT> 2826 void ELFDumper<ELFT>::printGnuHashTable(const object::ObjectFile *Obj) { 2827 DictScope D(W, "GnuHashTable"); 2828 if (!GnuHashTable) 2829 return; 2830 2831 bool IsHeaderValid; 2832 Error Err = 2833 checkGNUHashTable<ELFT>(ObjF->getELFFile(), GnuHashTable, &IsHeaderValid); 2834 if (IsHeaderValid) { 2835 W.printNumber("Num Buckets", GnuHashTable->nbuckets); 2836 W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); 2837 W.printNumber("Num Mask Words", GnuHashTable->maskwords); 2838 W.printNumber("Shift Count", GnuHashTable->shift2); 2839 } 2840 2841 if (Err) { 2842 reportUniqueWarning(std::move(Err)); 2843 return; 2844 } 2845 2846 ArrayRef<typename ELFT::Off> BloomFilter = GnuHashTable->filter(); 2847 W.printHexList("Bloom Filter", BloomFilter); 2848 2849 ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets(); 2850 W.printList("Buckets", Buckets); 2851 2852 Expected<ArrayRef<Elf_Word>> Chains = 2853 getGnuHashTableChains<ELFT>(DynSymRegion, GnuHashTable); 2854 if (!Chains) { 2855 reportUniqueWarning( 2856 createError("unable to dump 'Values' for the SHT_GNU_HASH " 2857 "section: " + 2858 toString(Chains.takeError()))); 2859 return; 2860 } 2861 2862 W.printHexList("Values", *Chains); 2863 } 2864 2865 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() { 2866 W.printString("LoadName", SOName); 2867 } 2868 2869 template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() { 2870 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 2871 switch (Obj->getHeader()->e_machine) { 2872 case EM_ARM: 2873 case EM_RISCV: 2874 printAttributes(); 2875 break; 2876 case EM_MIPS: { 2877 ELFDumperStyle->printMipsABIFlags(ObjF); 2878 printMipsOptions(); 2879 printMipsReginfo(); 2880 MipsGOTParser<ELFT> Parser(*this); 2881 if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols())) 2882 reportError(std::move(E), ObjF->getFileName()); 2883 else if (!Parser.isGotEmpty()) 2884 ELFDumperStyle->printMipsGOT(Parser); 2885 2886 if (Error E = Parser.findPLT(dynamic_table())) 2887 reportError(std::move(E), ObjF->getFileName()); 2888 else if (!Parser.isPltEmpty()) 2889 ELFDumperStyle->printMipsPLT(Parser); 2890 break; 2891 } 2892 default: 2893 break; 2894 } 2895 } 2896 2897 namespace { 2898 2899 template <class ELFT> void ELFDumper<ELFT>::printAttributes() { 2900 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 2901 if (!Obj->isLE()) { 2902 W.startLine() << "Attributes not implemented.\n"; 2903 return; 2904 } 2905 2906 const unsigned Machine = Obj->getHeader()->e_machine; 2907 assert((Machine == EM_ARM || Machine == EM_RISCV) && 2908 "Attributes not implemented."); 2909 2910 DictScope BA(W, "BuildAttributes"); 2911 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 2912 if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES && 2913 Sec.sh_type != ELF::SHT_RISCV_ATTRIBUTES) 2914 continue; 2915 2916 ArrayRef<uint8_t> Contents = 2917 unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec)); 2918 if (Contents[0] != ELFAttrs::Format_Version) { 2919 reportWarning(createError(Twine("unrecognised FormatVersion: 0x") + 2920 Twine::utohexstr(Contents[0])), 2921 ObjF->getFileName()); 2922 continue; 2923 } 2924 W.printHex("FormatVersion", Contents[0]); 2925 if (Contents.size() == 1) 2926 continue; 2927 2928 // TODO: Delete the redundant FormatVersion check above. 2929 if (Machine == EM_ARM) { 2930 if (Error E = ARMAttributeParser(&W).parse(Contents, support::little)) 2931 reportWarning(std::move(E), ObjF->getFileName()); 2932 } else if (Machine == EM_RISCV) { 2933 if (Error E = RISCVAttributeParser(&W).parse(Contents, support::little)) 2934 reportWarning(std::move(E), ObjF->getFileName()); 2935 } 2936 } 2937 } 2938 2939 template <class ELFT> class MipsGOTParser { 2940 public: 2941 TYPEDEF_ELF_TYPES(ELFT) 2942 using Entry = typename ELFO::Elf_Addr; 2943 using Entries = ArrayRef<Entry>; 2944 2945 const bool IsStatic; 2946 const ELFO * const Obj; 2947 const ELFDumper<ELFT> &Dumper; 2948 2949 MipsGOTParser(const ELFDumper<ELFT> &D); 2950 Error findGOT(Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms); 2951 Error findPLT(Elf_Dyn_Range DynTable); 2952 2953 bool isGotEmpty() const { return GotEntries.empty(); } 2954 bool isPltEmpty() const { return PltEntries.empty(); } 2955 2956 uint64_t getGp() const; 2957 2958 const Entry *getGotLazyResolver() const; 2959 const Entry *getGotModulePointer() const; 2960 const Entry *getPltLazyResolver() const; 2961 const Entry *getPltModulePointer() const; 2962 2963 Entries getLocalEntries() const; 2964 Entries getGlobalEntries() const; 2965 Entries getOtherEntries() const; 2966 Entries getPltEntries() const; 2967 2968 uint64_t getGotAddress(const Entry * E) const; 2969 int64_t getGotOffset(const Entry * E) const; 2970 const Elf_Sym *getGotSym(const Entry *E) const; 2971 2972 uint64_t getPltAddress(const Entry * E) const; 2973 const Elf_Sym *getPltSym(const Entry *E) const; 2974 2975 StringRef getPltStrTable() const { return PltStrTable; } 2976 2977 private: 2978 const Elf_Shdr *GotSec; 2979 size_t LocalNum; 2980 size_t GlobalNum; 2981 2982 const Elf_Shdr *PltSec; 2983 const Elf_Shdr *PltRelSec; 2984 const Elf_Shdr *PltSymTable; 2985 StringRef FileName; 2986 2987 Elf_Sym_Range GotDynSyms; 2988 StringRef PltStrTable; 2989 2990 Entries GotEntries; 2991 Entries PltEntries; 2992 }; 2993 2994 } // end anonymous namespace 2995 2996 template <class ELFT> 2997 MipsGOTParser<ELFT>::MipsGOTParser(const ELFDumper<ELFT> &D) 2998 : IsStatic(D.dynamic_table().empty()), Obj(D.getElfObject()->getELFFile()), 2999 Dumper(D), GotSec(nullptr), LocalNum(0), GlobalNum(0), PltSec(nullptr), 3000 PltRelSec(nullptr), PltSymTable(nullptr), 3001 FileName(D.getElfObject()->getFileName()) {} 3002 3003 template <class ELFT> 3004 Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable, 3005 Elf_Sym_Range DynSyms) { 3006 // See "Global Offset Table" in Chapter 5 in the following document 3007 // for detailed GOT description. 3008 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 3009 3010 // Find static GOT secton. 3011 if (IsStatic) { 3012 GotSec = Dumper.findSectionByName(".got"); 3013 if (!GotSec) 3014 return Error::success(); 3015 3016 ArrayRef<uint8_t> Content = 3017 unwrapOrError(FileName, Obj->getSectionContents(GotSec)); 3018 GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), 3019 Content.size() / sizeof(Entry)); 3020 LocalNum = GotEntries.size(); 3021 return Error::success(); 3022 } 3023 3024 // Lookup dynamic table tags which define the GOT layout. 3025 Optional<uint64_t> DtPltGot; 3026 Optional<uint64_t> DtLocalGotNum; 3027 Optional<uint64_t> DtGotSym; 3028 for (const auto &Entry : DynTable) { 3029 switch (Entry.getTag()) { 3030 case ELF::DT_PLTGOT: 3031 DtPltGot = Entry.getVal(); 3032 break; 3033 case ELF::DT_MIPS_LOCAL_GOTNO: 3034 DtLocalGotNum = Entry.getVal(); 3035 break; 3036 case ELF::DT_MIPS_GOTSYM: 3037 DtGotSym = Entry.getVal(); 3038 break; 3039 } 3040 } 3041 3042 if (!DtPltGot && !DtLocalGotNum && !DtGotSym) 3043 return Error::success(); 3044 3045 if (!DtPltGot) 3046 return createError("cannot find PLTGOT dynamic tag"); 3047 if (!DtLocalGotNum) 3048 return createError("cannot find MIPS_LOCAL_GOTNO dynamic tag"); 3049 if (!DtGotSym) 3050 return createError("cannot find MIPS_GOTSYM dynamic tag"); 3051 3052 size_t DynSymTotal = DynSyms.size(); 3053 if (*DtGotSym > DynSymTotal) 3054 return createError("DT_MIPS_GOTSYM value (" + Twine(*DtGotSym) + 3055 ") exceeds the number of dynamic symbols (" + 3056 Twine(DynSymTotal) + ")"); 3057 3058 GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot); 3059 if (!GotSec) 3060 return createError("there is no non-empty GOT section at 0x" + 3061 Twine::utohexstr(*DtPltGot)); 3062 3063 LocalNum = *DtLocalGotNum; 3064 GlobalNum = DynSymTotal - *DtGotSym; 3065 3066 ArrayRef<uint8_t> Content = 3067 unwrapOrError(FileName, Obj->getSectionContents(GotSec)); 3068 GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()), 3069 Content.size() / sizeof(Entry)); 3070 GotDynSyms = DynSyms.drop_front(*DtGotSym); 3071 3072 return Error::success(); 3073 } 3074 3075 template <class ELFT> 3076 Error MipsGOTParser<ELFT>::findPLT(Elf_Dyn_Range DynTable) { 3077 // Lookup dynamic table tags which define the PLT layout. 3078 Optional<uint64_t> DtMipsPltGot; 3079 Optional<uint64_t> DtJmpRel; 3080 for (const auto &Entry : DynTable) { 3081 switch (Entry.getTag()) { 3082 case ELF::DT_MIPS_PLTGOT: 3083 DtMipsPltGot = Entry.getVal(); 3084 break; 3085 case ELF::DT_JMPREL: 3086 DtJmpRel = Entry.getVal(); 3087 break; 3088 } 3089 } 3090 3091 if (!DtMipsPltGot && !DtJmpRel) 3092 return Error::success(); 3093 3094 // Find PLT section. 3095 if (!DtMipsPltGot) 3096 return createError("cannot find MIPS_PLTGOT dynamic tag"); 3097 if (!DtJmpRel) 3098 return createError("cannot find JMPREL dynamic tag"); 3099 3100 PltSec = findNotEmptySectionByAddress(Obj, FileName, *DtMipsPltGot); 3101 if (!PltSec) 3102 return createError("there is no non-empty PLTGOT section at 0x" + 3103 Twine::utohexstr(*DtMipsPltGot)); 3104 3105 PltRelSec = findNotEmptySectionByAddress(Obj, FileName, *DtJmpRel); 3106 if (!PltRelSec) 3107 return createError("there is no non-empty RELPLT section at 0x" + 3108 Twine::utohexstr(*DtJmpRel)); 3109 3110 if (Expected<ArrayRef<uint8_t>> PltContentOrErr = 3111 Obj->getSectionContents(PltSec)) 3112 PltEntries = 3113 Entries(reinterpret_cast<const Entry *>(PltContentOrErr->data()), 3114 PltContentOrErr->size() / sizeof(Entry)); 3115 else 3116 return createError("unable to read PLTGOT section content: " + 3117 toString(PltContentOrErr.takeError())); 3118 3119 if (Expected<const Elf_Shdr *> PltSymTableOrErr = 3120 Obj->getSection(PltRelSec->sh_link)) 3121 PltSymTable = *PltSymTableOrErr; 3122 else 3123 return createError("unable to get a symbol table linked to the " + 3124 describe(Obj, *PltRelSec) + ": " + 3125 toString(PltSymTableOrErr.takeError())); 3126 3127 if (Expected<StringRef> StrTabOrErr = 3128 Obj->getStringTableForSymtab(*PltSymTable)) 3129 PltStrTable = *StrTabOrErr; 3130 else 3131 return createError("unable to get a string table for the " + 3132 describe(Obj, *PltSymTable) + ": " + 3133 toString(StrTabOrErr.takeError())); 3134 3135 return Error::success(); 3136 } 3137 3138 template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const { 3139 return GotSec->sh_addr + 0x7ff0; 3140 } 3141 3142 template <class ELFT> 3143 const typename MipsGOTParser<ELFT>::Entry * 3144 MipsGOTParser<ELFT>::getGotLazyResolver() const { 3145 return LocalNum > 0 ? &GotEntries[0] : nullptr; 3146 } 3147 3148 template <class ELFT> 3149 const typename MipsGOTParser<ELFT>::Entry * 3150 MipsGOTParser<ELFT>::getGotModulePointer() const { 3151 if (LocalNum < 2) 3152 return nullptr; 3153 const Entry &E = GotEntries[1]; 3154 if ((E >> (sizeof(Entry) * 8 - 1)) == 0) 3155 return nullptr; 3156 return &E; 3157 } 3158 3159 template <class ELFT> 3160 typename MipsGOTParser<ELFT>::Entries 3161 MipsGOTParser<ELFT>::getLocalEntries() const { 3162 size_t Skip = getGotModulePointer() ? 2 : 1; 3163 if (LocalNum - Skip <= 0) 3164 return Entries(); 3165 return GotEntries.slice(Skip, LocalNum - Skip); 3166 } 3167 3168 template <class ELFT> 3169 typename MipsGOTParser<ELFT>::Entries 3170 MipsGOTParser<ELFT>::getGlobalEntries() const { 3171 if (GlobalNum == 0) 3172 return Entries(); 3173 return GotEntries.slice(LocalNum, GlobalNum); 3174 } 3175 3176 template <class ELFT> 3177 typename MipsGOTParser<ELFT>::Entries 3178 MipsGOTParser<ELFT>::getOtherEntries() const { 3179 size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum; 3180 if (OtherNum == 0) 3181 return Entries(); 3182 return GotEntries.slice(LocalNum + GlobalNum, OtherNum); 3183 } 3184 3185 template <class ELFT> 3186 uint64_t MipsGOTParser<ELFT>::getGotAddress(const Entry *E) const { 3187 int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); 3188 return GotSec->sh_addr + Offset; 3189 } 3190 3191 template <class ELFT> 3192 int64_t MipsGOTParser<ELFT>::getGotOffset(const Entry *E) const { 3193 int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); 3194 return Offset - 0x7ff0; 3195 } 3196 3197 template <class ELFT> 3198 const typename MipsGOTParser<ELFT>::Elf_Sym * 3199 MipsGOTParser<ELFT>::getGotSym(const Entry *E) const { 3200 int64_t Offset = std::distance(GotEntries.data(), E); 3201 return &GotDynSyms[Offset - LocalNum]; 3202 } 3203 3204 template <class ELFT> 3205 const typename MipsGOTParser<ELFT>::Entry * 3206 MipsGOTParser<ELFT>::getPltLazyResolver() const { 3207 return PltEntries.empty() ? nullptr : &PltEntries[0]; 3208 } 3209 3210 template <class ELFT> 3211 const typename MipsGOTParser<ELFT>::Entry * 3212 MipsGOTParser<ELFT>::getPltModulePointer() const { 3213 return PltEntries.size() < 2 ? nullptr : &PltEntries[1]; 3214 } 3215 3216 template <class ELFT> 3217 typename MipsGOTParser<ELFT>::Entries 3218 MipsGOTParser<ELFT>::getPltEntries() const { 3219 if (PltEntries.size() <= 2) 3220 return Entries(); 3221 return PltEntries.slice(2, PltEntries.size() - 2); 3222 } 3223 3224 template <class ELFT> 3225 uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const { 3226 int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry); 3227 return PltSec->sh_addr + Offset; 3228 } 3229 3230 template <class ELFT> 3231 const typename MipsGOTParser<ELFT>::Elf_Sym * 3232 MipsGOTParser<ELFT>::getPltSym(const Entry *E) const { 3233 int64_t Offset = std::distance(getPltEntries().data(), E); 3234 if (PltRelSec->sh_type == ELF::SHT_REL) { 3235 Elf_Rel_Range Rels = unwrapOrError(FileName, Obj->rels(PltRelSec)); 3236 return unwrapOrError(FileName, 3237 Obj->getRelocationSymbol(&Rels[Offset], PltSymTable)); 3238 } else { 3239 Elf_Rela_Range Rels = unwrapOrError(FileName, Obj->relas(PltRelSec)); 3240 return unwrapOrError(FileName, 3241 Obj->getRelocationSymbol(&Rels[Offset], PltSymTable)); 3242 } 3243 } 3244 3245 static const EnumEntry<unsigned> ElfMipsISAExtType[] = { 3246 {"None", Mips::AFL_EXT_NONE}, 3247 {"Broadcom SB-1", Mips::AFL_EXT_SB1}, 3248 {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, 3249 {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, 3250 {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, 3251 {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, 3252 {"LSI R4010", Mips::AFL_EXT_4010}, 3253 {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, 3254 {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, 3255 {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, 3256 {"MIPS R4650", Mips::AFL_EXT_4650}, 3257 {"MIPS R5900", Mips::AFL_EXT_5900}, 3258 {"MIPS R10000", Mips::AFL_EXT_10000}, 3259 {"NEC VR4100", Mips::AFL_EXT_4100}, 3260 {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, 3261 {"NEC VR4120", Mips::AFL_EXT_4120}, 3262 {"NEC VR5400", Mips::AFL_EXT_5400}, 3263 {"NEC VR5500", Mips::AFL_EXT_5500}, 3264 {"RMI Xlr", Mips::AFL_EXT_XLR}, 3265 {"Toshiba R3900", Mips::AFL_EXT_3900} 3266 }; 3267 3268 static const EnumEntry<unsigned> ElfMipsASEFlags[] = { 3269 {"DSP", Mips::AFL_ASE_DSP}, 3270 {"DSPR2", Mips::AFL_ASE_DSPR2}, 3271 {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, 3272 {"MCU", Mips::AFL_ASE_MCU}, 3273 {"MDMX", Mips::AFL_ASE_MDMX}, 3274 {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, 3275 {"MT", Mips::AFL_ASE_MT}, 3276 {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, 3277 {"VZ", Mips::AFL_ASE_VIRT}, 3278 {"MSA", Mips::AFL_ASE_MSA}, 3279 {"MIPS16", Mips::AFL_ASE_MIPS16}, 3280 {"microMIPS", Mips::AFL_ASE_MICROMIPS}, 3281 {"XPA", Mips::AFL_ASE_XPA}, 3282 {"CRC", Mips::AFL_ASE_CRC}, 3283 {"GINV", Mips::AFL_ASE_GINV}, 3284 }; 3285 3286 static const EnumEntry<unsigned> ElfMipsFpABIType[] = { 3287 {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, 3288 {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, 3289 {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, 3290 {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, 3291 {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", 3292 Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, 3293 {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, 3294 {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, 3295 {"Hard float compat (32-bit CPU, 64-bit FPU)", 3296 Mips::Val_GNU_MIPS_ABI_FP_64A} 3297 }; 3298 3299 static const EnumEntry<unsigned> ElfMipsFlags1[] { 3300 {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, 3301 }; 3302 3303 static int getMipsRegisterSize(uint8_t Flag) { 3304 switch (Flag) { 3305 case Mips::AFL_REG_NONE: 3306 return 0; 3307 case Mips::AFL_REG_32: 3308 return 32; 3309 case Mips::AFL_REG_64: 3310 return 64; 3311 case Mips::AFL_REG_128: 3312 return 128; 3313 default: 3314 return -1; 3315 } 3316 } 3317 3318 template <class ELFT> 3319 static void printMipsReginfoData(ScopedPrinter &W, 3320 const Elf_Mips_RegInfo<ELFT> &Reginfo) { 3321 W.printHex("GP", Reginfo.ri_gp_value); 3322 W.printHex("General Mask", Reginfo.ri_gprmask); 3323 W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); 3324 W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); 3325 W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); 3326 W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); 3327 } 3328 3329 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() { 3330 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 3331 const Elf_Shdr *RegInfo = findSectionByName(".reginfo"); 3332 if (!RegInfo) { 3333 W.startLine() << "There is no .reginfo section in the file.\n"; 3334 return; 3335 } 3336 3337 ArrayRef<uint8_t> Sec = unwrapOrError(ObjF->getFileName(), 3338 Obj->getSectionContents(RegInfo)); 3339 if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) { 3340 W.startLine() << "The .reginfo section has a wrong size.\n"; 3341 return; 3342 } 3343 3344 DictScope GS(W, "MIPS RegInfo"); 3345 auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data()); 3346 printMipsReginfoData(W, *Reginfo); 3347 } 3348 3349 template <class ELFT> 3350 static Expected<const Elf_Mips_Options<ELFT> *> 3351 readMipsOptions(const uint8_t *SecBegin, ArrayRef<uint8_t> &SecData, 3352 bool &IsSupported) { 3353 if (SecData.size() < sizeof(Elf_Mips_Options<ELFT>)) 3354 return createError("the .MIPS.options section has an invalid size (0x" + 3355 Twine::utohexstr(SecData.size()) + ")"); 3356 3357 const Elf_Mips_Options<ELFT> *O = 3358 reinterpret_cast<const Elf_Mips_Options<ELFT> *>(SecData.data()); 3359 const uint8_t Size = O->size; 3360 if (Size > SecData.size()) { 3361 const uint64_t Offset = SecData.data() - SecBegin; 3362 const uint64_t SecSize = Offset + SecData.size(); 3363 return createError("a descriptor of size 0x" + Twine::utohexstr(Size) + 3364 " at offset 0x" + Twine::utohexstr(Offset) + 3365 " goes past the end of the .MIPS.options " 3366 "section of size 0x" + 3367 Twine::utohexstr(SecSize)); 3368 } 3369 3370 IsSupported = O->kind == ODK_REGINFO; 3371 const size_t ExpectedSize = 3372 sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>); 3373 3374 if (IsSupported) 3375 if (Size < ExpectedSize) 3376 return createError( 3377 "a .MIPS.options entry of kind " + 3378 Twine(getElfMipsOptionsOdkType(O->kind)) + 3379 " has an invalid size (0x" + Twine::utohexstr(Size) + 3380 "), the expected size is 0x" + Twine::utohexstr(ExpectedSize)); 3381 3382 SecData = SecData.drop_front(Size); 3383 return O; 3384 } 3385 3386 template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() { 3387 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 3388 const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options"); 3389 if (!MipsOpts) { 3390 W.startLine() << "There is no .MIPS.options section in the file.\n"; 3391 return; 3392 } 3393 3394 DictScope GS(W, "MIPS Options"); 3395 3396 ArrayRef<uint8_t> Data = 3397 unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(MipsOpts)); 3398 const uint8_t *const SecBegin = Data.begin(); 3399 while (!Data.empty()) { 3400 bool IsSupported; 3401 Expected<const Elf_Mips_Options<ELFT> *> OptsOrErr = 3402 readMipsOptions<ELFT>(SecBegin, Data, IsSupported); 3403 if (!OptsOrErr) { 3404 reportUniqueWarning(OptsOrErr.takeError()); 3405 break; 3406 } 3407 3408 unsigned Kind = (*OptsOrErr)->kind; 3409 const char *Type = getElfMipsOptionsOdkType(Kind); 3410 if (!IsSupported) { 3411 W.startLine() << "Unsupported MIPS options tag: " << Type << " (" << Kind 3412 << ")\n"; 3413 continue; 3414 } 3415 3416 DictScope GS(W, Type); 3417 if (Kind == ODK_REGINFO) 3418 printMipsReginfoData(W, (*OptsOrErr)->getRegInfo()); 3419 else 3420 llvm_unreachable("unexpected .MIPS.options section descriptor kind"); 3421 } 3422 } 3423 3424 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const { 3425 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 3426 const Elf_Shdr *StackMapSection = nullptr; 3427 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 3428 StringRef Name = 3429 unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec)); 3430 if (Name == ".llvm_stackmaps") { 3431 StackMapSection = &Sec; 3432 break; 3433 } 3434 } 3435 3436 if (!StackMapSection) 3437 return; 3438 3439 ArrayRef<uint8_t> StackMapContentsArray = unwrapOrError( 3440 ObjF->getFileName(), Obj->getSectionContents(StackMapSection)); 3441 3442 prettyPrintStackMap( 3443 W, StackMapParser<ELFT::TargetEndianness>(StackMapContentsArray)); 3444 } 3445 3446 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() { 3447 ELFDumperStyle->printGroupSections(ObjF->getELFFile()); 3448 } 3449 3450 template <class ELFT> void ELFDumper<ELFT>::printAddrsig() { 3451 ELFDumperStyle->printAddrsig(ObjF->getELFFile()); 3452 } 3453 3454 static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, 3455 StringRef Str2) { 3456 OS.PadToColumn(2u); 3457 OS << Str1; 3458 OS.PadToColumn(37u); 3459 OS << Str2 << "\n"; 3460 OS.flush(); 3461 } 3462 3463 template <class ELFT> 3464 static std::string getSectionHeadersNumString(const ELFFile<ELFT> *Obj, 3465 StringRef FileName) { 3466 const typename ELFT::Ehdr *ElfHeader = Obj->getHeader(); 3467 if (ElfHeader->e_shnum != 0) 3468 return to_string(ElfHeader->e_shnum); 3469 3470 ArrayRef<typename ELFT::Shdr> Arr = cantFail(Obj->sections()); 3471 if (Arr.empty()) 3472 return "0"; 3473 return "0 (" + to_string(Arr[0].sh_size) + ")"; 3474 } 3475 3476 template <class ELFT> 3477 static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> *Obj, 3478 StringRef FileName) { 3479 const typename ELFT::Ehdr *ElfHeader = Obj->getHeader(); 3480 if (ElfHeader->e_shstrndx != SHN_XINDEX) 3481 return to_string(ElfHeader->e_shstrndx); 3482 3483 ArrayRef<typename ELFT::Shdr> Arr = cantFail(Obj->sections()); 3484 if (Arr.empty()) 3485 return "65535 (corrupt: out of range)"; 3486 return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) + 3487 ")"; 3488 } 3489 3490 template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) { 3491 const Elf_Ehdr *e = Obj->getHeader(); 3492 OS << "ELF Header:\n"; 3493 OS << " Magic: "; 3494 std::string Str; 3495 for (int i = 0; i < ELF::EI_NIDENT; i++) 3496 OS << format(" %02x", static_cast<int>(e->e_ident[i])); 3497 OS << "\n"; 3498 Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); 3499 printFields(OS, "Class:", Str); 3500 Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); 3501 printFields(OS, "Data:", Str); 3502 OS.PadToColumn(2u); 3503 OS << "Version:"; 3504 OS.PadToColumn(37u); 3505 OS << to_hexString(e->e_ident[ELF::EI_VERSION]); 3506 if (e->e_version == ELF::EV_CURRENT) 3507 OS << " (current)"; 3508 OS << "\n"; 3509 Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); 3510 printFields(OS, "OS/ABI:", Str); 3511 printFields(OS, 3512 "ABI Version:", std::to_string(e->e_ident[ELF::EI_ABIVERSION])); 3513 Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType)); 3514 printFields(OS, "Type:", Str); 3515 Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType)); 3516 printFields(OS, "Machine:", Str); 3517 Str = "0x" + to_hexString(e->e_version); 3518 printFields(OS, "Version:", Str); 3519 Str = "0x" + to_hexString(e->e_entry); 3520 printFields(OS, "Entry point address:", Str); 3521 Str = to_string(e->e_phoff) + " (bytes into file)"; 3522 printFields(OS, "Start of program headers:", Str); 3523 Str = to_string(e->e_shoff) + " (bytes into file)"; 3524 printFields(OS, "Start of section headers:", Str); 3525 std::string ElfFlags; 3526 if (e->e_machine == EM_MIPS) 3527 ElfFlags = 3528 printFlags(e->e_flags, makeArrayRef(ElfHeaderMipsFlags), 3529 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), 3530 unsigned(ELF::EF_MIPS_MACH)); 3531 else if (e->e_machine == EM_RISCV) 3532 ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderRISCVFlags)); 3533 Str = "0x" + to_hexString(e->e_flags); 3534 if (!ElfFlags.empty()) 3535 Str = Str + ", " + ElfFlags; 3536 printFields(OS, "Flags:", Str); 3537 Str = to_string(e->e_ehsize) + " (bytes)"; 3538 printFields(OS, "Size of this header:", Str); 3539 Str = to_string(e->e_phentsize) + " (bytes)"; 3540 printFields(OS, "Size of program headers:", Str); 3541 Str = to_string(e->e_phnum); 3542 printFields(OS, "Number of program headers:", Str); 3543 Str = to_string(e->e_shentsize) + " (bytes)"; 3544 printFields(OS, "Size of section headers:", Str); 3545 Str = getSectionHeadersNumString(Obj, this->FileName); 3546 printFields(OS, "Number of section headers:", Str); 3547 Str = getSectionHeaderTableIndexString(Obj, this->FileName); 3548 printFields(OS, "Section header string table index:", Str); 3549 } 3550 3551 namespace { 3552 struct GroupMember { 3553 StringRef Name; 3554 uint64_t Index; 3555 }; 3556 3557 struct GroupSection { 3558 StringRef Name; 3559 std::string Signature; 3560 uint64_t ShName; 3561 uint64_t Index; 3562 uint32_t Link; 3563 uint32_t Info; 3564 uint32_t Type; 3565 std::vector<GroupMember> Members; 3566 }; 3567 3568 template <class ELFT> 3569 std::vector<GroupSection> getGroups(const ELFFile<ELFT> *Obj, 3570 StringRef FileName) { 3571 using Elf_Shdr = typename ELFT::Shdr; 3572 using Elf_Sym = typename ELFT::Sym; 3573 using Elf_Word = typename ELFT::Word; 3574 3575 std::vector<GroupSection> Ret; 3576 uint64_t I = 0; 3577 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 3578 ++I; 3579 if (Sec.sh_type != ELF::SHT_GROUP) 3580 continue; 3581 3582 const Elf_Shdr *Symtab = 3583 unwrapOrError(FileName, Obj->getSection(Sec.sh_link)); 3584 StringRef StrTable = 3585 unwrapOrError(FileName, Obj->getStringTableForSymtab(*Symtab)); 3586 const Elf_Sym *Sym = unwrapOrError( 3587 FileName, Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info)); 3588 auto Data = unwrapOrError( 3589 FileName, Obj->template getSectionContentsAsArray<Elf_Word>(&Sec)); 3590 3591 StringRef Name = unwrapOrError(FileName, Obj->getSectionName(&Sec)); 3592 StringRef Signature = StrTable.data() + Sym->st_name; 3593 Ret.push_back({Name, 3594 maybeDemangle(Signature), 3595 Sec.sh_name, 3596 I - 1, 3597 Sec.sh_link, 3598 Sec.sh_info, 3599 Data[0], 3600 {}}); 3601 3602 std::vector<GroupMember> &GM = Ret.back().Members; 3603 for (uint32_t Ndx : Data.slice(1)) { 3604 auto Sec = unwrapOrError(FileName, Obj->getSection(Ndx)); 3605 const StringRef Name = unwrapOrError(FileName, Obj->getSectionName(Sec)); 3606 GM.push_back({Name, Ndx}); 3607 } 3608 } 3609 return Ret; 3610 } 3611 3612 DenseMap<uint64_t, const GroupSection *> 3613 mapSectionsToGroups(ArrayRef<GroupSection> Groups) { 3614 DenseMap<uint64_t, const GroupSection *> Ret; 3615 for (const GroupSection &G : Groups) 3616 for (const GroupMember &GM : G.Members) 3617 Ret.insert({GM.Index, &G}); 3618 return Ret; 3619 } 3620 3621 } // namespace 3622 3623 template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) { 3624 std::vector<GroupSection> V = getGroups<ELFT>(Obj, this->FileName); 3625 DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); 3626 for (const GroupSection &G : V) { 3627 OS << "\n" 3628 << getGroupType(G.Type) << " group section [" 3629 << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature 3630 << "] contains " << G.Members.size() << " sections:\n" 3631 << " [Index] Name\n"; 3632 for (const GroupMember &GM : G.Members) { 3633 const GroupSection *MainGroup = Map[GM.Index]; 3634 if (MainGroup != &G) 3635 this->reportUniqueWarning( 3636 createError("section with index " + Twine(GM.Index) + 3637 ", included in the group section with index " + 3638 Twine(MainGroup->Index) + 3639 ", was also found in the group section with index " + 3640 Twine(G.Index))); 3641 OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n"; 3642 } 3643 } 3644 3645 if (V.empty()) 3646 OS << "There are no section groups in this file.\n"; 3647 } 3648 3649 template <class ELFT> 3650 void GNUStyle<ELFT>::printRelReloc(const ELFO *Obj, unsigned SecIndex, 3651 const Elf_Shdr *SymTab, const Elf_Rel &R, 3652 unsigned RelIndex) { 3653 printRelRelaReloc(Obj, SecIndex, SymTab, R, RelIndex); 3654 } 3655 3656 template <class ELFT> 3657 void GNUStyle<ELFT>::printRelaReloc(const ELFO *Obj, unsigned SecIndex, 3658 const Elf_Shdr *SymTab, const Elf_Rela &R, 3659 unsigned RelIndex) { 3660 printRelRelaReloc(Obj, SecIndex, SymTab, R, RelIndex); 3661 } 3662 3663 template <class ELFT> void GNUStyle<ELFT>::printRelrReloc(const Elf_Relr &R) { 3664 OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n"; 3665 } 3666 3667 template <class ELFT> 3668 template <class RelTy> 3669 void GNUStyle<ELFT>::printRelRelaReloc(const ELFO *Obj, unsigned SecIndex, 3670 const Elf_Shdr *SymTab, const RelTy &R, 3671 unsigned RelIndex) { 3672 Expected<std::pair<const typename ELFT::Sym *, std::string>> Target = 3673 this->dumper()->getRelocationTarget(SymTab, R); 3674 if (!Target) 3675 this->reportUniqueWarning(createError( 3676 "unable to print relocation " + Twine(RelIndex) + " in section " + 3677 Twine(SecIndex) + ": " + toString(Target.takeError()))); 3678 else 3679 printRelRelaReloc(Obj, /*Sym=*/Target->first, /*Name=*/Target->second, R); 3680 } 3681 3682 template <class ELFT> 3683 static Optional<int64_t> getAddend(const typename ELFT::Rela &R) { 3684 return (int64_t)R.r_addend; 3685 } 3686 3687 template <class ELFT> 3688 static Optional<int64_t> getAddend(const typename ELFT::Rel &) { 3689 return None; 3690 } 3691 3692 template <class ELFT> 3693 template <class RelTy> 3694 void GNUStyle<ELFT>::printRelRelaReloc(const ELFO *Obj, const Elf_Sym *Sym, 3695 StringRef SymbolName, const RelTy &R) { 3696 // First two fields are bit width dependent. The rest of them are fixed width. 3697 unsigned Bias = ELFT::Is64Bits ? 8 : 0; 3698 Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; 3699 unsigned Width = ELFT::Is64Bits ? 16 : 8; 3700 3701 Fields[0].Str = to_string(format_hex_no_prefix(R.r_offset, Width)); 3702 Fields[1].Str = to_string(format_hex_no_prefix(R.r_info, Width)); 3703 3704 SmallString<32> RelocName; 3705 Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName); 3706 Fields[2].Str = RelocName.c_str(); 3707 3708 if (Sym) 3709 Fields[3].Str = to_string(format_hex_no_prefix(Sym->getValue(), Width)); 3710 3711 Fields[4].Str = std::string(SymbolName); 3712 for (const Field &F : Fields) 3713 printField(F); 3714 3715 std::string Addend; 3716 if (Optional<int64_t> A = getAddend<ELFT>(R)) { 3717 int64_t RelAddend = *A; 3718 if (!SymbolName.empty()) { 3719 if (RelAddend < 0) { 3720 Addend = " - "; 3721 RelAddend = std::abs(RelAddend); 3722 } else { 3723 Addend = " + "; 3724 } 3725 } 3726 Addend += to_hexString(RelAddend, false); 3727 } 3728 OS << Addend << "\n"; 3729 } 3730 3731 template <class ELFT> void GNUStyle<ELFT>::printRelocHeader(unsigned SType) { 3732 bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA; 3733 bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR; 3734 if (ELFT::Is64Bits) 3735 OS << " "; 3736 else 3737 OS << " "; 3738 if (IsRelr && opts::RawRelr) 3739 OS << "Data "; 3740 else 3741 OS << "Offset"; 3742 if (ELFT::Is64Bits) 3743 OS << " Info Type" 3744 << " Symbol's Value Symbol's Name"; 3745 else 3746 OS << " Info Type Sym. Value Symbol's Name"; 3747 if (IsRela) 3748 OS << " + Addend"; 3749 OS << "\n"; 3750 } 3751 3752 template <class ELFT> 3753 static bool isRelocationSec(const typename ELFT::Shdr &Sec) { 3754 return Sec.sh_type == ELF::SHT_REL || Sec.sh_type == ELF::SHT_RELA || 3755 Sec.sh_type == ELF::SHT_RELR || Sec.sh_type == ELF::SHT_ANDROID_REL || 3756 Sec.sh_type == ELF::SHT_ANDROID_RELA || 3757 Sec.sh_type == ELF::SHT_ANDROID_RELR; 3758 } 3759 3760 template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) { 3761 bool HasRelocSections = false; 3762 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 3763 if (!isRelocationSec<ELFT>(Sec)) 3764 continue; 3765 HasRelocSections = true; 3766 3767 unsigned Entries; 3768 // Android's packed relocation section needs to be unpacked first 3769 // to get the actual number of entries. 3770 if (Sec.sh_type == ELF::SHT_ANDROID_REL || 3771 Sec.sh_type == ELF::SHT_ANDROID_RELA) { 3772 Entries = unwrapOrError(this->FileName, Obj->android_relas(&Sec)).size(); 3773 } else if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR || 3774 Sec.sh_type == ELF::SHT_ANDROID_RELR)) { 3775 Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(&Sec)); 3776 Entries = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)).size(); 3777 } else { 3778 Entries = Sec.getEntityCount(); 3779 } 3780 3781 uintX_t Offset = Sec.sh_offset; 3782 StringRef Name = this->getPrintableSectionName(Obj, Sec); 3783 OS << "\nRelocation section '" << Name << "' at offset 0x" 3784 << to_hexString(Offset, false) << " contains " << Entries 3785 << " entries:\n"; 3786 printRelocHeader(Sec.sh_type); 3787 this->printRelocationsHelper(Obj, Sec); 3788 } 3789 if (!HasRelocSections) 3790 OS << "\nThere are no relocations in this file.\n"; 3791 } 3792 3793 // Print the offset of a particular section from anyone of the ranges: 3794 // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER]. 3795 // If 'Type' does not fall within any of those ranges, then a string is 3796 // returned as '<unknown>' followed by the type value. 3797 static std::string getSectionTypeOffsetString(unsigned Type) { 3798 if (Type >= SHT_LOOS && Type <= SHT_HIOS) 3799 return "LOOS+0x" + to_hexString(Type - SHT_LOOS); 3800 else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC) 3801 return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC); 3802 else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER) 3803 return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER); 3804 return "0x" + to_hexString(Type) + ": <unknown>"; 3805 } 3806 3807 static std::string getSectionTypeString(unsigned Machine, unsigned Type) { 3808 StringRef Name = getELFSectionTypeName(Machine, Type); 3809 3810 // Handle SHT_GNU_* type names. 3811 if (Name.startswith("SHT_GNU_")) { 3812 if (Name == "SHT_GNU_HASH") 3813 return "GNU_HASH"; 3814 // E.g. SHT_GNU_verneed -> VERNEED. 3815 return Name.drop_front(8).upper(); 3816 } 3817 3818 if (Name == "SHT_SYMTAB_SHNDX") 3819 return "SYMTAB SECTION INDICES"; 3820 3821 if (Name.startswith("SHT_")) 3822 return Name.drop_front(4).str(); 3823 return getSectionTypeOffsetString(Type); 3824 } 3825 3826 static void printSectionDescription(formatted_raw_ostream &OS, 3827 unsigned EMachine) { 3828 OS << "Key to Flags:\n"; 3829 OS << " W (write), A (alloc), X (execute), M (merge), S (strings), I " 3830 "(info),\n"; 3831 OS << " L (link order), O (extra OS processing required), G (group), T " 3832 "(TLS),\n"; 3833 OS << " C (compressed), x (unknown), o (OS specific), E (exclude),\n"; 3834 3835 if (EMachine == EM_X86_64) 3836 OS << " l (large), "; 3837 else if (EMachine == EM_ARM) 3838 OS << " y (purecode), "; 3839 else 3840 OS << " "; 3841 3842 OS << "p (processor specific)\n"; 3843 } 3844 3845 template <class ELFT> 3846 void GNUStyle<ELFT>::printSectionHeaders(const ELFO *Obj) { 3847 unsigned Bias = ELFT::Is64Bits ? 0 : 8; 3848 ArrayRef<Elf_Shdr> Sections = cantFail(Obj->sections()); 3849 OS << "There are " << to_string(Sections.size()) 3850 << " section headers, starting at offset " 3851 << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n"; 3852 OS << "Section Headers:\n"; 3853 Field Fields[11] = { 3854 {"[Nr]", 2}, {"Name", 7}, {"Type", 25}, 3855 {"Address", 41}, {"Off", 58 - Bias}, {"Size", 65 - Bias}, 3856 {"ES", 72 - Bias}, {"Flg", 75 - Bias}, {"Lk", 79 - Bias}, 3857 {"Inf", 82 - Bias}, {"Al", 86 - Bias}}; 3858 for (auto &F : Fields) 3859 printField(F); 3860 OS << "\n"; 3861 3862 StringRef SecStrTable; 3863 if (Expected<StringRef> SecStrTableOrErr = 3864 Obj->getSectionStringTable(Sections, this->dumper()->WarningHandler)) 3865 SecStrTable = *SecStrTableOrErr; 3866 else 3867 this->reportUniqueWarning(SecStrTableOrErr.takeError()); 3868 3869 size_t SectionIndex = 0; 3870 for (const Elf_Shdr &Sec : Sections) { 3871 Fields[0].Str = to_string(SectionIndex); 3872 if (SecStrTable.empty()) 3873 Fields[1].Str = "<no-strings>"; 3874 else 3875 Fields[1].Str = std::string(unwrapOrError<StringRef>( 3876 this->FileName, Obj->getSectionName(&Sec, SecStrTable))); 3877 Fields[2].Str = 3878 getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type); 3879 Fields[3].Str = 3880 to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8)); 3881 Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); 3882 Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6)); 3883 Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); 3884 Fields[7].Str = getGNUFlags(Obj->getHeader()->e_machine, Sec.sh_flags); 3885 Fields[8].Str = to_string(Sec.sh_link); 3886 Fields[9].Str = to_string(Sec.sh_info); 3887 Fields[10].Str = to_string(Sec.sh_addralign); 3888 3889 OS.PadToColumn(Fields[0].Column); 3890 OS << "[" << right_justify(Fields[0].Str, 2) << "]"; 3891 for (int i = 1; i < 7; i++) 3892 printField(Fields[i]); 3893 OS.PadToColumn(Fields[7].Column); 3894 OS << right_justify(Fields[7].Str, 3); 3895 OS.PadToColumn(Fields[8].Column); 3896 OS << right_justify(Fields[8].Str, 2); 3897 OS.PadToColumn(Fields[9].Column); 3898 OS << right_justify(Fields[9].Str, 3); 3899 OS.PadToColumn(Fields[10].Column); 3900 OS << right_justify(Fields[10].Str, 2); 3901 OS << "\n"; 3902 ++SectionIndex; 3903 } 3904 printSectionDescription(OS, Obj->getHeader()->e_machine); 3905 } 3906 3907 template <class ELFT> 3908 void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, const Elf_Shdr *Symtab, 3909 size_t Entries, 3910 bool NonVisibilityBitsUsed) { 3911 StringRef Name; 3912 if (Symtab) 3913 Name = this->getPrintableSectionName(Obj, *Symtab); 3914 if (!Name.empty()) 3915 OS << "\nSymbol table '" << Name << "'"; 3916 else 3917 OS << "\nSymbol table for image"; 3918 OS << " contains " << Entries << " entries:\n"; 3919 3920 if (ELFT::Is64Bits) 3921 OS << " Num: Value Size Type Bind Vis"; 3922 else 3923 OS << " Num: Value Size Type Bind Vis"; 3924 3925 if (NonVisibilityBitsUsed) 3926 OS << " "; 3927 OS << " Ndx Name\n"; 3928 } 3929 3930 template <class ELFT> 3931 std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj, 3932 const Elf_Sym *Symbol, 3933 const Elf_Sym *FirstSym) { 3934 unsigned SectionIndex = Symbol->st_shndx; 3935 switch (SectionIndex) { 3936 case ELF::SHN_UNDEF: 3937 return "UND"; 3938 case ELF::SHN_ABS: 3939 return "ABS"; 3940 case ELF::SHN_COMMON: 3941 return "COM"; 3942 case ELF::SHN_XINDEX: { 3943 Expected<uint32_t> IndexOrErr = object::getExtendedSymbolTableIndex<ELFT>( 3944 Symbol, FirstSym, this->dumper()->getShndxTable()); 3945 if (!IndexOrErr) { 3946 assert(Symbol->st_shndx == SHN_XINDEX && 3947 "getSymbolSectionIndex should only fail due to an invalid " 3948 "SHT_SYMTAB_SHNDX table/reference"); 3949 this->reportUniqueWarning(IndexOrErr.takeError()); 3950 return "RSV[0xffff]"; 3951 } 3952 return to_string(format_decimal(*IndexOrErr, 3)); 3953 } 3954 default: 3955 // Find if: 3956 // Processor specific 3957 if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) 3958 return std::string("PRC[0x") + 3959 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; 3960 // OS specific 3961 if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) 3962 return std::string("OS[0x") + 3963 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; 3964 // Architecture reserved: 3965 if (SectionIndex >= ELF::SHN_LORESERVE && 3966 SectionIndex <= ELF::SHN_HIRESERVE) 3967 return std::string("RSV[0x") + 3968 to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; 3969 // A normal section with an index 3970 return to_string(format_decimal(SectionIndex, 3)); 3971 } 3972 } 3973 3974 template <class ELFT> 3975 void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, 3976 const Elf_Sym *FirstSym, 3977 Optional<StringRef> StrTable, bool IsDynamic, 3978 bool NonVisibilityBitsUsed) { 3979 unsigned Bias = ELFT::Is64Bits ? 8 : 0; 3980 Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, 3981 31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias}; 3982 Fields[0].Str = to_string(format_decimal(Symbol - FirstSym, 6)) + ":"; 3983 Fields[1].Str = to_string( 3984 format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); 3985 Fields[2].Str = to_string(format_decimal(Symbol->st_size, 5)); 3986 3987 unsigned char SymbolType = Symbol->getType(); 3988 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && 3989 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) 3990 Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); 3991 else 3992 Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes)); 3993 3994 Fields[4].Str = 3995 printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); 3996 Fields[5].Str = 3997 printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities)); 3998 if (Symbol->st_other & ~0x3) 3999 Fields[5].Str += 4000 " [<other: " + to_string(format_hex(Symbol->st_other, 2)) + ">]"; 4001 4002 Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0; 4003 Fields[6].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym); 4004 4005 Fields[7].Str = 4006 this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); 4007 for (auto &Entry : Fields) 4008 printField(Entry); 4009 OS << "\n"; 4010 } 4011 4012 template <class ELFT> 4013 void GNUStyle<ELFT>::printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, 4014 uint32_t Sym, StringRef StrTable, 4015 uint32_t Bucket) { 4016 unsigned Bias = ELFT::Is64Bits ? 8 : 0; 4017 Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias, 4018 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias}; 4019 Fields[0].Str = to_string(format_decimal(Sym, 5)); 4020 Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":"; 4021 4022 const auto Symbol = FirstSym + Sym; 4023 Fields[2].Str = to_string( 4024 format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); 4025 Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5)); 4026 4027 unsigned char SymbolType = Symbol->getType(); 4028 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && 4029 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) 4030 Fields[4].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); 4031 else 4032 Fields[4].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes)); 4033 4034 Fields[5].Str = 4035 printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); 4036 Fields[6].Str = 4037 printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities)); 4038 Fields[7].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym); 4039 Fields[8].Str = this->dumper()->getFullSymbolName(Symbol, StrTable, true); 4040 4041 for (auto &Entry : Fields) 4042 printField(Entry); 4043 OS << "\n"; 4044 } 4045 4046 template <class ELFT> 4047 void GNUStyle<ELFT>::printSymbols(const ELFO *Obj, bool PrintSymbols, 4048 bool PrintDynamicSymbols) { 4049 if (!PrintSymbols && !PrintDynamicSymbols) 4050 return; 4051 // GNU readelf prints both the .dynsym and .symtab with --symbols. 4052 this->dumper()->printSymbolsHelper(true); 4053 if (PrintSymbols) 4054 this->dumper()->printSymbolsHelper(false); 4055 } 4056 4057 template <class ELFT> 4058 void GNUStyle<ELFT>::printHashTableSymbols(const ELFO *Obj, 4059 const Elf_Hash &SysVHash) { 4060 StringRef StringTable = this->dumper()->getDynamicStringTable(); 4061 if (StringTable.empty()) 4062 return; 4063 4064 if (ELFT::Is64Bits) 4065 OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; 4066 else 4067 OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; 4068 OS << "\n"; 4069 4070 Elf_Sym_Range DynSyms = this->dumper()->dynamic_symbols(); 4071 const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; 4072 if (!FirstSym) { 4073 Optional<DynRegionInfo> DynSymRegion = this->dumper()->getDynSymRegion(); 4074 this->reportUniqueWarning( 4075 createError(Twine("unable to print symbols for the .hash table: the " 4076 "dynamic symbol table ") + 4077 (DynSymRegion ? "is empty" : "was not found"))); 4078 return; 4079 } 4080 4081 auto Buckets = SysVHash.buckets(); 4082 auto Chains = SysVHash.chains(); 4083 for (uint32_t Buc = 0; Buc < SysVHash.nbucket; Buc++) { 4084 if (Buckets[Buc] == ELF::STN_UNDEF) 4085 continue; 4086 std::vector<bool> Visited(SysVHash.nchain); 4087 for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash.nchain; Ch = Chains[Ch]) { 4088 if (Ch == ELF::STN_UNDEF) 4089 break; 4090 4091 if (Visited[Ch]) { 4092 reportWarning(createError(".hash section is invalid: bucket " + 4093 Twine(Ch) + 4094 ": a cycle was detected in the linked chain"), 4095 this->FileName); 4096 break; 4097 } 4098 4099 printHashedSymbol(Obj, FirstSym, Ch, StringTable, Buc); 4100 Visited[Ch] = true; 4101 } 4102 } 4103 } 4104 4105 template <class ELFT> 4106 void GNUStyle<ELFT>::printGnuHashTableSymbols(const ELFO *Obj, 4107 const Elf_GnuHash &GnuHash) { 4108 StringRef StringTable = this->dumper()->getDynamicStringTable(); 4109 if (StringTable.empty()) 4110 return; 4111 4112 Elf_Sym_Range DynSyms = this->dumper()->dynamic_symbols(); 4113 const Elf_Sym *FirstSym = DynSyms.empty() ? nullptr : &DynSyms[0]; 4114 if (!FirstSym) { 4115 Optional<DynRegionInfo> DynSymRegion = this->dumper()->getDynSymRegion(); 4116 this->reportUniqueWarning(createError( 4117 Twine("unable to print symbols for the .gnu.hash table: the " 4118 "dynamic symbol table ") + 4119 (DynSymRegion ? "is empty" : "was not found"))); 4120 return; 4121 } 4122 4123 ArrayRef<Elf_Word> Buckets = GnuHash.buckets(); 4124 for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) { 4125 if (Buckets[Buc] == ELF::STN_UNDEF) 4126 continue; 4127 uint32_t Index = Buckets[Buc]; 4128 uint32_t GnuHashable = Index - GnuHash.symndx; 4129 // Print whole chain 4130 while (true) { 4131 printHashedSymbol(Obj, FirstSym, Index++, StringTable, Buc); 4132 // Chain ends at symbol with stopper bit 4133 if ((GnuHash.values(DynSyms.size())[GnuHashable++] & 1) == 1) 4134 break; 4135 } 4136 } 4137 } 4138 4139 template <class ELFT> void GNUStyle<ELFT>::printHashSymbols(const ELFO *Obj) { 4140 if (const Elf_Hash *SysVHash = this->dumper()->getHashTable()) { 4141 OS << "\n Symbol table of .hash for image:\n"; 4142 if (Error E = checkHashTable<ELFT>(Obj, SysVHash)) 4143 this->reportUniqueWarning(std::move(E)); 4144 else 4145 printHashTableSymbols(Obj, *SysVHash); 4146 } 4147 4148 // Try printing the .gnu.hash table. 4149 if (const Elf_GnuHash *GnuHash = this->dumper()->getGnuHashTable()) { 4150 OS << "\n Symbol table of .gnu.hash for image:\n"; 4151 if (ELFT::Is64Bits) 4152 OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; 4153 else 4154 OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; 4155 OS << "\n"; 4156 4157 if (Error E = checkGNUHashTable<ELFT>(Obj, GnuHash)) 4158 this->reportUniqueWarning(std::move(E)); 4159 else 4160 printGnuHashTableSymbols(Obj, *GnuHash); 4161 } 4162 } 4163 4164 static inline std::string printPhdrFlags(unsigned Flag) { 4165 std::string Str; 4166 Str = (Flag & PF_R) ? "R" : " "; 4167 Str += (Flag & PF_W) ? "W" : " "; 4168 Str += (Flag & PF_X) ? "E" : " "; 4169 return Str; 4170 } 4171 4172 template <class ELFT> 4173 static bool checkTLSSections(const typename ELFT::Phdr &Phdr, 4174 const typename ELFT::Shdr &Sec) { 4175 if (Sec.sh_flags & ELF::SHF_TLS) { 4176 // .tbss must only be shown in the PT_TLS segment. 4177 if (Sec.sh_type == ELF::SHT_NOBITS) 4178 return Phdr.p_type == ELF::PT_TLS; 4179 4180 // SHF_TLS sections are only shown in PT_TLS, PT_LOAD or PT_GNU_RELRO 4181 // segments. 4182 return (Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || 4183 (Phdr.p_type == ELF::PT_GNU_RELRO); 4184 } 4185 4186 // PT_TLS must only have SHF_TLS sections. 4187 return Phdr.p_type != ELF::PT_TLS; 4188 } 4189 4190 template <class ELFT> 4191 static bool checkOffsets(const typename ELFT::Phdr &Phdr, 4192 const typename ELFT::Shdr &Sec) { 4193 // SHT_NOBITS sections don't need to have an offset inside the segment. 4194 if (Sec.sh_type == ELF::SHT_NOBITS) 4195 return true; 4196 4197 if (Sec.sh_offset < Phdr.p_offset) 4198 return false; 4199 4200 // Only non-empty sections can be at the end of a segment. 4201 if (Sec.sh_size == 0) 4202 return (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz); 4203 return Sec.sh_offset + Sec.sh_size <= Phdr.p_offset + Phdr.p_filesz; 4204 } 4205 4206 // Check that an allocatable section belongs to a virtual address 4207 // space of a segment. 4208 template <class ELFT> 4209 static bool checkVMA(const typename ELFT::Phdr &Phdr, 4210 const typename ELFT::Shdr &Sec) { 4211 if (!(Sec.sh_flags & ELF::SHF_ALLOC)) 4212 return true; 4213 4214 if (Sec.sh_addr < Phdr.p_vaddr) 4215 return false; 4216 4217 bool IsTbss = 4218 (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); 4219 // .tbss is special, it only has memory in PT_TLS and has NOBITS properties. 4220 bool IsTbssInNonTLS = IsTbss && Phdr.p_type != ELF::PT_TLS; 4221 // Only non-empty sections can be at the end of a segment. 4222 if (Sec.sh_size == 0 || IsTbssInNonTLS) 4223 return Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz; 4224 return Sec.sh_addr + Sec.sh_size <= Phdr.p_vaddr + Phdr.p_memsz; 4225 } 4226 4227 template <class ELFT> 4228 static bool checkPTDynamic(const typename ELFT::Phdr &Phdr, 4229 const typename ELFT::Shdr &Sec) { 4230 if (Phdr.p_type != ELF::PT_DYNAMIC || Phdr.p_memsz == 0 || Sec.sh_size != 0) 4231 return true; 4232 4233 // We get here when we have an empty section. Only non-empty sections can be 4234 // at the start or at the end of PT_DYNAMIC. 4235 // Is section within the phdr both based on offset and VMA? 4236 bool CheckOffset = (Sec.sh_type == ELF::SHT_NOBITS) || 4237 (Sec.sh_offset > Phdr.p_offset && 4238 Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz); 4239 bool CheckVA = !(Sec.sh_flags & ELF::SHF_ALLOC) || 4240 (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz); 4241 return CheckOffset && CheckVA; 4242 } 4243 4244 template <class ELFT> 4245 void GNUStyle<ELFT>::printProgramHeaders( 4246 const ELFO *Obj, bool PrintProgramHeaders, 4247 cl::boolOrDefault PrintSectionMapping) { 4248 if (PrintProgramHeaders) 4249 printProgramHeaders(Obj); 4250 4251 // Display the section mapping along with the program headers, unless 4252 // -section-mapping is explicitly set to false. 4253 if (PrintSectionMapping != cl::BOU_FALSE) 4254 printSectionMapping(Obj); 4255 } 4256 4257 template <class ELFT> 4258 void GNUStyle<ELFT>::printProgramHeaders(const ELFO *Obj) { 4259 unsigned Bias = ELFT::Is64Bits ? 8 : 0; 4260 const Elf_Ehdr *Header = Obj->getHeader(); 4261 Field Fields[8] = {2, 17, 26, 37 + Bias, 4262 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; 4263 OS << "\nElf file type is " 4264 << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n" 4265 << "Entry point " << format_hex(Header->e_entry, 3) << "\n" 4266 << "There are " << Header->e_phnum << " program headers," 4267 << " starting at offset " << Header->e_phoff << "\n\n" 4268 << "Program Headers:\n"; 4269 if (ELFT::Is64Bits) 4270 OS << " Type Offset VirtAddr PhysAddr " 4271 << " FileSiz MemSiz Flg Align\n"; 4272 else 4273 OS << " Type Offset VirtAddr PhysAddr FileSiz " 4274 << "MemSiz Flg Align\n"; 4275 4276 unsigned Width = ELFT::Is64Bits ? 18 : 10; 4277 unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; 4278 4279 Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers(); 4280 if (!PhdrsOrErr) { 4281 this->reportUniqueWarning(createError("unable to dump program headers: " + 4282 toString(PhdrsOrErr.takeError()))); 4283 return; 4284 } 4285 4286 for (const Elf_Phdr &Phdr : *PhdrsOrErr) { 4287 Fields[0].Str = getElfPtType(Header->e_machine, Phdr.p_type); 4288 Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8)); 4289 Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width)); 4290 Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width)); 4291 Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth)); 4292 Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth)); 4293 Fields[6].Str = printPhdrFlags(Phdr.p_flags); 4294 Fields[7].Str = to_string(format_hex(Phdr.p_align, 1)); 4295 for (auto Field : Fields) 4296 printField(Field); 4297 if (Phdr.p_type == ELF::PT_INTERP) { 4298 OS << "\n"; 4299 auto ReportBadInterp = [&](const Twine &Msg) { 4300 reportWarning( 4301 createError("unable to read program interpreter name at offset 0x" + 4302 Twine::utohexstr(Phdr.p_offset) + ": " + Msg), 4303 this->FileName); 4304 }; 4305 4306 if (Phdr.p_offset >= Obj->getBufSize()) { 4307 ReportBadInterp("it goes past the end of the file (0x" + 4308 Twine::utohexstr(Obj->getBufSize()) + ")"); 4309 continue; 4310 } 4311 4312 const char *Data = 4313 reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset; 4314 size_t MaxSize = Obj->getBufSize() - Phdr.p_offset; 4315 size_t Len = strnlen(Data, MaxSize); 4316 if (Len == MaxSize) { 4317 ReportBadInterp("it is not null-terminated"); 4318 continue; 4319 } 4320 4321 OS << " [Requesting program interpreter: "; 4322 OS << StringRef(Data, Len) << "]"; 4323 } 4324 OS << "\n"; 4325 } 4326 } 4327 4328 template <class ELFT> 4329 void GNUStyle<ELFT>::printSectionMapping(const ELFO *Obj) { 4330 OS << "\n Section to Segment mapping:\n Segment Sections...\n"; 4331 DenseSet<const Elf_Shdr *> BelongsToSegment; 4332 int Phnum = 0; 4333 4334 Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers(); 4335 if (!PhdrsOrErr) { 4336 this->reportUniqueWarning(createError( 4337 "can't read program headers to build section to segment mapping: " + 4338 toString(PhdrsOrErr.takeError()))); 4339 return; 4340 } 4341 4342 for (const Elf_Phdr &Phdr : *PhdrsOrErr) { 4343 std::string Sections; 4344 OS << format(" %2.2d ", Phnum++); 4345 // Check if each section is in a segment and then print mapping. 4346 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 4347 if (Sec.sh_type == ELF::SHT_NULL) 4348 continue; 4349 4350 // readelf additionally makes sure it does not print zero sized sections 4351 // at end of segments and for PT_DYNAMIC both start and end of section 4352 // .tbss must only be shown in PT_TLS section. 4353 if (checkTLSSections<ELFT>(Phdr, Sec) && checkOffsets<ELFT>(Phdr, Sec) && 4354 checkVMA<ELFT>(Phdr, Sec) && checkPTDynamic<ELFT>(Phdr, Sec)) { 4355 Sections += 4356 unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() + 4357 " "; 4358 BelongsToSegment.insert(&Sec); 4359 } 4360 } 4361 OS << Sections << "\n"; 4362 OS.flush(); 4363 } 4364 4365 // Display sections that do not belong to a segment. 4366 std::string Sections; 4367 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 4368 if (BelongsToSegment.find(&Sec) == BelongsToSegment.end()) 4369 Sections += 4370 unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() + ' '; 4371 } 4372 if (!Sections.empty()) { 4373 OS << " None " << Sections << '\n'; 4374 OS.flush(); 4375 } 4376 } 4377 4378 namespace { 4379 template <class ELFT> struct RelSymbol { 4380 const typename ELFT::Sym *Sym; 4381 std::string Name; 4382 }; 4383 4384 template <class ELFT, class RelTy> 4385 RelSymbol<ELFT> getSymbolForReloc(const ELFFile<ELFT> *Obj, StringRef FileName, 4386 const ELFDumper<ELFT> *Dumper, 4387 const RelTy &Reloc) { 4388 uint32_t SymIndex = Reloc.getSymbol(Obj->isMips64EL()); 4389 auto WarnAndReturn = [&](const typename ELFT::Sym *Sym, 4390 const Twine &Reason) -> RelSymbol<ELFT> { 4391 reportWarning( 4392 createError("unable to get name of the dynamic symbol with index " + 4393 Twine(SymIndex) + ": " + Reason), 4394 FileName); 4395 return {Sym, "<corrupt>"}; 4396 }; 4397 4398 ArrayRef<typename ELFT::Sym> Symbols = Dumper->dynamic_symbols(); 4399 const typename ELFT::Sym *FirstSym = Symbols.begin(); 4400 if (!FirstSym) 4401 return WarnAndReturn(nullptr, "no dynamic symbol table found"); 4402 4403 // We might have an object without a section header. In this case the size of 4404 // Symbols is zero, because there is no way to know the size of the dynamic 4405 // table. We should allow this case and not print a warning. 4406 if (!Symbols.empty() && SymIndex >= Symbols.size()) 4407 return WarnAndReturn( 4408 nullptr, 4409 "index is greater than or equal to the number of dynamic symbols (" + 4410 Twine(Symbols.size()) + ")"); 4411 4412 const typename ELFT::Sym *Sym = FirstSym + SymIndex; 4413 Expected<StringRef> ErrOrName = Sym->getName(Dumper->getDynamicStringTable()); 4414 if (!ErrOrName) 4415 return WarnAndReturn(Sym, toString(ErrOrName.takeError())); 4416 4417 return {Sym == FirstSym ? nullptr : Sym, maybeDemangle(*ErrOrName)}; 4418 } 4419 } // namespace 4420 4421 template <class ELFT> 4422 template <class RelTy> 4423 void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, const RelTy &R) { 4424 RelSymbol<ELFT> S = getSymbolForReloc(Obj, this->FileName, this->dumper(), R); 4425 printRelRelaReloc(Obj, S.Sym, S.Name, R); 4426 } 4427 4428 template <class ELFT> 4429 static size_t getMaxDynamicTagSize(const ELFFile<ELFT> *Obj, 4430 typename ELFT::DynRange Tags) { 4431 size_t Max = 0; 4432 for (const typename ELFT::Dyn &Dyn : Tags) 4433 Max = std::max(Max, Obj->getDynamicTagAsString(Dyn.d_tag).size()); 4434 return Max; 4435 } 4436 4437 template <class ELFT> void GNUStyle<ELFT>::printDynamic(const ELFO *Obj) { 4438 Elf_Dyn_Range Table = this->dumper()->dynamic_table(); 4439 if (Table.empty()) 4440 return; 4441 4442 const DynRegionInfo &DynamicTableRegion = 4443 this->dumper()->getDynamicTableRegion(); 4444 4445 OS << "Dynamic section at offset " 4446 << format_hex(reinterpret_cast<const uint8_t *>(DynamicTableRegion.Addr) - 4447 Obj->base(), 4448 1) 4449 << " contains " << Table.size() << " entries:\n"; 4450 4451 // The type name is surrounded with round brackets, hence add 2. 4452 size_t MaxTagSize = getMaxDynamicTagSize(Obj, Table) + 2; 4453 // The "Name/Value" column should be indented from the "Type" column by N 4454 // spaces, where N = MaxTagSize - length of "Type" (4) + trailing 4455 // space (1) = 3. 4456 OS << " Tag" + std::string(ELFT::Is64Bits ? 16 : 8, ' ') + "Type" 4457 << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; 4458 4459 std::string ValueFmt = " %-" + std::to_string(MaxTagSize) + "s "; 4460 for (auto Entry : Table) { 4461 uintX_t Tag = Entry.getTag(); 4462 std::string Type = 4463 std::string("(") + Obj->getDynamicTagAsString(Tag).c_str() + ")"; 4464 std::string Value = this->dumper()->getDynamicEntry(Tag, Entry.getVal()); 4465 OS << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10) 4466 << format(ValueFmt.c_str(), Type.c_str()) << Value << "\n"; 4467 } 4468 } 4469 4470 template <class ELFT> 4471 void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) { 4472 const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); 4473 const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); 4474 const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion(); 4475 const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); 4476 if (DynRelaRegion.Size > 0) { 4477 OS << "\n'RELA' relocation section at offset " 4478 << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) - 4479 Obj->base(), 4480 1) 4481 << " contains " << DynRelaRegion.Size << " bytes:\n"; 4482 printRelocHeader(ELF::SHT_RELA); 4483 for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) 4484 printDynamicRelocation(Obj, Rela); 4485 } 4486 if (DynRelRegion.Size > 0) { 4487 OS << "\n'REL' relocation section at offset " 4488 << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) - 4489 Obj->base(), 4490 1) 4491 << " contains " << DynRelRegion.Size << " bytes:\n"; 4492 printRelocHeader(ELF::SHT_REL); 4493 for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) 4494 printDynamicRelocation(Obj, Rel); 4495 } 4496 if (DynRelrRegion.Size > 0) { 4497 OS << "\n'RELR' relocation section at offset " 4498 << format_hex(reinterpret_cast<const uint8_t *>(DynRelrRegion.Addr) - 4499 Obj->base(), 4500 1) 4501 << " contains " << DynRelrRegion.Size << " bytes:\n"; 4502 printRelocHeader(ELF::SHT_REL); 4503 Elf_Relr_Range Relrs = this->dumper()->dyn_relrs(); 4504 std::vector<Elf_Rel> RelrRels = 4505 unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); 4506 for (const Elf_Rel &R : RelrRels) 4507 printDynamicRelocation(Obj, R); 4508 } 4509 if (DynPLTRelRegion.Size) { 4510 OS << "\n'PLT' relocation section at offset " 4511 << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) - 4512 Obj->base(), 4513 1) 4514 << " contains " << DynPLTRelRegion.Size << " bytes:\n"; 4515 4516 if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { 4517 printRelocHeader(ELF::SHT_RELA); 4518 for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>()) 4519 printDynamicRelocation(Obj, Rela); 4520 } else { 4521 printRelocHeader(ELF::SHT_REL); 4522 for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) 4523 printDynamicRelocation(Obj, Rel); 4524 } 4525 } 4526 } 4527 4528 template <class ELFT> 4529 void GNUStyle<ELFT>::printGNUVersionSectionProlog( 4530 const ELFFile<ELFT> *Obj, const typename ELFT::Shdr *Sec, 4531 const Twine &Label, unsigned EntriesNum) { 4532 StringRef SecName = unwrapOrError(this->FileName, Obj->getSectionName(Sec)); 4533 OS << Label << " section '" << SecName << "' " 4534 << "contains " << EntriesNum << " entries:\n"; 4535 4536 StringRef SymTabName = "<corrupt>"; 4537 Expected<const typename ELFT::Shdr *> SymTabOrErr = 4538 Obj->getSection(Sec->sh_link); 4539 if (SymTabOrErr) 4540 SymTabName = 4541 unwrapOrError(this->FileName, Obj->getSectionName(*SymTabOrErr)); 4542 else 4543 this->reportUniqueWarning(createError("invalid section linked to " + 4544 describe(Obj, *Sec) + ": " + 4545 toString(SymTabOrErr.takeError()))); 4546 4547 OS << " Addr: " << format_hex_no_prefix(Sec->sh_addr, 16) 4548 << " Offset: " << format_hex(Sec->sh_offset, 8) 4549 << " Link: " << Sec->sh_link << " (" << SymTabName << ")\n"; 4550 } 4551 4552 template <class ELFT> 4553 void GNUStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj, 4554 const Elf_Shdr *Sec) { 4555 if (!Sec) 4556 return; 4557 4558 printGNUVersionSectionProlog(Obj, Sec, "Version symbols", 4559 Sec->sh_size / sizeof(Elf_Versym)); 4560 Expected<ArrayRef<Elf_Versym>> VerTableOrErr = 4561 this->dumper()->getVersionTable(Sec, /*SymTab=*/nullptr, 4562 /*StrTab=*/nullptr); 4563 if (!VerTableOrErr) { 4564 this->reportUniqueWarning(VerTableOrErr.takeError()); 4565 return; 4566 } 4567 4568 ArrayRef<Elf_Versym> VerTable = *VerTableOrErr; 4569 std::vector<StringRef> Versions; 4570 for (size_t I = 0, E = VerTable.size(); I < E; ++I) { 4571 unsigned Ndx = VerTable[I].vs_index; 4572 if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) { 4573 Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*"); 4574 continue; 4575 } 4576 4577 bool IsDefault; 4578 Expected<StringRef> NameOrErr = 4579 this->dumper()->getSymbolVersionByIndex(Ndx, IsDefault); 4580 if (!NameOrErr) { 4581 if (!NameOrErr) 4582 this->reportUniqueWarning(createError( 4583 "unable to get a version for entry " + Twine(I) + " of " + 4584 describe(Obj, *Sec) + ": " + toString(NameOrErr.takeError()))); 4585 Versions.emplace_back("<corrupt>"); 4586 continue; 4587 } 4588 Versions.emplace_back(*NameOrErr); 4589 } 4590 4591 // readelf prints 4 entries per line. 4592 uint64_t Entries = VerTable.size(); 4593 for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) { 4594 OS << " " << format_hex_no_prefix(VersymRow, 3) << ":"; 4595 for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) { 4596 unsigned Ndx = VerTable[VersymRow + I].vs_index; 4597 OS << format("%4x%c", Ndx & VERSYM_VERSION, 4598 Ndx & VERSYM_HIDDEN ? 'h' : ' '); 4599 OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13); 4600 } 4601 OS << '\n'; 4602 } 4603 OS << '\n'; 4604 } 4605 4606 static std::string versionFlagToString(unsigned Flags) { 4607 if (Flags == 0) 4608 return "none"; 4609 4610 std::string Ret; 4611 auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) { 4612 if (!(Flags & Flag)) 4613 return; 4614 if (!Ret.empty()) 4615 Ret += " | "; 4616 Ret += Name; 4617 Flags &= ~Flag; 4618 }; 4619 4620 AddFlag(VER_FLG_BASE, "BASE"); 4621 AddFlag(VER_FLG_WEAK, "WEAK"); 4622 AddFlag(VER_FLG_INFO, "INFO"); 4623 AddFlag(~0, "<unknown>"); 4624 return Ret; 4625 } 4626 4627 template <class ELFT> 4628 void GNUStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj, 4629 const Elf_Shdr *Sec) { 4630 if (!Sec) 4631 return; 4632 4633 printGNUVersionSectionProlog(Obj, Sec, "Version definition", Sec->sh_info); 4634 4635 Expected<std::vector<VerDef>> V = this->dumper()->getVersionDefinitions(Sec); 4636 if (!V) { 4637 this->reportUniqueWarning(V.takeError()); 4638 return; 4639 } 4640 4641 for (const VerDef &Def : *V) { 4642 OS << format(" 0x%04x: Rev: %u Flags: %s Index: %u Cnt: %u Name: %s\n", 4643 Def.Offset, Def.Version, 4644 versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt, 4645 Def.Name.data()); 4646 unsigned I = 0; 4647 for (const VerdAux &Aux : Def.AuxV) 4648 OS << format(" 0x%04x: Parent %u: %s\n", Aux.Offset, ++I, 4649 Aux.Name.data()); 4650 } 4651 4652 OS << '\n'; 4653 } 4654 4655 template <class ELFT> 4656 void GNUStyle<ELFT>::printVersionDependencySection(const ELFFile<ELFT> *Obj, 4657 const Elf_Shdr *Sec) { 4658 if (!Sec) 4659 return; 4660 4661 unsigned VerneedNum = Sec->sh_info; 4662 printGNUVersionSectionProlog(Obj, Sec, "Version needs", VerneedNum); 4663 4664 Expected<std::vector<VerNeed>> V = 4665 this->dumper()->getVersionDependencies(Sec); 4666 if (!V) { 4667 this->reportUniqueWarning(V.takeError()); 4668 return; 4669 } 4670 4671 for (const VerNeed &VN : *V) { 4672 OS << format(" 0x%04x: Version: %u File: %s Cnt: %u\n", VN.Offset, 4673 VN.Version, VN.File.data(), VN.Cnt); 4674 for (const VernAux &Aux : VN.AuxV) 4675 OS << format(" 0x%04x: Name: %s Flags: %s Version: %u\n", Aux.Offset, 4676 Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(), 4677 Aux.Other); 4678 } 4679 OS << '\n'; 4680 } 4681 4682 template <class ELFT> 4683 void GNUStyle<ELFT>::printHashHistogram(const Elf_Hash &HashTable) { 4684 size_t NBucket = HashTable.nbucket; 4685 size_t NChain = HashTable.nchain; 4686 ArrayRef<Elf_Word> Buckets = HashTable.buckets(); 4687 ArrayRef<Elf_Word> Chains = HashTable.chains(); 4688 size_t TotalSyms = 0; 4689 // If hash table is correct, we have at least chains with 0 length 4690 size_t MaxChain = 1; 4691 size_t CumulativeNonZero = 0; 4692 4693 if (NChain == 0 || NBucket == 0) 4694 return; 4695 4696 std::vector<size_t> ChainLen(NBucket, 0); 4697 // Go over all buckets and and note chain lengths of each bucket (total 4698 // unique chain lengths). 4699 for (size_t B = 0; B < NBucket; B++) { 4700 std::vector<bool> Visited(NChain); 4701 for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) { 4702 if (C == ELF::STN_UNDEF) 4703 break; 4704 if (Visited[C]) { 4705 reportWarning(createError(".hash section is invalid: bucket " + 4706 Twine(C) + 4707 ": a cycle was detected in the linked chain"), 4708 this->FileName); 4709 break; 4710 } 4711 Visited[C] = true; 4712 if (MaxChain <= ++ChainLen[B]) 4713 MaxChain++; 4714 } 4715 TotalSyms += ChainLen[B]; 4716 } 4717 4718 if (!TotalSyms) 4719 return; 4720 4721 std::vector<size_t> Count(MaxChain, 0); 4722 // Count how long is the chain for each bucket 4723 for (size_t B = 0; B < NBucket; B++) 4724 ++Count[ChainLen[B]]; 4725 // Print Number of buckets with each chain lengths and their cumulative 4726 // coverage of the symbols 4727 OS << "Histogram for bucket list length (total of " << NBucket 4728 << " buckets)\n" 4729 << " Length Number % of total Coverage\n"; 4730 for (size_t I = 0; I < MaxChain; I++) { 4731 CumulativeNonZero += Count[I] * I; 4732 OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], 4733 (Count[I] * 100.0) / NBucket, 4734 (CumulativeNonZero * 100.0) / TotalSyms); 4735 } 4736 } 4737 4738 template <class ELFT> 4739 void GNUStyle<ELFT>::printGnuHashHistogram(const Elf_GnuHash &GnuHashTable) { 4740 Expected<ArrayRef<Elf_Word>> ChainsOrErr = getGnuHashTableChains<ELFT>( 4741 this->dumper()->getDynSymRegion(), &GnuHashTable); 4742 if (!ChainsOrErr) { 4743 this->reportUniqueWarning( 4744 createError("unable to print the GNU hash table histogram: " + 4745 toString(ChainsOrErr.takeError()))); 4746 return; 4747 } 4748 4749 ArrayRef<Elf_Word> Chains = *ChainsOrErr; 4750 size_t Symndx = GnuHashTable.symndx; 4751 size_t TotalSyms = 0; 4752 size_t MaxChain = 1; 4753 size_t CumulativeNonZero = 0; 4754 4755 size_t NBucket = GnuHashTable.nbuckets; 4756 if (Chains.empty() || NBucket == 0) 4757 return; 4758 4759 ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets(); 4760 std::vector<size_t> ChainLen(NBucket, 0); 4761 for (size_t B = 0; B < NBucket; B++) { 4762 if (!Buckets[B]) 4763 continue; 4764 size_t Len = 1; 4765 for (size_t C = Buckets[B] - Symndx; 4766 C < Chains.size() && (Chains[C] & 1) == 0; C++) 4767 if (MaxChain < ++Len) 4768 MaxChain++; 4769 ChainLen[B] = Len; 4770 TotalSyms += Len; 4771 } 4772 MaxChain++; 4773 4774 if (!TotalSyms) 4775 return; 4776 4777 std::vector<size_t> Count(MaxChain, 0); 4778 for (size_t B = 0; B < NBucket; B++) 4779 ++Count[ChainLen[B]]; 4780 // Print Number of buckets with each chain lengths and their cumulative 4781 // coverage of the symbols 4782 OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket 4783 << " buckets)\n" 4784 << " Length Number % of total Coverage\n"; 4785 for (size_t I = 0; I < MaxChain; I++) { 4786 CumulativeNonZero += Count[I] * I; 4787 OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], 4788 (Count[I] * 100.0) / NBucket, 4789 (CumulativeNonZero * 100.0) / TotalSyms); 4790 } 4791 } 4792 4793 // Hash histogram shows statistics of how efficient the hash was for the 4794 // dynamic symbol table. The table shows the number of hash buckets for 4795 // different lengths of chains as an absolute number and percentage of the total 4796 // buckets, and the cumulative coverage of symbols for each set of buckets. 4797 template <class ELFT> 4798 void GNUStyle<ELFT>::printHashHistograms(const ELFFile<ELFT> *Obj) { 4799 // Print histogram for the .hash section. 4800 if (const Elf_Hash *HashTable = this->dumper()->getHashTable()) { 4801 if (Error E = checkHashTable<ELFT>(Obj, HashTable)) 4802 this->reportUniqueWarning(std::move(E)); 4803 else 4804 printHashHistogram(*HashTable); 4805 } 4806 4807 // Print histogram for the .gnu.hash section. 4808 if (const Elf_GnuHash *GnuHashTable = this->dumper()->getGnuHashTable()) { 4809 if (Error E = checkGNUHashTable<ELFT>(Obj, GnuHashTable)) 4810 this->reportUniqueWarning(std::move(E)); 4811 else 4812 printGnuHashHistogram(*GnuHashTable); 4813 } 4814 } 4815 4816 template <class ELFT> 4817 void GNUStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) { 4818 OS << "GNUStyle::printCGProfile not implemented\n"; 4819 } 4820 4821 template <class ELFT> 4822 void GNUStyle<ELFT>::printAddrsig(const ELFFile<ELFT> *Obj) { 4823 reportError(createError("--addrsig: not implemented"), this->FileName); 4824 } 4825 4826 static StringRef getGenericNoteTypeName(const uint32_t NT) { 4827 static const struct { 4828 uint32_t ID; 4829 const char *Name; 4830 } Notes[] = { 4831 {ELF::NT_VERSION, "NT_VERSION (version)"}, 4832 {ELF::NT_ARCH, "NT_ARCH (architecture)"}, 4833 {ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN, "OPEN"}, 4834 {ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC, "func"}, 4835 }; 4836 4837 for (const auto &Note : Notes) 4838 if (Note.ID == NT) 4839 return Note.Name; 4840 4841 return ""; 4842 } 4843 4844 static StringRef getCoreNoteTypeName(const uint32_t NT) { 4845 static const struct { 4846 uint32_t ID; 4847 const char *Name; 4848 } Notes[] = { 4849 {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"}, 4850 {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"}, 4851 {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"}, 4852 {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"}, 4853 {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"}, 4854 {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"}, 4855 {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"}, 4856 {ELF::NT_PSINFO, "NT_PSINFO (psinfo structure)"}, 4857 {ELF::NT_LWPSTATUS, "NT_LWPSTATUS (lwpstatus_t structure)"}, 4858 {ELF::NT_LWPSINFO, "NT_LWPSINFO (lwpsinfo_t structure)"}, 4859 {ELF::NT_WIN32PSTATUS, "NT_WIN32PSTATUS (win32_pstatus structure)"}, 4860 4861 {ELF::NT_PPC_VMX, "NT_PPC_VMX (ppc Altivec registers)"}, 4862 {ELF::NT_PPC_VSX, "NT_PPC_VSX (ppc VSX registers)"}, 4863 {ELF::NT_PPC_TAR, "NT_PPC_TAR (ppc TAR register)"}, 4864 {ELF::NT_PPC_PPR, "NT_PPC_PPR (ppc PPR register)"}, 4865 {ELF::NT_PPC_DSCR, "NT_PPC_DSCR (ppc DSCR register)"}, 4866 {ELF::NT_PPC_EBB, "NT_PPC_EBB (ppc EBB registers)"}, 4867 {ELF::NT_PPC_PMU, "NT_PPC_PMU (ppc PMU registers)"}, 4868 {ELF::NT_PPC_TM_CGPR, "NT_PPC_TM_CGPR (ppc checkpointed GPR registers)"}, 4869 {ELF::NT_PPC_TM_CFPR, 4870 "NT_PPC_TM_CFPR (ppc checkpointed floating point registers)"}, 4871 {ELF::NT_PPC_TM_CVMX, 4872 "NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)"}, 4873 {ELF::NT_PPC_TM_CVSX, "NT_PPC_TM_CVSX (ppc checkpointed VSX registers)"}, 4874 {ELF::NT_PPC_TM_SPR, "NT_PPC_TM_SPR (ppc TM special purpose registers)"}, 4875 {ELF::NT_PPC_TM_CTAR, "NT_PPC_TM_CTAR (ppc checkpointed TAR register)"}, 4876 {ELF::NT_PPC_TM_CPPR, "NT_PPC_TM_CPPR (ppc checkpointed PPR register)"}, 4877 {ELF::NT_PPC_TM_CDSCR, 4878 "NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)"}, 4879 4880 {ELF::NT_386_TLS, "NT_386_TLS (x86 TLS information)"}, 4881 {ELF::NT_386_IOPERM, "NT_386_IOPERM (x86 I/O permissions)"}, 4882 {ELF::NT_X86_XSTATE, "NT_X86_XSTATE (x86 XSAVE extended state)"}, 4883 4884 {ELF::NT_S390_HIGH_GPRS, 4885 "NT_S390_HIGH_GPRS (s390 upper register halves)"}, 4886 {ELF::NT_S390_TIMER, "NT_S390_TIMER (s390 timer register)"}, 4887 {ELF::NT_S390_TODCMP, "NT_S390_TODCMP (s390 TOD comparator register)"}, 4888 {ELF::NT_S390_TODPREG, 4889 "NT_S390_TODPREG (s390 TOD programmable register)"}, 4890 {ELF::NT_S390_CTRS, "NT_S390_CTRS (s390 control registers)"}, 4891 {ELF::NT_S390_PREFIX, "NT_S390_PREFIX (s390 prefix register)"}, 4892 {ELF::NT_S390_LAST_BREAK, 4893 "NT_S390_LAST_BREAK (s390 last breaking event address)"}, 4894 {ELF::NT_S390_SYSTEM_CALL, 4895 "NT_S390_SYSTEM_CALL (s390 system call restart data)"}, 4896 {ELF::NT_S390_TDB, "NT_S390_TDB (s390 transaction diagnostic block)"}, 4897 {ELF::NT_S390_VXRS_LOW, 4898 "NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)"}, 4899 {ELF::NT_S390_VXRS_HIGH, 4900 "NT_S390_VXRS_HIGH (s390 vector registers 16-31)"}, 4901 {ELF::NT_S390_GS_CB, "NT_S390_GS_CB (s390 guarded-storage registers)"}, 4902 {ELF::NT_S390_GS_BC, 4903 "NT_S390_GS_BC (s390 guarded-storage broadcast control)"}, 4904 4905 {ELF::NT_ARM_VFP, "NT_ARM_VFP (arm VFP registers)"}, 4906 {ELF::NT_ARM_TLS, "NT_ARM_TLS (AArch TLS registers)"}, 4907 {ELF::NT_ARM_HW_BREAK, 4908 "NT_ARM_HW_BREAK (AArch hardware breakpoint registers)"}, 4909 {ELF::NT_ARM_HW_WATCH, 4910 "NT_ARM_HW_WATCH (AArch hardware watchpoint registers)"}, 4911 4912 {ELF::NT_FILE, "NT_FILE (mapped files)"}, 4913 {ELF::NT_PRXFPREG, "NT_PRXFPREG (user_xfpregs structure)"}, 4914 {ELF::NT_SIGINFO, "NT_SIGINFO (siginfo_t data)"}, 4915 }; 4916 4917 for (const auto &Note : Notes) 4918 if (Note.ID == NT) 4919 return Note.Name; 4920 4921 return ""; 4922 } 4923 4924 static std::string getGNUNoteTypeName(const uint32_t NT) { 4925 static const struct { 4926 uint32_t ID; 4927 const char *Name; 4928 } Notes[] = { 4929 {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"}, 4930 {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"}, 4931 {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"}, 4932 {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"}, 4933 {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"}, 4934 }; 4935 4936 for (const auto &Note : Notes) 4937 if (Note.ID == NT) 4938 return std::string(Note.Name); 4939 4940 std::string string; 4941 raw_string_ostream OS(string); 4942 OS << format("Unknown note type (0x%08x)", NT); 4943 return OS.str(); 4944 } 4945 4946 static std::string getFreeBSDNoteTypeName(const uint32_t NT) { 4947 static const struct { 4948 uint32_t ID; 4949 const char *Name; 4950 } Notes[] = { 4951 {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"}, 4952 {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"}, 4953 {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"}, 4954 {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"}, 4955 {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"}, 4956 {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"}, 4957 {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"}, 4958 {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"}, 4959 {ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS, 4960 "NT_PROCSTAT_PSSTRINGS (ps_strings data)"}, 4961 {ELF::NT_FREEBSD_PROCSTAT_AUXV, "NT_PROCSTAT_AUXV (auxv data)"}, 4962 }; 4963 4964 for (const auto &Note : Notes) 4965 if (Note.ID == NT) 4966 return std::string(Note.Name); 4967 4968 std::string string; 4969 raw_string_ostream OS(string); 4970 OS << format("Unknown note type (0x%08x)", NT); 4971 return OS.str(); 4972 } 4973 4974 static std::string getAMDNoteTypeName(const uint32_t NT) { 4975 static const struct { 4976 uint32_t ID; 4977 const char *Name; 4978 } Notes[] = {{ELF::NT_AMD_AMDGPU_HSA_METADATA, 4979 "NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)"}, 4980 {ELF::NT_AMD_AMDGPU_ISA, "NT_AMD_AMDGPU_ISA (ISA Version)"}, 4981 {ELF::NT_AMD_AMDGPU_PAL_METADATA, 4982 "NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)"}}; 4983 4984 for (const auto &Note : Notes) 4985 if (Note.ID == NT) 4986 return std::string(Note.Name); 4987 4988 std::string string; 4989 raw_string_ostream OS(string); 4990 OS << format("Unknown note type (0x%08x)", NT); 4991 return OS.str(); 4992 } 4993 4994 static std::string getAMDGPUNoteTypeName(const uint32_t NT) { 4995 if (NT == ELF::NT_AMDGPU_METADATA) 4996 return std::string("NT_AMDGPU_METADATA (AMDGPU Metadata)"); 4997 4998 std::string string; 4999 raw_string_ostream OS(string); 5000 OS << format("Unknown note type (0x%08x)", NT); 5001 return OS.str(); 5002 } 5003 5004 template <typename ELFT> 5005 static std::string getGNUProperty(uint32_t Type, uint32_t DataSize, 5006 ArrayRef<uint8_t> Data) { 5007 std::string str; 5008 raw_string_ostream OS(str); 5009 uint32_t PrData; 5010 auto DumpBit = [&](uint32_t Flag, StringRef Name) { 5011 if (PrData & Flag) { 5012 PrData &= ~Flag; 5013 OS << Name; 5014 if (PrData) 5015 OS << ", "; 5016 } 5017 }; 5018 5019 switch (Type) { 5020 default: 5021 OS << format("<application-specific type 0x%x>", Type); 5022 return OS.str(); 5023 case GNU_PROPERTY_STACK_SIZE: { 5024 OS << "stack size: "; 5025 if (DataSize == sizeof(typename ELFT::uint)) 5026 OS << formatv("{0:x}", 5027 (uint64_t)(*(const typename ELFT::Addr *)Data.data())); 5028 else 5029 OS << format("<corrupt length: 0x%x>", DataSize); 5030 return OS.str(); 5031 } 5032 case GNU_PROPERTY_NO_COPY_ON_PROTECTED: 5033 OS << "no copy on protected"; 5034 if (DataSize) 5035 OS << format(" <corrupt length: 0x%x>", DataSize); 5036 return OS.str(); 5037 case GNU_PROPERTY_AARCH64_FEATURE_1_AND: 5038 case GNU_PROPERTY_X86_FEATURE_1_AND: 5039 OS << ((Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) ? "aarch64 feature: " 5040 : "x86 feature: "); 5041 if (DataSize != 4) { 5042 OS << format("<corrupt length: 0x%x>", DataSize); 5043 return OS.str(); 5044 } 5045 PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); 5046 if (PrData == 0) { 5047 OS << "<None>"; 5048 return OS.str(); 5049 } 5050 if (Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) { 5051 DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_BTI, "BTI"); 5052 DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_PAC, "PAC"); 5053 } else { 5054 DumpBit(GNU_PROPERTY_X86_FEATURE_1_IBT, "IBT"); 5055 DumpBit(GNU_PROPERTY_X86_FEATURE_1_SHSTK, "SHSTK"); 5056 } 5057 if (PrData) 5058 OS << format("<unknown flags: 0x%x>", PrData); 5059 return OS.str(); 5060 case GNU_PROPERTY_X86_ISA_1_NEEDED: 5061 case GNU_PROPERTY_X86_ISA_1_USED: 5062 OS << "x86 ISA " 5063 << (Type == GNU_PROPERTY_X86_ISA_1_NEEDED ? "needed: " : "used: "); 5064 if (DataSize != 4) { 5065 OS << format("<corrupt length: 0x%x>", DataSize); 5066 return OS.str(); 5067 } 5068 PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); 5069 if (PrData == 0) { 5070 OS << "<None>"; 5071 return OS.str(); 5072 } 5073 DumpBit(GNU_PROPERTY_X86_ISA_1_CMOV, "CMOV"); 5074 DumpBit(GNU_PROPERTY_X86_ISA_1_SSE, "SSE"); 5075 DumpBit(GNU_PROPERTY_X86_ISA_1_SSE2, "SSE2"); 5076 DumpBit(GNU_PROPERTY_X86_ISA_1_SSE3, "SSE3"); 5077 DumpBit(GNU_PROPERTY_X86_ISA_1_SSSE3, "SSSE3"); 5078 DumpBit(GNU_PROPERTY_X86_ISA_1_SSE4_1, "SSE4_1"); 5079 DumpBit(GNU_PROPERTY_X86_ISA_1_SSE4_2, "SSE4_2"); 5080 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX, "AVX"); 5081 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX2, "AVX2"); 5082 DumpBit(GNU_PROPERTY_X86_ISA_1_FMA, "FMA"); 5083 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512F, "AVX512F"); 5084 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512CD, "AVX512CD"); 5085 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512ER, "AVX512ER"); 5086 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512PF, "AVX512PF"); 5087 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512VL, "AVX512VL"); 5088 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512DQ, "AVX512DQ"); 5089 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512BW, "AVX512BW"); 5090 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS, "AVX512_4FMAPS"); 5091 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW, "AVX512_4VNNIW"); 5092 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_BITALG, "AVX512_BITALG"); 5093 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_IFMA, "AVX512_IFMA"); 5094 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VBMI, "AVX512_VBMI"); 5095 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2, "AVX512_VBMI2"); 5096 DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VNNI, "AVX512_VNNI"); 5097 if (PrData) 5098 OS << format("<unknown flags: 0x%x>", PrData); 5099 return OS.str(); 5100 break; 5101 case GNU_PROPERTY_X86_FEATURE_2_NEEDED: 5102 case GNU_PROPERTY_X86_FEATURE_2_USED: 5103 OS << "x86 feature " 5104 << (Type == GNU_PROPERTY_X86_FEATURE_2_NEEDED ? "needed: " : "used: "); 5105 if (DataSize != 4) { 5106 OS << format("<corrupt length: 0x%x>", DataSize); 5107 return OS.str(); 5108 } 5109 PrData = support::endian::read32<ELFT::TargetEndianness>(Data.data()); 5110 if (PrData == 0) { 5111 OS << "<None>"; 5112 return OS.str(); 5113 } 5114 DumpBit(GNU_PROPERTY_X86_FEATURE_2_X86, "x86"); 5115 DumpBit(GNU_PROPERTY_X86_FEATURE_2_X87, "x87"); 5116 DumpBit(GNU_PROPERTY_X86_FEATURE_2_MMX, "MMX"); 5117 DumpBit(GNU_PROPERTY_X86_FEATURE_2_XMM, "XMM"); 5118 DumpBit(GNU_PROPERTY_X86_FEATURE_2_YMM, "YMM"); 5119 DumpBit(GNU_PROPERTY_X86_FEATURE_2_ZMM, "ZMM"); 5120 DumpBit(GNU_PROPERTY_X86_FEATURE_2_FXSR, "FXSR"); 5121 DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVE, "XSAVE"); 5122 DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT, "XSAVEOPT"); 5123 DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEC, "XSAVEC"); 5124 if (PrData) 5125 OS << format("<unknown flags: 0x%x>", PrData); 5126 return OS.str(); 5127 } 5128 } 5129 5130 template <typename ELFT> 5131 static SmallVector<std::string, 4> getGNUPropertyList(ArrayRef<uint8_t> Arr) { 5132 using Elf_Word = typename ELFT::Word; 5133 5134 SmallVector<std::string, 4> Properties; 5135 while (Arr.size() >= 8) { 5136 uint32_t Type = *reinterpret_cast<const Elf_Word *>(Arr.data()); 5137 uint32_t DataSize = *reinterpret_cast<const Elf_Word *>(Arr.data() + 4); 5138 Arr = Arr.drop_front(8); 5139 5140 // Take padding size into account if present. 5141 uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint)); 5142 std::string str; 5143 raw_string_ostream OS(str); 5144 if (Arr.size() < PaddedSize) { 5145 OS << format("<corrupt type (0x%x) datasz: 0x%x>", Type, DataSize); 5146 Properties.push_back(OS.str()); 5147 break; 5148 } 5149 Properties.push_back( 5150 getGNUProperty<ELFT>(Type, DataSize, Arr.take_front(PaddedSize))); 5151 Arr = Arr.drop_front(PaddedSize); 5152 } 5153 5154 if (!Arr.empty()) 5155 Properties.push_back("<corrupted GNU_PROPERTY_TYPE_0>"); 5156 5157 return Properties; 5158 } 5159 5160 struct GNUAbiTag { 5161 std::string OSName; 5162 std::string ABI; 5163 bool IsValid; 5164 }; 5165 5166 template <typename ELFT> static GNUAbiTag getGNUAbiTag(ArrayRef<uint8_t> Desc) { 5167 typedef typename ELFT::Word Elf_Word; 5168 5169 ArrayRef<Elf_Word> Words(reinterpret_cast<const Elf_Word *>(Desc.begin()), 5170 reinterpret_cast<const Elf_Word *>(Desc.end())); 5171 5172 if (Words.size() < 4) 5173 return {"", "", /*IsValid=*/false}; 5174 5175 static const char *OSNames[] = { 5176 "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl", 5177 }; 5178 StringRef OSName = "Unknown"; 5179 if (Words[0] < array_lengthof(OSNames)) 5180 OSName = OSNames[Words[0]]; 5181 uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3]; 5182 std::string str; 5183 raw_string_ostream ABI(str); 5184 ABI << Major << "." << Minor << "." << Patch; 5185 return {std::string(OSName), ABI.str(), /*IsValid=*/true}; 5186 } 5187 5188 static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) { 5189 std::string str; 5190 raw_string_ostream OS(str); 5191 for (const auto &B : Desc) 5192 OS << format_hex_no_prefix(B, 2); 5193 return OS.str(); 5194 } 5195 5196 static StringRef getGNUGoldVersion(ArrayRef<uint8_t> Desc) { 5197 return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); 5198 } 5199 5200 template <typename ELFT> 5201 static void printGNUNote(raw_ostream &OS, uint32_t NoteType, 5202 ArrayRef<uint8_t> Desc) { 5203 switch (NoteType) { 5204 default: 5205 return; 5206 case ELF::NT_GNU_ABI_TAG: { 5207 const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); 5208 if (!AbiTag.IsValid) 5209 OS << " <corrupt GNU_ABI_TAG>"; 5210 else 5211 OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI; 5212 break; 5213 } 5214 case ELF::NT_GNU_BUILD_ID: { 5215 OS << " Build ID: " << getGNUBuildId(Desc); 5216 break; 5217 } 5218 case ELF::NT_GNU_GOLD_VERSION: 5219 OS << " Version: " << getGNUGoldVersion(Desc); 5220 break; 5221 case ELF::NT_GNU_PROPERTY_TYPE_0: 5222 OS << " Properties:"; 5223 for (const auto &Property : getGNUPropertyList<ELFT>(Desc)) 5224 OS << " " << Property << "\n"; 5225 break; 5226 } 5227 OS << '\n'; 5228 } 5229 5230 struct AMDNote { 5231 std::string Type; 5232 std::string Value; 5233 }; 5234 5235 template <typename ELFT> 5236 static AMDNote getAMDNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { 5237 switch (NoteType) { 5238 default: 5239 return {"", ""}; 5240 case ELF::NT_AMD_AMDGPU_HSA_METADATA: 5241 return { 5242 "HSA Metadata", 5243 std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())}; 5244 case ELF::NT_AMD_AMDGPU_ISA: 5245 return { 5246 "ISA Version", 5247 std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())}; 5248 } 5249 } 5250 5251 struct AMDGPUNote { 5252 std::string Type; 5253 std::string Value; 5254 }; 5255 5256 template <typename ELFT> 5257 static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) { 5258 switch (NoteType) { 5259 default: 5260 return {"", ""}; 5261 case ELF::NT_AMDGPU_METADATA: { 5262 auto MsgPackString = 5263 StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size()); 5264 msgpack::Document MsgPackDoc; 5265 if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false)) 5266 return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"}; 5267 5268 AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true); 5269 if (!Verifier.verify(MsgPackDoc.getRoot())) 5270 return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"}; 5271 5272 std::string HSAMetadataString; 5273 raw_string_ostream StrOS(HSAMetadataString); 5274 MsgPackDoc.toYAML(StrOS); 5275 5276 return {"AMDGPU Metadata", StrOS.str()}; 5277 } 5278 } 5279 } 5280 5281 struct CoreFileMapping { 5282 uint64_t Start, End, Offset; 5283 StringRef Filename; 5284 }; 5285 5286 struct CoreNote { 5287 uint64_t PageSize; 5288 std::vector<CoreFileMapping> Mappings; 5289 }; 5290 5291 static Expected<CoreNote> readCoreNote(DataExtractor Desc) { 5292 // Expected format of the NT_FILE note description: 5293 // 1. # of file mappings (call it N) 5294 // 2. Page size 5295 // 3. N (start, end, offset) triples 5296 // 4. N packed filenames (null delimited) 5297 // Each field is an Elf_Addr, except for filenames which are char* strings. 5298 5299 CoreNote Ret; 5300 const int Bytes = Desc.getAddressSize(); 5301 5302 if (!Desc.isValidOffsetForAddress(2)) 5303 return createStringError(object_error::parse_failed, 5304 "malformed note: header too short"); 5305 if (Desc.getData().back() != 0) 5306 return createStringError(object_error::parse_failed, 5307 "malformed note: not NUL terminated"); 5308 5309 uint64_t DescOffset = 0; 5310 uint64_t FileCount = Desc.getAddress(&DescOffset); 5311 Ret.PageSize = Desc.getAddress(&DescOffset); 5312 5313 if (!Desc.isValidOffsetForAddress(3 * FileCount * Bytes)) 5314 return createStringError(object_error::parse_failed, 5315 "malformed note: too short for number of files"); 5316 5317 uint64_t FilenamesOffset = 0; 5318 DataExtractor Filenames( 5319 Desc.getData().drop_front(DescOffset + 3 * FileCount * Bytes), 5320 Desc.isLittleEndian(), Desc.getAddressSize()); 5321 5322 Ret.Mappings.resize(FileCount); 5323 for (CoreFileMapping &Mapping : Ret.Mappings) { 5324 if (!Filenames.isValidOffsetForDataOfSize(FilenamesOffset, 1)) 5325 return createStringError(object_error::parse_failed, 5326 "malformed note: too few filenames"); 5327 Mapping.Start = Desc.getAddress(&DescOffset); 5328 Mapping.End = Desc.getAddress(&DescOffset); 5329 Mapping.Offset = Desc.getAddress(&DescOffset); 5330 Mapping.Filename = Filenames.getCStrRef(&FilenamesOffset); 5331 } 5332 5333 return Ret; 5334 } 5335 5336 template <typename ELFT> 5337 static void printCoreNote(raw_ostream &OS, const CoreNote &Note) { 5338 // Length of "0x<address>" string. 5339 const int FieldWidth = ELFT::Is64Bits ? 18 : 10; 5340 5341 OS << " Page size: " << format_decimal(Note.PageSize, 0) << '\n'; 5342 OS << " " << right_justify("Start", FieldWidth) << " " 5343 << right_justify("End", FieldWidth) << " " 5344 << right_justify("Page Offset", FieldWidth) << '\n'; 5345 for (const CoreFileMapping &Mapping : Note.Mappings) { 5346 OS << " " << format_hex(Mapping.Start, FieldWidth) << " " 5347 << format_hex(Mapping.End, FieldWidth) << " " 5348 << format_hex(Mapping.Offset, FieldWidth) << "\n " 5349 << Mapping.Filename << '\n'; 5350 } 5351 } 5352 5353 template <class ELFT> 5354 void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) { 5355 auto PrintHeader = [&](Optional<StringRef> SecName, 5356 const typename ELFT::Off Offset, 5357 const typename ELFT::Addr Size) { 5358 OS << "Displaying notes found "; 5359 5360 if (SecName) 5361 OS << "in: " << *SecName << "\n"; 5362 else 5363 OS << "at file offset " << format_hex(Offset, 10) << " with length " 5364 << format_hex(Size, 10) << ":\n"; 5365 5366 OS << " Owner Data size \tDescription\n"; 5367 }; 5368 5369 auto ProcessNote = [&](const Elf_Note &Note) { 5370 StringRef Name = Note.getName(); 5371 ArrayRef<uint8_t> Descriptor = Note.getDesc(); 5372 Elf_Word Type = Note.getType(); 5373 5374 // Print the note owner/type. 5375 OS << " " << left_justify(Name, 20) << ' ' 5376 << format_hex(Descriptor.size(), 10) << '\t'; 5377 if (Name == "GNU") { 5378 OS << getGNUNoteTypeName(Type) << '\n'; 5379 } else if (Name == "FreeBSD") { 5380 OS << getFreeBSDNoteTypeName(Type) << '\n'; 5381 } else if (Name == "AMD") { 5382 OS << getAMDNoteTypeName(Type) << '\n'; 5383 } else if (Name == "AMDGPU") { 5384 OS << getAMDGPUNoteTypeName(Type) << '\n'; 5385 } else { 5386 StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE 5387 ? getCoreNoteTypeName(Type) 5388 : getGenericNoteTypeName(Type); 5389 if (!NoteType.empty()) 5390 OS << NoteType << '\n'; 5391 else 5392 OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n"; 5393 } 5394 5395 // Print the description, or fallback to printing raw bytes for unknown 5396 // owners. 5397 if (Name == "GNU") { 5398 printGNUNote<ELFT>(OS, Type, Descriptor); 5399 } else if (Name == "AMD") { 5400 const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); 5401 if (!N.Type.empty()) 5402 OS << " " << N.Type << ":\n " << N.Value << '\n'; 5403 } else if (Name == "AMDGPU") { 5404 const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); 5405 if (!N.Type.empty()) 5406 OS << " " << N.Type << ":\n " << N.Value << '\n'; 5407 } else if (Name == "CORE") { 5408 if (Type == ELF::NT_FILE) { 5409 DataExtractor DescExtractor(Descriptor, 5410 ELFT::TargetEndianness == support::little, 5411 sizeof(Elf_Addr)); 5412 Expected<CoreNote> Note = readCoreNote(DescExtractor); 5413 if (Note) 5414 printCoreNote<ELFT>(OS, *Note); 5415 else 5416 reportWarning(Note.takeError(), this->FileName); 5417 } 5418 } else if (!Descriptor.empty()) { 5419 OS << " description data:"; 5420 for (uint8_t B : Descriptor) 5421 OS << " " << format("%02x", B); 5422 OS << '\n'; 5423 } 5424 }; 5425 5426 ArrayRef<Elf_Shdr> Sections = cantFail(Obj->sections()); 5427 if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) { 5428 for (const auto &S : Sections) { 5429 if (S.sh_type != SHT_NOTE) 5430 continue; 5431 PrintHeader(expectedToOptional(Obj->getSectionName(&S)), S.sh_offset, 5432 S.sh_size); 5433 Error Err = Error::success(); 5434 for (auto Note : Obj->notes(S, Err)) 5435 ProcessNote(Note); 5436 if (Err) 5437 reportError(std::move(Err), this->FileName); 5438 } 5439 } else { 5440 Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers(); 5441 if (!PhdrsOrErr) { 5442 this->reportUniqueWarning(createError( 5443 "unable to read program headers to locate the PT_NOTE segment: " + 5444 toString(PhdrsOrErr.takeError()))); 5445 return; 5446 } 5447 5448 for (const Elf_Phdr &P : *PhdrsOrErr) { 5449 if (P.p_type != PT_NOTE) 5450 continue; 5451 PrintHeader(/*SecName=*/None, P.p_offset, P.p_filesz); 5452 Error Err = Error::success(); 5453 for (auto Note : Obj->notes(P, Err)) 5454 ProcessNote(Note); 5455 if (Err) 5456 reportError(std::move(Err), this->FileName); 5457 } 5458 } 5459 } 5460 5461 template <class ELFT> 5462 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) { 5463 OS << "printELFLinkerOptions not implemented!\n"; 5464 } 5465 5466 template <class ELFT> 5467 void DumpStyle<ELFT>::printDependentLibsHelper( 5468 const ELFFile<ELFT> *Obj, 5469 function_ref<void(const Elf_Shdr &)> OnSectionStart, 5470 function_ref<void(StringRef, uint64_t)> OnLibEntry) { 5471 auto Warn = [this](unsigned SecNdx, StringRef Msg) { 5472 this->reportUniqueWarning( 5473 createError("SHT_LLVM_DEPENDENT_LIBRARIES section at index " + 5474 Twine(SecNdx) + " is broken: " + Msg)); 5475 }; 5476 5477 unsigned I = -1; 5478 for (const Elf_Shdr &Shdr : cantFail(Obj->sections())) { 5479 ++I; 5480 if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES) 5481 continue; 5482 5483 OnSectionStart(Shdr); 5484 5485 Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(&Shdr); 5486 if (!ContentsOrErr) { 5487 Warn(I, toString(ContentsOrErr.takeError())); 5488 continue; 5489 } 5490 5491 ArrayRef<uint8_t> Contents = *ContentsOrErr; 5492 if (!Contents.empty() && Contents.back() != 0) { 5493 Warn(I, "the content is not null-terminated"); 5494 continue; 5495 } 5496 5497 for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) { 5498 StringRef Lib((const char *)I); 5499 OnLibEntry(Lib, I - Contents.begin()); 5500 I += Lib.size() + 1; 5501 } 5502 } 5503 } 5504 5505 template <class ELFT> 5506 void DumpStyle<ELFT>::printRelocationsHelper(const ELFFile<ELFT> *Obj, 5507 const Elf_Shdr &Sec) { 5508 const Elf_Shdr *SymTab = 5509 unwrapOrError(this->FileName, Obj->getSection(Sec.sh_link)); 5510 unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front(); 5511 unsigned RelNdx = 0; 5512 5513 switch (Sec.sh_type) { 5514 case ELF::SHT_REL: 5515 for (const Elf_Rel &R : unwrapOrError(this->FileName, Obj->rels(&Sec))) 5516 printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx); 5517 break; 5518 case ELF::SHT_RELA: 5519 for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->relas(&Sec))) 5520 printRelaReloc(Obj, SecNdx, SymTab, R, ++RelNdx); 5521 break; 5522 case ELF::SHT_RELR: 5523 case ELF::SHT_ANDROID_RELR: { 5524 Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(&Sec)); 5525 if (opts::RawRelr) { 5526 for (const Elf_Relr &R : Relrs) 5527 printRelrReloc(R); 5528 break; 5529 } 5530 std::vector<Elf_Rel> RelrRels = 5531 unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); 5532 for (const Elf_Rel &R : RelrRels) 5533 printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx); 5534 break; 5535 } 5536 case ELF::SHT_ANDROID_REL: 5537 case ELF::SHT_ANDROID_RELA: 5538 for (const Elf_Rela &R : 5539 unwrapOrError(this->FileName, Obj->android_relas(&Sec))) 5540 printRelaReloc(Obj, SecNdx, SymTab, R, ++RelNdx); 5541 break; 5542 } 5543 } 5544 5545 template <class ELFT> 5546 StringRef DumpStyle<ELFT>::getPrintableSectionName(const ELFFile<ELFT> *Obj, 5547 const Elf_Shdr &Sec) const { 5548 StringRef Name = "<?>"; 5549 if (Expected<StringRef> SecNameOrErr = 5550 Obj->getSectionName(&Sec, this->dumper()->WarningHandler)) 5551 Name = *SecNameOrErr; 5552 else 5553 this->reportUniqueWarning(createError("unable to get the name of " + 5554 describe(Obj, Sec) + ": " + 5555 toString(SecNameOrErr.takeError()))); 5556 return Name; 5557 } 5558 5559 template <class ELFT> 5560 void GNUStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) { 5561 bool SectionStarted = false; 5562 struct NameOffset { 5563 StringRef Name; 5564 uint64_t Offset; 5565 }; 5566 std::vector<NameOffset> SecEntries; 5567 NameOffset Current; 5568 auto PrintSection = [&]() { 5569 OS << "Dependent libraries section " << Current.Name << " at offset " 5570 << format_hex(Current.Offset, 1) << " contains " << SecEntries.size() 5571 << " entries:\n"; 5572 for (NameOffset Entry : SecEntries) 5573 OS << " [" << format("%6tx", Entry.Offset) << "] " << Entry.Name 5574 << "\n"; 5575 OS << "\n"; 5576 SecEntries.clear(); 5577 }; 5578 5579 auto OnSectionStart = [&](const Elf_Shdr &Shdr) { 5580 if (SectionStarted) 5581 PrintSection(); 5582 SectionStarted = true; 5583 Current.Offset = Shdr.sh_offset; 5584 Current.Name = this->getPrintableSectionName(Obj, Shdr); 5585 }; 5586 auto OnLibEntry = [&](StringRef Lib, uint64_t Offset) { 5587 SecEntries.push_back(NameOffset{Lib, Offset}); 5588 }; 5589 5590 this->printDependentLibsHelper(Obj, OnSectionStart, OnLibEntry); 5591 if (SectionStarted) 5592 PrintSection(); 5593 } 5594 5595 // Used for printing section names in places where possible errors can be 5596 // ignored. 5597 static StringRef getSectionName(const SectionRef &Sec) { 5598 Expected<StringRef> NameOrErr = Sec.getName(); 5599 if (NameOrErr) 5600 return *NameOrErr; 5601 consumeError(NameOrErr.takeError()); 5602 return "<?>"; 5603 } 5604 5605 // Used for printing symbol names in places where possible errors can be 5606 // ignored. 5607 static std::string getSymbolName(const ELFSymbolRef &Sym) { 5608 Expected<StringRef> NameOrErr = Sym.getName(); 5609 if (NameOrErr) 5610 return maybeDemangle(*NameOrErr); 5611 consumeError(NameOrErr.takeError()); 5612 return "<?>"; 5613 } 5614 5615 template <class ELFT> 5616 void DumpStyle<ELFT>::printFunctionStackSize(const ELFObjectFile<ELFT> *Obj, 5617 uint64_t SymValue, 5618 Optional<SectionRef> FunctionSec, 5619 const StringRef SectionName, 5620 DataExtractor Data, 5621 uint64_t *Offset) { 5622 // This function ignores potentially erroneous input, unless it is directly 5623 // related to stack size reporting. 5624 SymbolRef FuncSym; 5625 for (const ELFSymbolRef &Symbol : Obj->symbols()) { 5626 Expected<uint64_t> SymAddrOrErr = Symbol.getAddress(); 5627 if (!SymAddrOrErr) { 5628 consumeError(SymAddrOrErr.takeError()); 5629 continue; 5630 } 5631 if (Expected<uint32_t> SymFlags = Symbol.getFlags()) { 5632 if (*SymFlags & SymbolRef::SF_Undefined) 5633 continue; 5634 } else 5635 consumeError(SymFlags.takeError()); 5636 if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) { 5637 // Check if the symbol is in the right section. FunctionSec == None means 5638 // "any section". 5639 if (!FunctionSec || FunctionSec->containsSymbol(Symbol)) { 5640 FuncSym = Symbol; 5641 break; 5642 } 5643 } 5644 } 5645 5646 std::string FuncName = "?"; 5647 // A valid SymbolRef has a non-null object file pointer. 5648 if (FuncSym.BasicSymbolRef::getObject()) 5649 FuncName = getSymbolName(FuncSym); 5650 else 5651 reportWarning( 5652 createError("could not identify function symbol for stack size entry"), 5653 Obj->getFileName()); 5654 5655 // Extract the size. The expectation is that Offset is pointing to the right 5656 // place, i.e. past the function address. 5657 uint64_t PrevOffset = *Offset; 5658 uint64_t StackSize = Data.getULEB128(Offset); 5659 // getULEB128() does not advance Offset if it is not able to extract a valid 5660 // integer. 5661 if (*Offset == PrevOffset) 5662 reportError( 5663 createStringError(object_error::parse_failed, 5664 "could not extract a valid stack size in section %s", 5665 SectionName.data()), 5666 Obj->getFileName()); 5667 5668 printStackSizeEntry(StackSize, FuncName); 5669 } 5670 5671 template <class ELFT> 5672 void GNUStyle<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) { 5673 OS.PadToColumn(2); 5674 OS << format_decimal(Size, 11); 5675 OS.PadToColumn(18); 5676 OS << FuncName << "\n"; 5677 } 5678 5679 template <class ELFT> 5680 void DumpStyle<ELFT>::printStackSize(const ELFObjectFile<ELFT> *Obj, 5681 RelocationRef Reloc, 5682 SectionRef FunctionSec, 5683 const StringRef &StackSizeSectionName, 5684 const RelocationResolver &Resolver, 5685 DataExtractor Data) { 5686 // This function ignores potentially erroneous input, unless it is directly 5687 // related to stack size reporting. 5688 object::symbol_iterator RelocSym = Reloc.getSymbol(); 5689 uint64_t RelocSymValue = 0; 5690 StringRef FileStr = Obj->getFileName(); 5691 if (RelocSym != Obj->symbol_end()) { 5692 // Ensure that the relocation symbol is in the function section, i.e. the 5693 // section where the functions whose stack sizes we are reporting are 5694 // located. 5695 auto SectionOrErr = RelocSym->getSection(); 5696 if (!SectionOrErr) { 5697 reportWarning( 5698 createError("cannot identify the section for relocation symbol '" + 5699 getSymbolName(*RelocSym) + "'"), 5700 FileStr); 5701 consumeError(SectionOrErr.takeError()); 5702 } else if (*SectionOrErr != FunctionSec) { 5703 reportWarning(createError("relocation symbol '" + 5704 getSymbolName(*RelocSym) + 5705 "' is not in the expected section"), 5706 FileStr); 5707 // Pretend that the symbol is in the correct section and report its 5708 // stack size anyway. 5709 FunctionSec = **SectionOrErr; 5710 } 5711 5712 Expected<uint64_t> RelocSymValueOrErr = RelocSym->getValue(); 5713 if (RelocSymValueOrErr) 5714 RelocSymValue = *RelocSymValueOrErr; 5715 else 5716 consumeError(RelocSymValueOrErr.takeError()); 5717 } 5718 5719 uint64_t Offset = Reloc.getOffset(); 5720 if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) 5721 reportError( 5722 createStringError(object_error::parse_failed, 5723 "found invalid relocation offset into section %s " 5724 "while trying to extract a stack size entry", 5725 StackSizeSectionName.data()), 5726 FileStr); 5727 5728 uint64_t Addend = Data.getAddress(&Offset); 5729 uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend); 5730 this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName, 5731 Data, &Offset); 5732 } 5733 5734 template <class ELFT> 5735 void DumpStyle<ELFT>::printNonRelocatableStackSizes( 5736 const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) { 5737 // This function ignores potentially erroneous input, unless it is directly 5738 // related to stack size reporting. 5739 const ELFFile<ELFT> *EF = Obj->getELFFile(); 5740 StringRef FileStr = Obj->getFileName(); 5741 for (const SectionRef &Sec : Obj->sections()) { 5742 StringRef SectionName = getSectionName(Sec); 5743 if (SectionName != ".stack_sizes") 5744 continue; 5745 PrintHeader(); 5746 const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl()); 5747 ArrayRef<uint8_t> Contents = 5748 unwrapOrError(this->FileName, EF->getSectionContents(ElfSec)); 5749 DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr)); 5750 uint64_t Offset = 0; 5751 while (Offset < Contents.size()) { 5752 // The function address is followed by a ULEB representing the stack 5753 // size. Check for an extra byte before we try to process the entry. 5754 if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { 5755 reportError( 5756 createStringError( 5757 object_error::parse_failed, 5758 "section %s ended while trying to extract a stack size entry", 5759 SectionName.data()), 5760 FileStr); 5761 } 5762 uint64_t SymValue = Data.getAddress(&Offset); 5763 printFunctionStackSize(Obj, SymValue, /*FunctionSec=*/None, SectionName, 5764 Data, &Offset); 5765 } 5766 } 5767 } 5768 5769 template <class ELFT> 5770 void DumpStyle<ELFT>::printRelocatableStackSizes( 5771 const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) { 5772 const ELFFile<ELFT> *EF = Obj->getELFFile(); 5773 5774 // Build a map between stack size sections and their corresponding relocation 5775 // sections. 5776 llvm::MapVector<SectionRef, SectionRef> StackSizeRelocMap; 5777 const SectionRef NullSection{}; 5778 5779 for (const SectionRef &Sec : Obj->sections()) { 5780 StringRef SectionName; 5781 if (Expected<StringRef> NameOrErr = Sec.getName()) 5782 SectionName = *NameOrErr; 5783 else 5784 consumeError(NameOrErr.takeError()); 5785 5786 // A stack size section that we haven't encountered yet is mapped to the 5787 // null section until we find its corresponding relocation section. 5788 if (SectionName == ".stack_sizes") 5789 if (StackSizeRelocMap.count(Sec) == 0) { 5790 StackSizeRelocMap[Sec] = NullSection; 5791 continue; 5792 } 5793 5794 // Check relocation sections if they are relocating contents of a 5795 // stack sizes section. 5796 const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl()); 5797 uint32_t SectionType = ElfSec->sh_type; 5798 if (SectionType != ELF::SHT_RELA && SectionType != ELF::SHT_REL) 5799 continue; 5800 5801 Expected<section_iterator> RelSecOrErr = Sec.getRelocatedSection(); 5802 if (!RelSecOrErr) 5803 reportError(createStringError(object_error::parse_failed, 5804 "%s: failed to get a relocated section: %s", 5805 SectionName.data(), 5806 toString(RelSecOrErr.takeError()).c_str()), 5807 Obj->getFileName()); 5808 5809 const Elf_Shdr *ContentsSec = 5810 Obj->getSection((*RelSecOrErr)->getRawDataRefImpl()); 5811 Expected<StringRef> ContentsSectionNameOrErr = 5812 EF->getSectionName(ContentsSec); 5813 if (!ContentsSectionNameOrErr) { 5814 consumeError(ContentsSectionNameOrErr.takeError()); 5815 continue; 5816 } 5817 if (*ContentsSectionNameOrErr != ".stack_sizes") 5818 continue; 5819 // Insert a mapping from the stack sizes section to its relocation section. 5820 StackSizeRelocMap[Obj->toSectionRef(ContentsSec)] = Sec; 5821 } 5822 5823 for (const auto &StackSizeMapEntry : StackSizeRelocMap) { 5824 PrintHeader(); 5825 const SectionRef &StackSizesSec = StackSizeMapEntry.first; 5826 const SectionRef &RelocSec = StackSizeMapEntry.second; 5827 5828 // Warn about stack size sections without a relocation section. 5829 StringRef StackSizeSectionName = getSectionName(StackSizesSec); 5830 if (RelocSec == NullSection) { 5831 reportWarning(createError("section " + StackSizeSectionName + 5832 " does not have a corresponding " 5833 "relocation section"), 5834 Obj->getFileName()); 5835 continue; 5836 } 5837 5838 // A .stack_sizes section header's sh_link field is supposed to point 5839 // to the section that contains the functions whose stack sizes are 5840 // described in it. 5841 const Elf_Shdr *StackSizesELFSec = 5842 Obj->getSection(StackSizesSec.getRawDataRefImpl()); 5843 const SectionRef FunctionSec = Obj->toSectionRef(unwrapOrError( 5844 this->FileName, EF->getSection(StackSizesELFSec->sh_link))); 5845 5846 bool (*IsSupportedFn)(uint64_t); 5847 RelocationResolver Resolver; 5848 std::tie(IsSupportedFn, Resolver) = getRelocationResolver(*Obj); 5849 auto Contents = unwrapOrError(this->FileName, StackSizesSec.getContents()); 5850 DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr)); 5851 for (const RelocationRef &Reloc : RelocSec.relocations()) { 5852 if (!IsSupportedFn || !IsSupportedFn(Reloc.getType())) 5853 reportError(createStringError( 5854 object_error::parse_failed, 5855 "unsupported relocation type in section %s: %s", 5856 getSectionName(RelocSec).data(), 5857 EF->getRelocationTypeName(Reloc.getType()).data()), 5858 Obj->getFileName()); 5859 this->printStackSize(Obj, Reloc, FunctionSec, StackSizeSectionName, 5860 Resolver, Data); 5861 } 5862 } 5863 } 5864 5865 template <class ELFT> 5866 void GNUStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) { 5867 bool HeaderHasBeenPrinted = false; 5868 auto PrintHeader = [&]() { 5869 if (HeaderHasBeenPrinted) 5870 return; 5871 OS << "\nStack Sizes:\n"; 5872 OS.PadToColumn(9); 5873 OS << "Size"; 5874 OS.PadToColumn(18); 5875 OS << "Function\n"; 5876 HeaderHasBeenPrinted = true; 5877 }; 5878 5879 // For non-relocatable objects, look directly for sections whose name starts 5880 // with .stack_sizes and process the contents. 5881 if (Obj->isRelocatableObject()) 5882 this->printRelocatableStackSizes(Obj, PrintHeader); 5883 else 5884 this->printNonRelocatableStackSizes(Obj, PrintHeader); 5885 } 5886 5887 template <class ELFT> 5888 void GNUStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { 5889 size_t Bias = ELFT::Is64Bits ? 8 : 0; 5890 auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { 5891 OS.PadToColumn(2); 5892 OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias); 5893 OS.PadToColumn(11 + Bias); 5894 OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)"; 5895 OS.PadToColumn(22 + Bias); 5896 OS << format_hex_no_prefix(*E, 8 + Bias); 5897 OS.PadToColumn(31 + 2 * Bias); 5898 OS << Purpose << "\n"; 5899 }; 5900 5901 OS << (Parser.IsStatic ? "Static GOT:\n" : "Primary GOT:\n"); 5902 OS << " Canonical gp value: " 5903 << format_hex_no_prefix(Parser.getGp(), 8 + Bias) << "\n\n"; 5904 5905 OS << " Reserved entries:\n"; 5906 if (ELFT::Is64Bits) 5907 OS << " Address Access Initial Purpose\n"; 5908 else 5909 OS << " Address Access Initial Purpose\n"; 5910 PrintEntry(Parser.getGotLazyResolver(), "Lazy resolver"); 5911 if (Parser.getGotModulePointer()) 5912 PrintEntry(Parser.getGotModulePointer(), "Module pointer (GNU extension)"); 5913 5914 if (!Parser.getLocalEntries().empty()) { 5915 OS << "\n"; 5916 OS << " Local entries:\n"; 5917 if (ELFT::Is64Bits) 5918 OS << " Address Access Initial\n"; 5919 else 5920 OS << " Address Access Initial\n"; 5921 for (auto &E : Parser.getLocalEntries()) 5922 PrintEntry(&E, ""); 5923 } 5924 5925 if (Parser.IsStatic) 5926 return; 5927 5928 if (!Parser.getGlobalEntries().empty()) { 5929 OS << "\n"; 5930 OS << " Global entries:\n"; 5931 if (ELFT::Is64Bits) 5932 OS << " Address Access Initial Sym.Val." 5933 << " Type Ndx Name\n"; 5934 else 5935 OS << " Address Access Initial Sym.Val. Type Ndx Name\n"; 5936 for (auto &E : Parser.getGlobalEntries()) { 5937 const Elf_Sym *Sym = Parser.getGotSym(&E); 5938 std::string SymName = this->dumper()->getFullSymbolName( 5939 Sym, this->dumper()->getDynamicStringTable(), false); 5940 5941 OS.PadToColumn(2); 5942 OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias)); 5943 OS.PadToColumn(11 + Bias); 5944 OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)"; 5945 OS.PadToColumn(22 + Bias); 5946 OS << to_string(format_hex_no_prefix(E, 8 + Bias)); 5947 OS.PadToColumn(31 + 2 * Bias); 5948 OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias)); 5949 OS.PadToColumn(40 + 3 * Bias); 5950 OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes)); 5951 OS.PadToColumn(48 + 3 * Bias); 5952 OS << getSymbolSectionNdx(Parser.Obj, Sym, 5953 this->dumper()->dynamic_symbols().begin()); 5954 OS.PadToColumn(52 + 3 * Bias); 5955 OS << SymName << "\n"; 5956 } 5957 } 5958 5959 if (!Parser.getOtherEntries().empty()) 5960 OS << "\n Number of TLS and multi-GOT entries " 5961 << Parser.getOtherEntries().size() << "\n"; 5962 } 5963 5964 template <class ELFT> 5965 void GNUStyle<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { 5966 size_t Bias = ELFT::Is64Bits ? 8 : 0; 5967 auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { 5968 OS.PadToColumn(2); 5969 OS << format_hex_no_prefix(Parser.getPltAddress(E), 8 + Bias); 5970 OS.PadToColumn(11 + Bias); 5971 OS << format_hex_no_prefix(*E, 8 + Bias); 5972 OS.PadToColumn(20 + 2 * Bias); 5973 OS << Purpose << "\n"; 5974 }; 5975 5976 OS << "PLT GOT:\n\n"; 5977 5978 OS << " Reserved entries:\n"; 5979 OS << " Address Initial Purpose\n"; 5980 PrintEntry(Parser.getPltLazyResolver(), "PLT lazy resolver"); 5981 if (Parser.getPltModulePointer()) 5982 PrintEntry(Parser.getPltModulePointer(), "Module pointer"); 5983 5984 if (!Parser.getPltEntries().empty()) { 5985 OS << "\n"; 5986 OS << " Entries:\n"; 5987 OS << " Address Initial Sym.Val. Type Ndx Name\n"; 5988 for (auto &E : Parser.getPltEntries()) { 5989 const Elf_Sym *Sym = Parser.getPltSym(&E); 5990 std::string SymName = this->dumper()->getFullSymbolName( 5991 Sym, this->dumper()->getDynamicStringTable(), false); 5992 5993 OS.PadToColumn(2); 5994 OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias)); 5995 OS.PadToColumn(11 + Bias); 5996 OS << to_string(format_hex_no_prefix(E, 8 + Bias)); 5997 OS.PadToColumn(20 + 2 * Bias); 5998 OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias)); 5999 OS.PadToColumn(29 + 3 * Bias); 6000 OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes)); 6001 OS.PadToColumn(37 + 3 * Bias); 6002 OS << getSymbolSectionNdx(Parser.Obj, Sym, 6003 this->dumper()->dynamic_symbols().begin()); 6004 OS.PadToColumn(41 + 3 * Bias); 6005 OS << SymName << "\n"; 6006 } 6007 } 6008 } 6009 6010 template <class ELFT> 6011 Expected<const Elf_Mips_ABIFlags<ELFT> *> 6012 getMipsAbiFlagsSection(const ELFObjectFile<ELFT> *ObjF, 6013 const ELFDumper<ELFT> &Dumper) { 6014 const typename ELFT::Shdr *Sec = Dumper.findSectionByName(".MIPS.abiflags"); 6015 if (Sec == nullptr) 6016 return nullptr; 6017 6018 const ELFFile<ELFT> *Obj = ObjF->getELFFile(); 6019 constexpr StringRef ErrPrefix = "unable to read the .MIPS.abiflags section: "; 6020 Expected<ArrayRef<uint8_t>> DataOrErr = Obj->getSectionContents(Sec); 6021 if (!DataOrErr) 6022 return createError(ErrPrefix + toString(DataOrErr.takeError())); 6023 6024 if (DataOrErr->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) 6025 return createError(ErrPrefix + "it has a wrong size (" + 6026 Twine(DataOrErr->size()) + ")"); 6027 return reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(DataOrErr->data()); 6028 } 6029 6030 template <class ELFT> 6031 void GNUStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) { 6032 const Elf_Mips_ABIFlags<ELFT> *Flags = nullptr; 6033 if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = 6034 getMipsAbiFlagsSection(ObjF, *this->dumper())) 6035 Flags = *SecOrErr; 6036 else 6037 this->reportUniqueWarning(SecOrErr.takeError()); 6038 if (!Flags) 6039 return; 6040 6041 OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n"; 6042 OS << "ISA: MIPS" << int(Flags->isa_level); 6043 if (Flags->isa_rev > 1) 6044 OS << "r" << int(Flags->isa_rev); 6045 OS << "\n"; 6046 OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n"; 6047 OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n"; 6048 OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n"; 6049 OS << "FP ABI: " << printEnum(Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)) 6050 << "\n"; 6051 OS << "ISA Extension: " 6052 << printEnum(Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)) << "\n"; 6053 if (Flags->ases == 0) 6054 OS << "ASEs: None\n"; 6055 else 6056 // FIXME: Print each flag on a separate line. 6057 OS << "ASEs: " << printFlags(Flags->ases, makeArrayRef(ElfMipsASEFlags)) 6058 << "\n"; 6059 OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n"; 6060 OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n"; 6061 OS << "\n"; 6062 } 6063 6064 template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) { 6065 const Elf_Ehdr *E = Obj->getHeader(); 6066 { 6067 DictScope D(W, "ElfHeader"); 6068 { 6069 DictScope D(W, "Ident"); 6070 W.printBinary("Magic", makeArrayRef(E->e_ident).slice(ELF::EI_MAG0, 4)); 6071 W.printEnum("Class", E->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); 6072 W.printEnum("DataEncoding", E->e_ident[ELF::EI_DATA], 6073 makeArrayRef(ElfDataEncoding)); 6074 W.printNumber("FileVersion", E->e_ident[ELF::EI_VERSION]); 6075 6076 auto OSABI = makeArrayRef(ElfOSABI); 6077 if (E->e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH && 6078 E->e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) { 6079 switch (E->e_machine) { 6080 case ELF::EM_AMDGPU: 6081 OSABI = makeArrayRef(AMDGPUElfOSABI); 6082 break; 6083 case ELF::EM_ARM: 6084 OSABI = makeArrayRef(ARMElfOSABI); 6085 break; 6086 case ELF::EM_TI_C6000: 6087 OSABI = makeArrayRef(C6000ElfOSABI); 6088 break; 6089 } 6090 } 6091 W.printEnum("OS/ABI", E->e_ident[ELF::EI_OSABI], OSABI); 6092 W.printNumber("ABIVersion", E->e_ident[ELF::EI_ABIVERSION]); 6093 W.printBinary("Unused", makeArrayRef(E->e_ident).slice(ELF::EI_PAD)); 6094 } 6095 6096 W.printEnum("Type", E->e_type, makeArrayRef(ElfObjectFileType)); 6097 W.printEnum("Machine", E->e_machine, makeArrayRef(ElfMachineType)); 6098 W.printNumber("Version", E->e_version); 6099 W.printHex("Entry", E->e_entry); 6100 W.printHex("ProgramHeaderOffset", E->e_phoff); 6101 W.printHex("SectionHeaderOffset", E->e_shoff); 6102 if (E->e_machine == EM_MIPS) 6103 W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderMipsFlags), 6104 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), 6105 unsigned(ELF::EF_MIPS_MACH)); 6106 else if (E->e_machine == EM_AMDGPU) 6107 W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderAMDGPUFlags), 6108 unsigned(ELF::EF_AMDGPU_MACH)); 6109 else if (E->e_machine == EM_RISCV) 6110 W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderRISCVFlags)); 6111 else 6112 W.printFlags("Flags", E->e_flags); 6113 W.printNumber("HeaderSize", E->e_ehsize); 6114 W.printNumber("ProgramHeaderEntrySize", E->e_phentsize); 6115 W.printNumber("ProgramHeaderCount", E->e_phnum); 6116 W.printNumber("SectionHeaderEntrySize", E->e_shentsize); 6117 W.printString("SectionHeaderCount", 6118 getSectionHeadersNumString(Obj, this->FileName)); 6119 W.printString("StringTableSectionIndex", 6120 getSectionHeaderTableIndexString(Obj, this->FileName)); 6121 } 6122 } 6123 6124 template <class ELFT> 6125 void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) { 6126 DictScope Lists(W, "Groups"); 6127 std::vector<GroupSection> V = getGroups<ELFT>(Obj, this->FileName); 6128 DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V); 6129 for (const GroupSection &G : V) { 6130 DictScope D(W, "Group"); 6131 W.printNumber("Name", G.Name, G.ShName); 6132 W.printNumber("Index", G.Index); 6133 W.printNumber("Link", G.Link); 6134 W.printNumber("Info", G.Info); 6135 W.printHex("Type", getGroupType(G.Type), G.Type); 6136 W.startLine() << "Signature: " << G.Signature << "\n"; 6137 6138 ListScope L(W, "Section(s) in group"); 6139 for (const GroupMember &GM : G.Members) { 6140 const GroupSection *MainGroup = Map[GM.Index]; 6141 if (MainGroup != &G) 6142 this->reportUniqueWarning( 6143 createError("section with index " + Twine(GM.Index) + 6144 ", included in the group section with index " + 6145 Twine(MainGroup->Index) + 6146 ", was also found in the group section with index " + 6147 Twine(G.Index))); 6148 W.startLine() << GM.Name << " (" << GM.Index << ")\n"; 6149 } 6150 } 6151 6152 if (V.empty()) 6153 W.startLine() << "There are no group sections in the file.\n"; 6154 } 6155 6156 template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) { 6157 ListScope D(W, "Relocations"); 6158 6159 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 6160 if (!isRelocationSec<ELFT>(Sec)) 6161 continue; 6162 6163 StringRef Name = this->getPrintableSectionName(Obj, Sec); 6164 unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front(); 6165 W.startLine() << "Section (" << SecNdx << ") " << Name << " {\n"; 6166 W.indent(); 6167 this->printRelocationsHelper(Obj, Sec); 6168 W.unindent(); 6169 W.startLine() << "}\n"; 6170 } 6171 } 6172 6173 template <class ELFT> 6174 void LLVMStyle<ELFT>::printRelReloc(const ELFO *Obj, unsigned SecIndex, 6175 const Elf_Shdr *SymTab, const Elf_Rel &R, 6176 unsigned RelIndex) { 6177 printRelRelaReloc(Obj, SecIndex, R, RelIndex, SymTab); 6178 } 6179 6180 template <class ELFT> 6181 void LLVMStyle<ELFT>::printRelaReloc(const ELFO *Obj, unsigned SecIndex, 6182 const Elf_Shdr *SymTab, const Elf_Rela &R, 6183 unsigned RelIndex) { 6184 printRelRelaReloc(Obj, SecIndex, R, RelIndex, SymTab); 6185 } 6186 6187 template <class ELFT> void LLVMStyle<ELFT>::printRelrReloc(const Elf_Relr &R) { 6188 W.startLine() << W.hex(R) << "\n"; 6189 } 6190 6191 template <class ELFT> 6192 template <class RelTy> 6193 void LLVMStyle<ELFT>::printRelRelaReloc(const ELFO *Obj, unsigned SecIndex, 6194 const RelTy &Rel, unsigned RelIndex, 6195 const Elf_Shdr *SymTab) { 6196 Expected<std::pair<const typename ELFT::Sym *, std::string>> Target = 6197 this->dumper()->getRelocationTarget(SymTab, Rel); 6198 if (!Target) { 6199 this->reportUniqueWarning(createError( 6200 "unable to print relocation " + Twine(RelIndex) + " in section " + 6201 Twine(SecIndex) + ": " + toString(Target.takeError()))); 6202 return; 6203 } 6204 6205 std::string TargetName = Target->second; 6206 SmallString<32> RelocName; 6207 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); 6208 6209 uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0); 6210 if (opts::ExpandRelocs) { 6211 DictScope Group(W, "Relocation"); 6212 W.printHex("Offset", Rel.r_offset); 6213 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); 6214 W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-", 6215 Rel.getSymbol(Obj->isMips64EL())); 6216 W.printHex("Addend", Addend); 6217 } else { 6218 raw_ostream &OS = W.startLine(); 6219 OS << W.hex(Rel.r_offset) << " " << RelocName << " " 6220 << (!TargetName.empty() ? TargetName : "-") << " " << W.hex(Addend) 6221 << "\n"; 6222 } 6223 } 6224 6225 template <class ELFT> 6226 void LLVMStyle<ELFT>::printSectionHeaders(const ELFO *Obj) { 6227 ListScope SectionsD(W, "Sections"); 6228 6229 int SectionIndex = -1; 6230 std::vector<EnumEntry<unsigned>> FlagsList = 6231 getSectionFlagsForTarget(Obj->getHeader()->e_machine); 6232 for (const Elf_Shdr &Sec : cantFail(Obj->sections())) { 6233 DictScope SectionD(W, "Section"); 6234 W.printNumber("Index", ++SectionIndex); 6235 W.printNumber("Name", this->getPrintableSectionName(Obj, Sec), Sec.sh_name); 6236 W.printHex( 6237 "Type", 6238 object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec.sh_type), 6239 Sec.sh_type); 6240 W.printFlags("Flags", Sec.sh_flags, makeArrayRef(FlagsList)); 6241 W.printHex("Address", Sec.sh_addr); 6242 W.printHex("Offset", Sec.sh_offset); 6243 W.printNumber("Size", Sec.sh_size); 6244 W.printNumber("Link", Sec.sh_link); 6245 W.printNumber("Info", Sec.sh_info); 6246 W.printNumber("AddressAlignment", Sec.sh_addralign); 6247 W.printNumber("EntrySize", Sec.sh_entsize); 6248 6249 if (opts::SectionRelocations) { 6250 ListScope D(W, "Relocations"); 6251 this->printRelocationsHelper(Obj, Sec); 6252 } 6253 6254 if (opts::SectionSymbols) { 6255 ListScope D(W, "Symbols"); 6256 const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec(); 6257 StringRef StrTable = 6258 unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*Symtab)); 6259 6260 for (const Elf_Sym &Sym : 6261 unwrapOrError(this->FileName, Obj->symbols(Symtab))) { 6262 const Elf_Shdr *SymSec = unwrapOrError( 6263 this->FileName, 6264 Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable())); 6265 if (SymSec == &Sec) 6266 printSymbol( 6267 Obj, &Sym, 6268 unwrapOrError(this->FileName, Obj->symbols(Symtab)).begin(), 6269 StrTable, false, false); 6270 } 6271 } 6272 6273 if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { 6274 ArrayRef<uint8_t> Data = 6275 unwrapOrError(this->FileName, Obj->getSectionContents(&Sec)); 6276 W.printBinaryBlock( 6277 "SectionData", 6278 StringRef(reinterpret_cast<const char *>(Data.data()), Data.size())); 6279 } 6280 } 6281 } 6282 6283 template <class ELFT> 6284 void LLVMStyle<ELFT>::printSymbolSection(const Elf_Sym *Symbol, 6285 const Elf_Sym *First) { 6286 Expected<unsigned> SectionIndex = 6287 this->dumper()->getSymbolSectionIndex(Symbol, First); 6288 if (!SectionIndex) { 6289 assert(Symbol->st_shndx == SHN_XINDEX && 6290 "getSymbolSectionIndex should only fail due to an invalid " 6291 "SHT_SYMTAB_SHNDX table/reference"); 6292 this->reportUniqueWarning(SectionIndex.takeError()); 6293 W.printHex("Section", "Reserved", SHN_XINDEX); 6294 return; 6295 } 6296 6297 Expected<StringRef> SectionName = 6298 this->dumper()->getSymbolSectionName(Symbol, *SectionIndex); 6299 if (!SectionName) { 6300 // Don't report an invalid section name if the section headers are missing. 6301 // In such situations, all sections will be "invalid". 6302 if (!this->dumper()->getElfObject()->sections().empty()) 6303 this->reportUniqueWarning(SectionName.takeError()); 6304 else 6305 consumeError(SectionName.takeError()); 6306 W.printHex("Section", "<?>", *SectionIndex); 6307 } else { 6308 W.printHex("Section", *SectionName, *SectionIndex); 6309 } 6310 } 6311 6312 template <class ELFT> 6313 void LLVMStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, 6314 const Elf_Sym *First, 6315 Optional<StringRef> StrTable, bool IsDynamic, 6316 bool /*NonVisibilityBitsUsed*/) { 6317 std::string FullSymbolName = 6318 this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); 6319 unsigned char SymbolType = Symbol->getType(); 6320 6321 DictScope D(W, "Symbol"); 6322 W.printNumber("Name", FullSymbolName, Symbol->st_name); 6323 W.printHex("Value", Symbol->st_value); 6324 W.printNumber("Size", Symbol->st_size); 6325 W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); 6326 if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && 6327 SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) 6328 W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); 6329 else 6330 W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); 6331 if (Symbol->st_other == 0) 6332 // Usually st_other flag is zero. Do not pollute the output 6333 // by flags enumeration in that case. 6334 W.printNumber("Other", 0); 6335 else { 6336 std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags), 6337 std::end(ElfSymOtherFlags)); 6338 if (Obj->getHeader()->e_machine == EM_MIPS) { 6339 // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16 6340 // flag overlapped with other ST_MIPS_xxx flags. So consider both 6341 // cases separately. 6342 if ((Symbol->st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16) 6343 SymOtherFlags.insert(SymOtherFlags.end(), 6344 std::begin(ElfMips16SymOtherFlags), 6345 std::end(ElfMips16SymOtherFlags)); 6346 else 6347 SymOtherFlags.insert(SymOtherFlags.end(), 6348 std::begin(ElfMipsSymOtherFlags), 6349 std::end(ElfMipsSymOtherFlags)); 6350 } 6351 W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u); 6352 } 6353 printSymbolSection(Symbol, First); 6354 } 6355 6356 template <class ELFT> 6357 void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj, bool PrintSymbols, 6358 bool PrintDynamicSymbols) { 6359 if (PrintSymbols) 6360 printSymbols(Obj); 6361 if (PrintDynamicSymbols) 6362 printDynamicSymbols(Obj); 6363 } 6364 6365 template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) { 6366 ListScope Group(W, "Symbols"); 6367 this->dumper()->printSymbolsHelper(false); 6368 } 6369 6370 template <class ELFT> 6371 void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) { 6372 ListScope Group(W, "DynamicSymbols"); 6373 this->dumper()->printSymbolsHelper(true); 6374 } 6375 6376 template <class ELFT> void LLVMStyle<ELFT>::printDynamic(const ELFFile<ELFT> *Obj) { 6377 Elf_Dyn_Range Table = this->dumper()->dynamic_table(); 6378 if (Table.empty()) 6379 return; 6380 6381 W.startLine() << "DynamicSection [ (" << Table.size() << " entries)\n"; 6382 6383 size_t MaxTagSize = getMaxDynamicTagSize(Obj, Table); 6384 // The "Name/Value" column should be indented from the "Type" column by N 6385 // spaces, where N = MaxTagSize - length of "Type" (4) + trailing 6386 // space (1) = -3. 6387 W.startLine() << " Tag" << std::string(ELFT::Is64Bits ? 16 : 8, ' ') 6388 << "Type" << std::string(MaxTagSize - 3, ' ') << "Name/Value\n"; 6389 6390 std::string ValueFmt = "%-" + std::to_string(MaxTagSize) + "s "; 6391 for (auto Entry : Table) { 6392 uintX_t Tag = Entry.getTag(); 6393 std::string Value = this->dumper()->getDynamicEntry(Tag, Entry.getVal()); 6394 W.startLine() << " " << format_hex(Tag, ELFT::Is64Bits ? 18 : 10, true) 6395 << " " 6396 << format(ValueFmt.c_str(), 6397 Obj->getDynamicTagAsString(Tag).c_str()) 6398 << Value << "\n"; 6399 } 6400 W.startLine() << "]\n"; 6401 } 6402 6403 template <class ELFT> 6404 void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) { 6405 const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); 6406 const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); 6407 const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion(); 6408 const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); 6409 6410 W.startLine() << "Dynamic Relocations {\n"; 6411 W.indent(); 6412 if (DynRelaRegion.Size > 0) { 6413 for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) 6414 printDynamicRelocation(Obj, Rela); 6415 } 6416 if (DynRelRegion.Size > 0) { 6417 for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) 6418 printDynamicRelocation(Obj, Rel); 6419 } 6420 6421 if (DynRelrRegion.Size > 0) { 6422 Elf_Relr_Range Relrs = this->dumper()->dyn_relrs(); 6423 std::vector<Elf_Rel> RelrRels = 6424 unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); 6425 for (const Elf_Rel &R : RelrRels) 6426 printDynamicRelocation(Obj, R); 6427 } 6428 if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) 6429 for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>()) 6430 printDynamicRelocation(Obj, Rela); 6431 else 6432 for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) 6433 printDynamicRelocation(Obj, Rel); 6434 6435 W.unindent(); 6436 W.startLine() << "}\n"; 6437 } 6438 6439 template <class ELFT> 6440 template <class RelTy> 6441 void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, const RelTy& Rel) { 6442 SmallString<32> RelocName; 6443 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); 6444 std::string SymbolName = 6445 getSymbolForReloc(Obj, this->FileName, this->dumper(), Rel).Name; 6446 6447 uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0); 6448 if (opts::ExpandRelocs) { 6449 DictScope Group(W, "Relocation"); 6450 W.printHex("Offset", Rel.r_offset); 6451 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); 6452 W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-"); 6453 W.printHex("Addend", Addend); 6454 } else { 6455 raw_ostream &OS = W.startLine(); 6456 OS << W.hex(Rel.r_offset) << " " << RelocName << " " 6457 << (!SymbolName.empty() ? SymbolName : "-") << " " << W.hex(Addend) 6458 << "\n"; 6459 } 6460 } 6461 6462 template <class ELFT> 6463 void LLVMStyle<ELFT>::printProgramHeaders( 6464 const ELFO *Obj, bool PrintProgramHeaders, 6465 cl::boolOrDefault PrintSectionMapping) { 6466 if (PrintProgramHeaders) 6467 printProgramHeaders(Obj); 6468 if (PrintSectionMapping == cl::BOU_TRUE) 6469 printSectionMapping(Obj); 6470 } 6471 6472 template <class ELFT> 6473 void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) { 6474 ListScope L(W, "ProgramHeaders"); 6475 6476 Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers(); 6477 if (!PhdrsOrErr) { 6478 this->reportUniqueWarning(createError("unable to dump program headers: " + 6479 toString(PhdrsOrErr.takeError()))); 6480 return; 6481 } 6482 6483 for (const Elf_Phdr &Phdr : *PhdrsOrErr) { 6484 DictScope P(W, "ProgramHeader"); 6485 W.printHex("Type", 6486 getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type), 6487 Phdr.p_type); 6488 W.printHex("Offset", Phdr.p_offset); 6489 W.printHex("VirtualAddress", Phdr.p_vaddr); 6490 W.printHex("PhysicalAddress", Phdr.p_paddr); 6491 W.printNumber("FileSize", Phdr.p_filesz); 6492 W.printNumber("MemSize", Phdr.p_memsz); 6493 W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); 6494 W.printNumber("Alignment", Phdr.p_align); 6495 } 6496 } 6497 6498 template <class ELFT> 6499 void LLVMStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj, 6500 const Elf_Shdr *Sec) { 6501 ListScope SS(W, "VersionSymbols"); 6502 if (!Sec) 6503 return; 6504 6505 StringRef StrTable; 6506 ArrayRef<Elf_Sym> Syms; 6507 Expected<ArrayRef<Elf_Versym>> VerTableOrErr = 6508 this->dumper()->getVersionTable(Sec, &Syms, &StrTable); 6509 if (!VerTableOrErr) { 6510 this->reportUniqueWarning(VerTableOrErr.takeError()); 6511 return; 6512 } 6513 6514 if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size()) 6515 return; 6516 6517 for (size_t I = 0, E = Syms.size(); I < E; ++I) { 6518 DictScope S(W, "Symbol"); 6519 W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION); 6520 W.printString("Name", this->dumper()->getFullSymbolName( 6521 &Syms[I], StrTable, /*IsDynamic=*/true)); 6522 } 6523 } 6524 6525 template <class ELFT> 6526 void LLVMStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj, 6527 const Elf_Shdr *Sec) { 6528 ListScope SD(W, "VersionDefinitions"); 6529 if (!Sec) 6530 return; 6531 6532 Expected<std::vector<VerDef>> V = this->dumper()->getVersionDefinitions(Sec); 6533 if (!V) { 6534 this->reportUniqueWarning(V.takeError()); 6535 return; 6536 } 6537 6538 for (const VerDef &D : *V) { 6539 DictScope Def(W, "Definition"); 6540 W.printNumber("Version", D.Version); 6541 W.printFlags("Flags", D.Flags, makeArrayRef(SymVersionFlags)); 6542 W.printNumber("Index", D.Ndx); 6543 W.printNumber("Hash", D.Hash); 6544 W.printString("Name", D.Name.c_str()); 6545 W.printList( 6546 "Predecessors", D.AuxV, 6547 [](raw_ostream &OS, const VerdAux &Aux) { OS << Aux.Name.c_str(); }); 6548 } 6549 } 6550 6551 template <class ELFT> 6552 void LLVMStyle<ELFT>::printVersionDependencySection(const ELFFile<ELFT> *Obj, 6553 const Elf_Shdr *Sec) { 6554 ListScope SD(W, "VersionRequirements"); 6555 if (!Sec) 6556 return; 6557 6558 Expected<std::vector<VerNeed>> V = 6559 this->dumper()->getVersionDependencies(Sec); 6560 if (!V) { 6561 this->reportUniqueWarning(V.takeError()); 6562 return; 6563 } 6564 6565 for (const VerNeed &VN : *V) { 6566 DictScope Entry(W, "Dependency"); 6567 W.printNumber("Version", VN.Version); 6568 W.printNumber("Count", VN.Cnt); 6569 W.printString("FileName", VN.File.c_str()); 6570 6571 ListScope L(W, "Entries"); 6572 for (const VernAux &Aux : VN.AuxV) { 6573 DictScope Entry(W, "Entry"); 6574 W.printNumber("Hash", Aux.Hash); 6575 W.printFlags("Flags", Aux.Flags, makeArrayRef(SymVersionFlags)); 6576 W.printNumber("Index", Aux.Other); 6577 W.printString("Name", Aux.Name.c_str()); 6578 } 6579 } 6580 } 6581 6582 template <class ELFT> 6583 void LLVMStyle<ELFT>::printHashHistograms(const ELFFile<ELFT> *Obj) { 6584 W.startLine() << "Hash Histogram not implemented!\n"; 6585 } 6586 6587 template <class ELFT> 6588 void LLVMStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) { 6589 ListScope L(W, "CGProfile"); 6590 if (!this->dumper()->getDotCGProfileSec()) 6591 return; 6592 6593 Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr = 6594 Obj->template getSectionContentsAsArray<Elf_CGProfile>( 6595 this->dumper()->getDotCGProfileSec()); 6596 if (!CGProfileOrErr) { 6597 this->reportUniqueWarning( 6598 createError("unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " + 6599 toString(CGProfileOrErr.takeError()))); 6600 return; 6601 } 6602 6603 for (const Elf_CGProfile &CGPE : *CGProfileOrErr) { 6604 DictScope D(W, "CGProfileEntry"); 6605 W.printNumber("From", this->dumper()->getStaticSymbolName(CGPE.cgp_from), 6606 CGPE.cgp_from); 6607 W.printNumber("To", this->dumper()->getStaticSymbolName(CGPE.cgp_to), 6608 CGPE.cgp_to); 6609 W.printNumber("Weight", CGPE.cgp_weight); 6610 } 6611 } 6612 6613 static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) { 6614 std::vector<uint64_t> Ret; 6615 const uint8_t *Cur = Data.begin(); 6616 const uint8_t *End = Data.end(); 6617 while (Cur != End) { 6618 unsigned Size; 6619 const char *Err; 6620 Ret.push_back(decodeULEB128(Cur, &Size, End, &Err)); 6621 if (Err) 6622 return createError(Err); 6623 Cur += Size; 6624 } 6625 return Ret; 6626 } 6627 6628 template <class ELFT> 6629 void LLVMStyle<ELFT>::printAddrsig(const ELFFile<ELFT> *Obj) { 6630 ListScope L(W, "Addrsig"); 6631 if (!this->dumper()->getDotAddrsigSec()) 6632 return; 6633 ArrayRef<uint8_t> Contents = unwrapOrError( 6634 this->FileName, 6635 Obj->getSectionContents(this->dumper()->getDotAddrsigSec())); 6636 Expected<std::vector<uint64_t>> V = toULEB128Array(Contents); 6637 if (!V) { 6638 reportWarning(V.takeError(), this->FileName); 6639 return; 6640 } 6641 6642 for (uint64_t Sym : *V) { 6643 Expected<std::string> NameOrErr = this->dumper()->getStaticSymbolName(Sym); 6644 if (NameOrErr) { 6645 W.printNumber("Sym", *NameOrErr, Sym); 6646 continue; 6647 } 6648 reportWarning(NameOrErr.takeError(), this->FileName); 6649 W.printNumber("Sym", "<?>", Sym); 6650 } 6651 } 6652 6653 template <typename ELFT> 6654 static void printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc, 6655 ScopedPrinter &W) { 6656 switch (NoteType) { 6657 default: 6658 return; 6659 case ELF::NT_GNU_ABI_TAG: { 6660 const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc); 6661 if (!AbiTag.IsValid) { 6662 W.printString("ABI", "<corrupt GNU_ABI_TAG>"); 6663 } else { 6664 W.printString("OS", AbiTag.OSName); 6665 W.printString("ABI", AbiTag.ABI); 6666 } 6667 break; 6668 } 6669 case ELF::NT_GNU_BUILD_ID: { 6670 W.printString("Build ID", getGNUBuildId(Desc)); 6671 break; 6672 } 6673 case ELF::NT_GNU_GOLD_VERSION: 6674 W.printString("Version", getGNUGoldVersion(Desc)); 6675 break; 6676 case ELF::NT_GNU_PROPERTY_TYPE_0: 6677 ListScope D(W, "Property"); 6678 for (const auto &Property : getGNUPropertyList<ELFT>(Desc)) 6679 W.printString(Property); 6680 break; 6681 } 6682 } 6683 6684 static void printCoreNoteLLVMStyle(const CoreNote &Note, ScopedPrinter &W) { 6685 W.printNumber("Page Size", Note.PageSize); 6686 for (const CoreFileMapping &Mapping : Note.Mappings) { 6687 ListScope D(W, "Mapping"); 6688 W.printHex("Start", Mapping.Start); 6689 W.printHex("End", Mapping.End); 6690 W.printHex("Offset", Mapping.Offset); 6691 W.printString("Filename", Mapping.Filename); 6692 } 6693 } 6694 6695 template <class ELFT> 6696 void LLVMStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) { 6697 ListScope L(W, "Notes"); 6698 6699 auto PrintHeader = [&](Optional<StringRef> SecName, 6700 const typename ELFT::Off Offset, 6701 const typename ELFT::Addr Size) { 6702 W.printString("Name", SecName ? *SecName : "<?>"); 6703 W.printHex("Offset", Offset); 6704 W.printHex("Size", Size); 6705 }; 6706 6707 auto ProcessNote = [&](const Elf_Note &Note) { 6708 DictScope D2(W, "Note"); 6709 StringRef Name = Note.getName(); 6710 ArrayRef<uint8_t> Descriptor = Note.getDesc(); 6711 Elf_Word Type = Note.getType(); 6712 6713 // Print the note owner/type. 6714 W.printString("Owner", Name); 6715 W.printHex("Data size", Descriptor.size()); 6716 if (Name == "GNU") { 6717 W.printString("Type", getGNUNoteTypeName(Type)); 6718 } else if (Name == "FreeBSD") { 6719 W.printString("Type", getFreeBSDNoteTypeName(Type)); 6720 } else if (Name == "AMD") { 6721 W.printString("Type", getAMDNoteTypeName(Type)); 6722 } else if (Name == "AMDGPU") { 6723 W.printString("Type", getAMDGPUNoteTypeName(Type)); 6724 } else { 6725 StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE 6726 ? getCoreNoteTypeName(Type) 6727 : getGenericNoteTypeName(Type); 6728 if (!NoteType.empty()) 6729 W.printString("Type", NoteType); 6730 else 6731 W.printString("Type", 6732 "Unknown (" + to_string(format_hex(Type, 10)) + ")"); 6733 } 6734 6735 // Print the description, or fallback to printing raw bytes for unknown 6736 // owners. 6737 if (Name == "GNU") { 6738 printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W); 6739 } else if (Name == "AMD") { 6740 const AMDNote N = getAMDNote<ELFT>(Type, Descriptor); 6741 if (!N.Type.empty()) 6742 W.printString(N.Type, N.Value); 6743 } else if (Name == "AMDGPU") { 6744 const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor); 6745 if (!N.Type.empty()) 6746 W.printString(N.Type, N.Value); 6747 } else if (Name == "CORE") { 6748 if (Type == ELF::NT_FILE) { 6749 DataExtractor DescExtractor(Descriptor, 6750 ELFT::TargetEndianness == support::little, 6751 sizeof(Elf_Addr)); 6752 Expected<CoreNote> Note = readCoreNote(DescExtractor); 6753 if (Note) 6754 printCoreNoteLLVMStyle(*Note, W); 6755 else 6756 reportWarning(Note.takeError(), this->FileName); 6757 } 6758 } else if (!Descriptor.empty()) { 6759 W.printBinaryBlock("Description data", Descriptor); 6760 } 6761 }; 6762 6763 ArrayRef<Elf_Shdr> Sections = cantFail(Obj->sections()); 6764 if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) { 6765 for (const auto &S : Sections) { 6766 if (S.sh_type != SHT_NOTE) 6767 continue; 6768 DictScope D(W, "NoteSection"); 6769 PrintHeader(expectedToOptional(Obj->getSectionName(&S)), S.sh_offset, 6770 S.sh_size); 6771 Error Err = Error::success(); 6772 for (auto Note : Obj->notes(S, Err)) 6773 ProcessNote(Note); 6774 if (Err) 6775 reportError(std::move(Err), this->FileName); 6776 } 6777 } else { 6778 Expected<ArrayRef<Elf_Phdr>> PhdrsOrErr = Obj->program_headers(); 6779 if (!PhdrsOrErr) { 6780 this->reportUniqueWarning(createError( 6781 "unable to read program headers to locate the PT_NOTE segment: " + 6782 toString(PhdrsOrErr.takeError()))); 6783 return; 6784 } 6785 6786 for (const Elf_Phdr &P : *PhdrsOrErr) { 6787 if (P.p_type != PT_NOTE) 6788 continue; 6789 DictScope D(W, "NoteSection"); 6790 PrintHeader(/*SecName=*/None, P.p_offset, P.p_filesz); 6791 Error Err = Error::success(); 6792 for (auto Note : Obj->notes(P, Err)) 6793 ProcessNote(Note); 6794 if (Err) 6795 reportError(std::move(Err), this->FileName); 6796 } 6797 } 6798 } 6799 6800 template <class ELFT> 6801 void LLVMStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) { 6802 ListScope L(W, "LinkerOptions"); 6803 6804 unsigned I = -1; 6805 for (const Elf_Shdr &Shdr : cantFail(Obj->sections())) { 6806 ++I; 6807 if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS) 6808 continue; 6809 6810 Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(&Shdr); 6811 if (!ContentsOrErr) { 6812 this->reportUniqueWarning( 6813 createError("unable to read the content of the " 6814 "SHT_LLVM_LINKER_OPTIONS section: " + 6815 toString(ContentsOrErr.takeError()))); 6816 continue; 6817 } 6818 if (ContentsOrErr->empty()) 6819 continue; 6820 6821 if (ContentsOrErr->back() != 0) { 6822 this->reportUniqueWarning( 6823 createError("SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + 6824 " is broken: the " 6825 "content is not null-terminated")); 6826 continue; 6827 } 6828 6829 SmallVector<StringRef, 16> Strings; 6830 toStringRef(ContentsOrErr->drop_back()).split(Strings, '\0'); 6831 if (Strings.size() % 2 != 0) { 6832 this->reportUniqueWarning(createError( 6833 "SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + 6834 " is broken: an incomplete " 6835 "key-value pair was found. The last possible key was: \"" + 6836 Strings.back() + "\"")); 6837 continue; 6838 } 6839 6840 for (size_t I = 0; I < Strings.size(); I += 2) 6841 W.printString(Strings[I], Strings[I + 1]); 6842 } 6843 } 6844 6845 template <class ELFT> 6846 void LLVMStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) { 6847 ListScope L(W, "DependentLibs"); 6848 this->printDependentLibsHelper( 6849 Obj, [](const Elf_Shdr &) {}, 6850 [this](StringRef Lib, uint64_t) { W.printString(Lib); }); 6851 } 6852 6853 template <class ELFT> 6854 void LLVMStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) { 6855 ListScope L(W, "StackSizes"); 6856 if (Obj->isRelocatableObject()) 6857 this->printRelocatableStackSizes(Obj, []() {}); 6858 else 6859 this->printNonRelocatableStackSizes(Obj, []() {}); 6860 } 6861 6862 template <class ELFT> 6863 void LLVMStyle<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) { 6864 DictScope D(W, "Entry"); 6865 W.printString("Function", FuncName); 6866 W.printHex("Size", Size); 6867 } 6868 6869 template <class ELFT> 6870 void LLVMStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) { 6871 auto PrintEntry = [&](const Elf_Addr *E) { 6872 W.printHex("Address", Parser.getGotAddress(E)); 6873 W.printNumber("Access", Parser.getGotOffset(E)); 6874 W.printHex("Initial", *E); 6875 }; 6876 6877 DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT"); 6878 6879 W.printHex("Canonical gp value", Parser.getGp()); 6880 { 6881 ListScope RS(W, "Reserved entries"); 6882 { 6883 DictScope D(W, "Entry"); 6884 PrintEntry(Parser.getGotLazyResolver()); 6885 W.printString("Purpose", StringRef("Lazy resolver")); 6886 } 6887 6888 if (Parser.getGotModulePointer()) { 6889 DictScope D(W, "Entry"); 6890 PrintEntry(Parser.getGotModulePointer()); 6891 W.printString("Purpose", StringRef("Module pointer (GNU extension)")); 6892 } 6893 } 6894 { 6895 ListScope LS(W, "Local entries"); 6896 for (auto &E : Parser.getLocalEntries()) { 6897 DictScope D(W, "Entry"); 6898 PrintEntry(&E); 6899 } 6900 } 6901 6902 if (Parser.IsStatic) 6903 return; 6904 6905 { 6906 ListScope GS(W, "Global entries"); 6907 for (auto &E : Parser.getGlobalEntries()) { 6908 DictScope D(W, "Entry"); 6909 6910 PrintEntry(&E); 6911 6912 const Elf_Sym *Sym = Parser.getGotSym(&E); 6913 W.printHex("Value", Sym->st_value); 6914 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); 6915 printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin()); 6916 6917 std::string SymName = this->dumper()->getFullSymbolName( 6918 Sym, this->dumper()->getDynamicStringTable(), true); 6919 W.printNumber("Name", SymName, Sym->st_name); 6920 } 6921 } 6922 6923 W.printNumber("Number of TLS and multi-GOT entries", 6924 uint64_t(Parser.getOtherEntries().size())); 6925 } 6926 6927 template <class ELFT> 6928 void LLVMStyle<ELFT>::printMipsPLT(const MipsGOTParser<ELFT> &Parser) { 6929 auto PrintEntry = [&](const Elf_Addr *E) { 6930 W.printHex("Address", Parser.getPltAddress(E)); 6931 W.printHex("Initial", *E); 6932 }; 6933 6934 DictScope GS(W, "PLT GOT"); 6935 6936 { 6937 ListScope RS(W, "Reserved entries"); 6938 { 6939 DictScope D(W, "Entry"); 6940 PrintEntry(Parser.getPltLazyResolver()); 6941 W.printString("Purpose", StringRef("PLT lazy resolver")); 6942 } 6943 6944 if (auto E = Parser.getPltModulePointer()) { 6945 DictScope D(W, "Entry"); 6946 PrintEntry(E); 6947 W.printString("Purpose", StringRef("Module pointer")); 6948 } 6949 } 6950 { 6951 ListScope LS(W, "Entries"); 6952 for (auto &E : Parser.getPltEntries()) { 6953 DictScope D(W, "Entry"); 6954 PrintEntry(&E); 6955 6956 const Elf_Sym *Sym = Parser.getPltSym(&E); 6957 W.printHex("Value", Sym->st_value); 6958 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); 6959 printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin()); 6960 6961 std::string SymName = 6962 this->dumper()->getFullSymbolName(Sym, Parser.getPltStrTable(), true); 6963 W.printNumber("Name", SymName, Sym->st_name); 6964 } 6965 } 6966 } 6967 6968 template <class ELFT> 6969 void LLVMStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) { 6970 const Elf_Mips_ABIFlags<ELFT> *Flags; 6971 if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr = 6972 getMipsAbiFlagsSection(ObjF, *this->dumper())) { 6973 Flags = *SecOrErr; 6974 if (!Flags) { 6975 W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; 6976 return; 6977 } 6978 } else { 6979 this->reportUniqueWarning(SecOrErr.takeError()); 6980 return; 6981 } 6982 6983 raw_ostream &OS = W.getOStream(); 6984 DictScope GS(W, "MIPS ABI Flags"); 6985 6986 W.printNumber("Version", Flags->version); 6987 W.startLine() << "ISA: "; 6988 if (Flags->isa_rev <= 1) 6989 OS << format("MIPS%u", Flags->isa_level); 6990 else 6991 OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); 6992 OS << "\n"; 6993 W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)); 6994 W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags)); 6995 W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)); 6996 W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); 6997 W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); 6998 W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); 6999 W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1)); 7000 W.printHex("Flags 2", Flags->flags2); 7001 } 7002