include/llvm/ObjectYAML/ELFYAML.h

   1 //===- ELFYAML.h - ELF YAMLIO implementation --------------------*- C++ -*-===//
   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 declares classes for handling the YAML representation
  11 /// of ELF.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_OBJECTYAML_ELFYAML_H
  16 #define LLVM_OBJECTYAML_ELFYAML_H
  17
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/ObjectYAML/YAML.h"
  20 #include "llvm/Support/YAMLTraits.h"
  21 #include <cstdint>
  22 #include <memory>
  23 #include <vector>
  24
  25 namespace llvm {
  26 namespace ELFYAML {
  27
  28 StringRef dropUniqueSuffix(StringRef S);
  29
  30 // These types are invariant across 32/64-bit ELF, so for simplicity just
  31 // directly give them their exact sizes. We don't need to worry about
  32 // endianness because these are just the types in the YAMLIO structures,
  33 // and are appropriately converted to the necessary endianness when
  34 // reading/generating binary object files.
  35 // The naming of these types is intended to be ELF_PREFIX, where PREFIX is
  36 // the common prefix of the respective constants. E.g. ELF_EM corresponds
  37 // to the `e_machine` constants, like `EM_X86_64`.
  38 // In the future, these would probably be better suited by C++11 enum
  39 // class's with appropriate fixed underlying type.
  40 LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)
  41 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)
  42 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)
  43 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
  44 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
  45 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)
  46 // Just use 64, since it can hold 32-bit values too.
  47 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)
  48 // Just use 64, since it can hold 32-bit values too.
  49 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_DYNTAG)
  50 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)
  51 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)
  52 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_REL)
  53 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)
  54 // Just use 64, since it can hold 32-bit values too.
  55 LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)
  56 LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)
  57 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
  58 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
  59
  60 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
  61 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
  62 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
  63 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
  64 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
  65 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)
  66
  67 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
  68 // since 64-bit can hold 32-bit values too.
  69 struct FileHeader {
  70   ELF_ELFCLASS Class;
  71   ELF_ELFDATA Data;
  72   ELF_ELFOSABI OSABI;
  73   llvm::yaml::Hex8 ABIVersion;
  74   ELF_ET Type;
  75   ELF_EM Machine;
  76   ELF_EF Flags;
  77   llvm::yaml::Hex64 Entry;
  78
  79   Optional<llvm::yaml::Hex16> SHEntSize;
  80   Optional<llvm::yaml::Hex64> SHOff;
  81   Optional<llvm::yaml::Hex16> SHNum;
  82   Optional<llvm::yaml::Hex16> SHStrNdx;
  83 };
  84
  85 struct SectionName {
  86   StringRef Section;
  87 };
  88
  89 struct ProgramHeader {
  90   ELF_PT Type;
  91   ELF_PF Flags;
  92   llvm::yaml::Hex64 VAddr;
  93   llvm::yaml::Hex64 PAddr;
  94   Optional<llvm::yaml::Hex64> Align;
  95   Optional<llvm::yaml::Hex64> FileSize;
  96   Optional<llvm::yaml::Hex64> MemSize;
  97   Optional<llvm::yaml::Hex64> Offset;
  98   std::vector<SectionName> Sections;
  99 };
 100
 101 struct Symbol {
 102   StringRef Name;
 103   Optional<uint32_t> NameIndex;
 104   ELF_STT Type;
 105   StringRef Section;
 106   Optional<ELF_SHN> Index;
 107   ELF_STB Binding;
 108   llvm::yaml::Hex64 Value;
 109   llvm::yaml::Hex64 Size;
 110   Optional<uint8_t> Other;
 111 };
 112
 113 struct SectionOrType {
 114   StringRef sectionNameOrType;
 115 };
 116
 117 struct DynamicEntry {
 118   ELF_DYNTAG Tag;
 119   llvm::yaml::Hex64 Val;
 120 };
 121
 122 struct StackSizeEntry {
 123   llvm::yaml::Hex64 Address;
 124   llvm::yaml::Hex64 Size;
 125 };
 126
 127 struct Section {
 128   enum class SectionKind {
 129     Dynamic,
 130     Group,
 131     RawContent,
 132     Relocation,
 133     NoBits,
 134     Hash,
 135     Verdef,
 136     Verneed,
 137     StackSizes,
 138     SymtabShndxSection,
 139     Symver,
 140     MipsABIFlags,
 141     Addrsig
 142   };
 143   SectionKind Kind;
 144   StringRef Name;
 145   ELF_SHT Type;
 146   Optional<ELF_SHF> Flags;
 147   llvm::yaml::Hex64 Address;
 148   StringRef Link;
 149   llvm::yaml::Hex64 AddressAlign;
 150   Optional<llvm::yaml::Hex64> EntSize;
 151
 152   // Usually sections are not created implicitly, but loaded from YAML.
 153   // When they are, this flag is used to signal about that.
 154   bool IsImplicit;
 155
 156   Section(SectionKind Kind, bool IsImplicit = false)
 157       : Kind(Kind), IsImplicit(IsImplicit) {}
 158   virtual ~Section();
 159
 160   // The following members are used to override section fields which is
 161   // useful for creating invalid objects.
 162
 163   // This can be used to override the offset stored in the sh_name field.
 164   // It does not affect the name stored in the string table.
 165   Optional<llvm::yaml::Hex64> ShName;
 166
 167   // This can be used to override the sh_offset field. It does not place the
 168   // section data at the offset specified.
 169   Optional<llvm::yaml::Hex64> ShOffset;
 170
 171   // This can be used to override the sh_size field. It does not affect the
 172   // content written.
 173   Optional<llvm::yaml::Hex64> ShSize;
 174 };
 175
 176 struct StackSizesSection : Section {
 177   Optional<yaml::BinaryRef> Content;
 178   Optional<llvm::yaml::Hex64> Size;
 179   Optional<std::vector<StackSizeEntry>> Entries;
 180
 181   StackSizesSection() : Section(SectionKind::StackSizes) {}
 182
 183   static bool classof(const Section *S) {
 184     return S->Kind == SectionKind::StackSizes;
 185   }
 186
 187   static bool nameMatches(StringRef Name) {
 188     return Name == ".stack_sizes";
 189   }
 190 };
 191
 192 struct DynamicSection : Section {
 193   std::vector<DynamicEntry> Entries;
 194   Optional<yaml::BinaryRef> Content;
 195
 196   DynamicSection() : Section(SectionKind::Dynamic) {}
 197
 198   static bool classof(const Section *S) {
 199     return S->Kind == SectionKind::Dynamic;
 200   }
 201 };
 202
 203 struct RawContentSection : Section {
 204   Optional<yaml::BinaryRef> Content;
 205   Optional<llvm::yaml::Hex64> Size;
 206   Optional<llvm::yaml::Hex64> Info;
 207
 208   RawContentSection() : Section(SectionKind::RawContent) {}
 209
 210   static bool classof(const Section *S) {
 211     return S->Kind == SectionKind::RawContent;
 212   }
 213 };
 214
 215 struct NoBitsSection : Section {
 216   llvm::yaml::Hex64 Size;
 217
 218   NoBitsSection() : Section(SectionKind::NoBits) {}
 219
 220   static bool classof(const Section *S) {
 221     return S->Kind == SectionKind::NoBits;
 222   }
 223 };
 224
 225 struct HashSection : Section {
 226   Optional<yaml::BinaryRef> Content;
 227   Optional<llvm::yaml::Hex64> Size;
 228   Optional<std::vector<uint32_t>> Bucket;
 229   Optional<std::vector<uint32_t>> Chain;
 230
 231   HashSection() : Section(SectionKind::Hash) {}
 232
 233   static bool classof(const Section *S) { return S->Kind == SectionKind::Hash; }
 234 };
 235
 236 struct VernauxEntry {
 237   uint32_t Hash;
 238   uint16_t Flags;
 239   uint16_t Other;
 240   StringRef Name;
 241 };
 242
 243 struct VerneedEntry {
 244   uint16_t Version;
 245   StringRef File;
 246   std::vector<VernauxEntry> AuxV;
 247 };
 248
 249 struct VerneedSection : Section {
 250   std::vector<VerneedEntry> VerneedV;
 251   llvm::yaml::Hex64 Info;
 252
 253   VerneedSection() : Section(SectionKind::Verneed) {}
 254
 255   static bool classof(const Section *S) {
 256     return S->Kind == SectionKind::Verneed;
 257   }
 258 };
 259
 260 struct AddrsigSymbol {
 261   AddrsigSymbol(StringRef N) : Name(N), Index(None) {}
 262   AddrsigSymbol(llvm::yaml::Hex32 Ndx) : Name(None), Index(Ndx) {}
 263   AddrsigSymbol() : Name(None), Index(None) {}
 264
 265   Optional<StringRef> Name;
 266   Optional<llvm::yaml::Hex32> Index;
 267 };
 268
 269 struct AddrsigSection : Section {
 270   Optional<yaml::BinaryRef> Content;
 271   Optional<std::vector<AddrsigSymbol>> Symbols;
 272
 273   AddrsigSection() : Section(SectionKind::Addrsig) {}
 274   static bool classof(const Section *S) {
 275     return S->Kind == SectionKind::Addrsig;
 276   }
 277 };
 278
 279 struct SymverSection : Section {
 280   std::vector<uint16_t> Entries;
 281
 282   SymverSection() : Section(SectionKind::Symver) {}
 283
 284   static bool classof(const Section *S) {
 285     return S->Kind == SectionKind::Symver;
 286   }
 287 };
 288
 289 struct VerdefEntry {
 290   uint16_t Version;
 291   uint16_t Flags;
 292   uint16_t VersionNdx;
 293   uint32_t Hash;
 294   std::vector<StringRef> VerNames;
 295 };
 296
 297 struct VerdefSection : Section {
 298   std::vector<VerdefEntry> Entries;
 299   llvm::yaml::Hex64 Info;
 300
 301   VerdefSection() : Section(SectionKind::Verdef) {}
 302
 303   static bool classof(const Section *S) {
 304     return S->Kind == SectionKind::Verdef;
 305   }
 306 };
 307
 308 struct Group : Section {
 309   // Members of a group contain a flag and a list of section indices
 310   // that are part of the group.
 311   std::vector<SectionOrType> Members;
 312   StringRef Signature; /* Info */
 313
 314   Group() : Section(SectionKind::Group) {}
 315
 316   static bool classof(const Section *S) {
 317     return S->Kind == SectionKind::Group;
 318   }
 319 };
 320
 321 struct Relocation {
 322   llvm::yaml::Hex64 Offset;
 323   int64_t Addend;
 324   ELF_REL Type;
 325   Optional<StringRef> Symbol;
 326 };
 327
 328 struct RelocationSection : Section {
 329   std::vector<Relocation> Relocations;
 330   StringRef RelocatableSec; /* Info */
 331
 332   RelocationSection() : Section(SectionKind::Relocation) {}
 333
 334   static bool classof(const Section *S) {
 335     return S->Kind == SectionKind::Relocation;
 336   }
 337 };
 338
 339 struct SymtabShndxSection : Section {
 340   std::vector<uint32_t> Entries;
 341
 342   SymtabShndxSection() : Section(SectionKind::SymtabShndxSection) {}
 343
 344   static bool classof(const Section *S) {
 345     return S->Kind == SectionKind::SymtabShndxSection;
 346   }
 347 };
 348
 349 // Represents .MIPS.abiflags section
 350 struct MipsABIFlags : Section {
 351   llvm::yaml::Hex16 Version;
 352   MIPS_ISA ISALevel;
 353   llvm::yaml::Hex8 ISARevision;
 354   MIPS_AFL_REG GPRSize;
 355   MIPS_AFL_REG CPR1Size;
 356   MIPS_AFL_REG CPR2Size;
 357   MIPS_ABI_FP FpABI;
 358   MIPS_AFL_EXT ISAExtension;
 359   MIPS_AFL_ASE ASEs;
 360   MIPS_AFL_FLAGS1 Flags1;
 361   llvm::yaml::Hex32 Flags2;
 362
 363   MipsABIFlags() : Section(SectionKind::MipsABIFlags) {}
 364
 365   static bool classof(const Section *S) {
 366     return S->Kind == SectionKind::MipsABIFlags;
 367   }
 368 };
 369
 370 struct Object {
 371   FileHeader Header;
 372   std::vector<ProgramHeader> ProgramHeaders;
 373   std::vector<std::unique_ptr<Section>> Sections;
 374   // Although in reality the symbols reside in a section, it is a lot
 375   // cleaner and nicer if we read them from the YAML as a separate
 376   // top-level key, which automatically ensures that invariants like there
 377   // being a single SHT_SYMTAB section are upheld.
 378   std::vector<Symbol> Symbols;
 379   std::vector<Symbol> DynamicSymbols;
 380 };
 381
 382 } // end namespace ELFYAML
 383 } // end namespace llvm
 384
 385 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::AddrsigSymbol)
 386 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 387 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 388 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 389 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 390 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 391 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 392 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 393 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 394 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 395 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 396 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
 397
 398 namespace llvm {
 399 namespace yaml {
 400
 401 template <>
 402 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
 403   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
 404 };
 405
 406 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
 407   static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
 408 };
 409
 410 template <>
 411 struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
 412   static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
 413 };
 414
 415 template <>
 416 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
 417   static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
 418 };
 419
 420 template <>
 421 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
 422   static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
 423 };
 424
 425 template <>
 426 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
 427   static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
 428 };
 429
 430 template <>
 431 struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
 432   static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
 433 };
 434
 435 template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
 436   static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
 437 };
 438
 439 template <>
 440 struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
 441   static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
 442 };
 443
 444 template <>
 445 struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
 446   static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
 447 };
 448
 449 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
 450   static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
 451 };
 452
 453 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
 454   static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
 455 };
 456
 457 template <>
 458 struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
 459   static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
 460 };
 461
 462 template <>
 463 struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
 464   static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
 465 };
 466
 467 template <>
 468 struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
 469   static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
 470 };
 471
 472 template <>
 473 struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
 474   static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
 475 };
 476
 477 template <>
 478 struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
 479   static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
 480 };
 481
 482 template <>
 483 struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
 484   static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
 485 };
 486
 487 template <>
 488 struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
 489   static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
 490 };
 491
 492 template <>
 493 struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
 494   static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
 495 };
 496
 497 template <>
 498 struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
 499   static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
 500 };
 501
 502 template <>
 503 struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
 504   static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
 505 };
 506
 507 template <>
 508 struct MappingTraits<ELFYAML::FileHeader> {
 509   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 510 };
 511
 512 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
 513   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 514 };
 515
 516 template <>
 517 struct MappingTraits<ELFYAML::Symbol> {
 518   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
 519   static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
 520 };
 521
 522 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
 523   static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
 524 };
 525
 526 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
 527   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 528 };
 529
 530 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
 531   static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
 532 };
 533
 534 template <> struct MappingTraits<ELFYAML::VerneedEntry> {
 535   static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
 536 };
 537
 538 template <> struct MappingTraits<ELFYAML::VernauxEntry> {
 539   static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
 540 };
 541
 542 template <> struct MappingTraits<ELFYAML::AddrsigSymbol> {
 543   static void mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym);
 544 };
 545
 546 template <> struct MappingTraits<ELFYAML::Relocation> {
 547   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 548 };
 549
 550 template <>
 551 struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
 552   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
 553   static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);
 554 };
 555
 556 template <>
 557 struct MappingTraits<ELFYAML::Object> {
 558   static void mapping(IO &IO, ELFYAML::Object &Object);
 559 };
 560
 561 template <> struct MappingTraits<ELFYAML::SectionOrType> {
 562   static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
 563 };
 564
 565 template <> struct MappingTraits<ELFYAML::SectionName> {
 566   static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
 567 };
 568
 569 } // end namespace yaml
 570 } // end namespace llvm
 571
 572 #endif // LLVM_OBJECTYAML_ELFYAML_H