LLVM  17.0.0git
ELFYAML.h
Go to the documentation of this file.
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/BinaryFormat/ELF.h"
20 #include "llvm/Object/ELFTypes.h"
22 #include "llvm/ObjectYAML/YAML.h"
24 #include <cstdint>
25 #include <memory>
26 #include <optional>
27 #include <vector>
28 
29 namespace llvm {
30 namespace ELFYAML {
31 
33 std::string appendUniqueSuffix(StringRef Name, const Twine& Msg);
34 
35 // These types are invariant across 32/64-bit ELF, so for simplicity just
36 // directly give them their exact sizes. We don't need to worry about
37 // endianness because these are just the types in the YAMLIO structures,
38 // and are appropriately converted to the necessary endianness when
39 // reading/generating binary object files.
40 // The naming of these types is intended to be ELF_PREFIX, where PREFIX is
41 // the common prefix of the respective constants. E.g. ELF_EM corresponds
42 // to the `e_machine` constants, like `EM_X86_64`.
43 // In the future, these would probably be better suited by C++11 enum
44 // class's with appropriate fixed underlying type.
48 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
49 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
50 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)
51 // Just use 64, since it can hold 32-bit values too.
53 // Just use 64, since it can hold 32-bit values too.
58 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)
59 // Just use 64, since it can hold 32-bit values too.
62 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
63 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
65 
66 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
67 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
70 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
72 
73 LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)
74 LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)
75 
76 template <class ELFT>
77 unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
78  StringRef SecName) {
79  if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
80  return sizeof(object::Elf_Mips_ABIFlags<ELFT>);
81 
82  switch (SecType) {
83  case ELF::SHT_SYMTAB:
84  case ELF::SHT_DYNSYM:
85  return sizeof(typename ELFT::Sym);
86  case ELF::SHT_GROUP:
87  return sizeof(typename ELFT::Word);
88  case ELF::SHT_REL:
89  return sizeof(typename ELFT::Rel);
90  case ELF::SHT_RELA:
91  return sizeof(typename ELFT::Rela);
92  case ELF::SHT_RELR:
93  return sizeof(typename ELFT::Relr);
94  case ELF::SHT_DYNAMIC:
95  return sizeof(typename ELFT::Dyn);
96  case ELF::SHT_HASH:
97  return sizeof(typename ELFT::Word);
99  return sizeof(typename ELFT::Word);
100  case ELF::SHT_GNU_versym:
101  return sizeof(typename ELFT::Half);
103  return sizeof(object::Elf_CGProfile_Impl<ELFT>);
104  default:
105  if (SecName == ".debug_str")
106  return 1;
107  return 0;
108  }
109 }
110 
111 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
112 // since 64-bit can hold 32-bit values too.
113 struct FileHeader {
114  ELF_ELFCLASS Class;
115  ELF_ELFDATA Data;
116  ELF_ELFOSABI OSABI;
117  llvm::yaml::Hex8 ABIVersion;
118  ELF_ET Type;
119  std::optional<ELF_EM> Machine;
120  ELF_EF Flags;
121  llvm::yaml::Hex64 Entry;
122  std::optional<StringRef> SectionHeaderStringTable;
123 
124  std::optional<llvm::yaml::Hex64> EPhOff;
125  std::optional<llvm::yaml::Hex16> EPhEntSize;
126  std::optional<llvm::yaml::Hex16> EPhNum;
127  std::optional<llvm::yaml::Hex16> EShEntSize;
128  std::optional<llvm::yaml::Hex64> EShOff;
129  std::optional<llvm::yaml::Hex16> EShNum;
130  std::optional<llvm::yaml::Hex16> EShStrNdx;
131 };
132 
135 };
136 
137 struct Symbol {
139  ELF_STT Type;
140  std::optional<StringRef> Section;
141  std::optional<ELF_SHN> Index;
142  ELF_STB Binding;
143  std::optional<llvm::yaml::Hex64> Value;
144  std::optional<llvm::yaml::Hex64> Size;
145  std::optional<uint8_t> Other;
146 
147  std::optional<uint32_t> StName;
148 };
149 
152 };
153 
154 struct DynamicEntry {
155  ELF_DYNTAG Tag;
156  llvm::yaml::Hex64 Val;
157 };
158 
160  struct BBEntry {
162  llvm::yaml::Hex64 AddressOffset;
163  llvm::yaml::Hex64 Size;
164  llvm::yaml::Hex64 Metadata;
165  };
166  uint8_t Version;
167  llvm::yaml::Hex8 Feature;
168  llvm::yaml::Hex64 Address;
169  std::optional<uint64_t> NumBlocks;
170  std::optional<std::vector<BBEntry>> BBEntries;
171 };
172 
174  llvm::yaml::Hex64 Address;
175  llvm::yaml::Hex64 Size;
176 };
177 
178 struct NoteEntry {
181  ELF_NT Type;
182 };
183 
184 struct Chunk {
185  enum class ChunkKind {
186  Dynamic,
187  Group,
188  RawContent,
189  Relocation,
190  Relr,
191  NoBits,
192  Note,
193  Hash,
194  GnuHash,
195  Verdef,
196  Verneed,
197  StackSizes,
199  Symver,
201  MipsABIFlags,
202  Addrsig,
206  BBAddrMap,
207 
208  // Special chunks.
212  };
213 
216  std::optional<llvm::yaml::Hex64> Offset;
217 
218  // Usually chunks are not created implicitly, but rather loaded from YAML.
219  // This flag is used to signal whether this is the case or not.
221 
223  virtual ~Chunk();
224 };
225 
226 struct Section : public Chunk {
227  ELF_SHT Type;
228  std::optional<ELF_SHF> Flags;
229  std::optional<llvm::yaml::Hex64> Address;
230  std::optional<StringRef> Link;
231  llvm::yaml::Hex64 AddressAlign;
232  std::optional<llvm::yaml::Hex64> EntSize;
233 
234  std::optional<yaml::BinaryRef> Content;
235  std::optional<llvm::yaml::Hex64> Size;
236 
237  // Holds the original section index.
238  unsigned OriginalSecNdx;
239 
241 
242  static bool classof(const Chunk *S) {
243  return S->Kind < ChunkKind::SpecialChunksStart;
244  }
245 
246  // Some derived sections might have their own special entries. This method
247  // returns a vector of <entry name, is used> pairs. It is used for section
248  // validation.
249  virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
250  return {};
251  };
252 
253  // The following members are used to override section fields which is
254  // useful for creating invalid objects.
255 
256  // This can be used to override the sh_addralign field.
257  std::optional<llvm::yaml::Hex64> ShAddrAlign;
258 
259  // This can be used to override the offset stored in the sh_name field.
260  // It does not affect the name stored in the string table.
261  std::optional<llvm::yaml::Hex64> ShName;
262 
263  // This can be used to override the sh_offset field. It does not place the
264  // section data at the offset specified.
265  std::optional<llvm::yaml::Hex64> ShOffset;
266 
267  // This can be used to override the sh_size field. It does not affect the
268  // content written.
269  std::optional<llvm::yaml::Hex64> ShSize;
270 
271  // This can be used to override the sh_flags field.
272  std::optional<llvm::yaml::Hex64> ShFlags;
273 
274  // This can be used to override the sh_type field. It is useful when we
275  // want to use specific YAML keys for a section of a particular type to
276  // describe the content, but still want to have a different final type
277  // for the section.
278  std::optional<ELF_SHT> ShType;
279 };
280 
281 // Fill is a block of data which is placed outside of sections. It is
282 // not present in the sections header table, but it might affect the output file
283 // size and program headers produced.
284 struct Fill : Chunk {
285  std::optional<yaml::BinaryRef> Pattern;
286  llvm::yaml::Hex64 Size;
287 
288  Fill() : Chunk(ChunkKind::Fill, /*Implicit=*/false) {}
289 
290  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
291 };
292 
296 
297  static bool classof(const Chunk *S) {
298  return S->Kind == ChunkKind::SectionHeaderTable;
299  }
300 
301  std::optional<std::vector<SectionHeader>> Sections;
302  std::optional<std::vector<SectionHeader>> Excluded;
303  std::optional<bool> NoHeaders;
304 
305  size_t getNumHeaders(size_t SectionsNum) const {
306  if (IsImplicit || isDefault())
307  return SectionsNum;
308  if (NoHeaders)
309  return (*NoHeaders) ? 0 : SectionsNum;
310  return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
311  }
312 
313  bool isDefault() const { return !Sections && !Excluded && !NoHeaders; }
314 
315  static constexpr StringRef TypeStr = "SectionHeaderTable";
316 };
317 
319  std::optional<std::vector<BBAddrMapEntry>> Entries;
320 
321  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
322 
323  std::vector<std::pair<StringRef, bool>> getEntries() const override {
324  return {{"Entries", Entries.has_value()}};
325  };
326 
327  static bool classof(const Chunk *S) {
328  return S->Kind == ChunkKind::BBAddrMap;
329  }
330 };
331 
333  std::optional<std::vector<StackSizeEntry>> Entries;
334 
335  StackSizesSection() : Section(ChunkKind::StackSizes) {}
336 
337  std::vector<std::pair<StringRef, bool>> getEntries() const override {
338  return {{"Entries", Entries.has_value()}};
339  };
340 
341  static bool classof(const Chunk *S) {
342  return S->Kind == ChunkKind::StackSizes;
343  }
344 
345  static bool nameMatches(StringRef Name) {
346  return Name == ".stack_sizes";
347  }
348 };
349 
351  std::optional<std::vector<DynamicEntry>> Entries;
352 
354 
355  std::vector<std::pair<StringRef, bool>> getEntries() const override {
356  return {{"Entries", Entries.has_value()}};
357  };
358 
359  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
360 };
361 
363  std::optional<llvm::yaml::Hex64> Info;
364 
365  RawContentSection() : Section(ChunkKind::RawContent) {}
366 
367  static bool classof(const Chunk *S) {
368  return S->Kind == ChunkKind::RawContent;
369  }
370 
371  // Is used when a content is read as an array of bytes.
372  std::optional<std::vector<uint8_t>> ContentBuf;
373 };
374 
377 
378  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
379 };
380 
382  std::optional<std::vector<ELFYAML::NoteEntry>> Notes;
383 
385 
386  std::vector<std::pair<StringRef, bool>> getEntries() const override {
387  return {{"Notes", Notes.has_value()}};
388  };
389 
390  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
391 };
392 
394  std::optional<std::vector<uint32_t>> Bucket;
395  std::optional<std::vector<uint32_t>> Chain;
396 
397  std::vector<std::pair<StringRef, bool>> getEntries() const override {
398  return {{"Bucket", Bucket.has_value()}, {"Chain", Chain.has_value()}};
399  };
400 
401  // The following members are used to override section fields.
402  // This is useful for creating invalid objects.
403  std::optional<llvm::yaml::Hex64> NBucket;
404  std::optional<llvm::yaml::Hex64> NChain;
405 
407 
408  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
409 };
410 
412  // The number of hash buckets.
413  // Not used when dumping the object, but can be used to override
414  // the real number of buckets when emiting an object from a YAML document.
415  std::optional<llvm::yaml::Hex32> NBuckets;
416 
417  // Index of the first symbol in the dynamic symbol table
418  // included in the hash table.
419  llvm::yaml::Hex32 SymNdx;
420 
421  // The number of words in the Bloom filter.
422  // Not used when dumping the object, but can be used to override the real
423  // number of words in the Bloom filter when emiting an object from a YAML
424  // document.
425  std::optional<llvm::yaml::Hex32> MaskWords;
426 
427  // A shift constant used by the Bloom filter.
428  llvm::yaml::Hex32 Shift2;
429 };
430 
432  std::optional<GnuHashHeader> Header;
433  std::optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
434  std::optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
435  std::optional<std::vector<llvm::yaml::Hex32>> HashValues;
436 
438 
439  std::vector<std::pair<StringRef, bool>> getEntries() const override {
440  return {{"Header", Header.has_value()},
441  {"BloomFilter", BloomFilter.has_value()},
442  {"HashBuckets", HashBuckets.has_value()},
443  {"HashValues", HashValues.has_value()}};
444  };
445 
446  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
447 };
448 
449 struct VernauxEntry {
454 };
455 
456 struct VerneedEntry {
459  std::vector<VernauxEntry> AuxV;
460 };
461 
463  std::optional<std::vector<VerneedEntry>> VerneedV;
464  std::optional<llvm::yaml::Hex64> Info;
465 
467 
468  std::vector<std::pair<StringRef, bool>> getEntries() const override {
469  return {{"Dependencies", VerneedV.has_value()}};
470  };
471 
472  static bool classof(const Chunk *S) {
473  return S->Kind == ChunkKind::Verneed;
474  }
475 };
476 
478  std::optional<std::vector<YAMLFlowString>> Symbols;
479 
481 
482  std::vector<std::pair<StringRef, bool>> getEntries() const override {
483  return {{"Symbols", Symbols.has_value()}};
484  };
485 
486  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
487 };
488 
489 struct LinkerOption {
492 };
493 
495  std::optional<std::vector<LinkerOption>> Options;
496 
497  LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
498 
499  std::vector<std::pair<StringRef, bool>> getEntries() const override {
500  return {{"Options", Options.has_value()}};
501  };
502 
503  static bool classof(const Chunk *S) {
504  return S->Kind == ChunkKind::LinkerOptions;
505  }
506 };
507 
509  std::optional<std::vector<YAMLFlowString>> Libs;
510 
511  DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
512 
513  std::vector<std::pair<StringRef, bool>> getEntries() const override {
514  return {{"Libraries", Libs.has_value()}};
515  };
516 
517  static bool classof(const Chunk *S) {
518  return S->Kind == ChunkKind::DependentLibraries;
519  }
520 };
521 
522 // Represents the call graph profile section entry.
524  // The weight of the edge.
526 };
527 
529  std::optional<std::vector<CallGraphEntryWeight>> Entries;
530 
531  CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
532 
533  std::vector<std::pair<StringRef, bool>> getEntries() const override {
534  return {{"Entries", Entries.has_value()}};
535  };
536 
537  static bool classof(const Chunk *S) {
538  return S->Kind == ChunkKind::CallGraphProfile;
539  }
540 };
541 
543  std::optional<std::vector<uint16_t>> Entries;
544 
546 
547  std::vector<std::pair<StringRef, bool>> getEntries() const override {
548  return {{"Entries", Entries.has_value()}};
549  };
550 
551  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
552 };
553 
554 struct VerdefEntry {
555  std::optional<uint16_t> Version;
556  std::optional<uint16_t> Flags;
557  std::optional<uint16_t> VersionNdx;
558  std::optional<uint32_t> Hash;
559  std::vector<StringRef> VerNames;
560 };
561 
563  std::optional<std::vector<VerdefEntry>> Entries;
564  std::optional<llvm::yaml::Hex64> Info;
565 
567 
568  std::vector<std::pair<StringRef, bool>> getEntries() const override {
569  return {{"Entries", Entries.has_value()}};
570  };
571 
572  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
573 };
574 
576  // Members of a group contain a flag and a list of section indices
577  // that are part of the group.
578  std::optional<std::vector<SectionOrType>> Members;
579  std::optional<StringRef> Signature; /* Info */
580 
582 
583  std::vector<std::pair<StringRef, bool>> getEntries() const override {
584  return {{"Members", Members.has_value()}};
585  };
586 
587  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
588 };
589 
590 struct Relocation {
591  llvm::yaml::Hex64 Offset;
592  YAMLIntUInt Addend;
593  ELF_REL Type;
594  std::optional<StringRef> Symbol;
595 };
596 
598  std::optional<std::vector<Relocation>> Relocations;
600 
602 
603  std::vector<std::pair<StringRef, bool>> getEntries() const override {
604  return {{"Relocations", Relocations.has_value()}};
605  };
606 
607  static bool classof(const Chunk *S) {
608  return S->Kind == ChunkKind::Relocation;
609  }
610 };
611 
613  std::optional<std::vector<llvm::yaml::Hex64>> Entries;
614 
616 
617  std::vector<std::pair<StringRef, bool>> getEntries() const override {
618  return {{"Entries", Entries.has_value()}};
619  };
620 
621  static bool classof(const Chunk *S) {
622  return S->Kind == ChunkKind::Relr;
623  }
624 };
625 
627  std::optional<std::vector<uint32_t>> Entries;
628 
630 
631  std::vector<std::pair<StringRef, bool>> getEntries() const override {
632  return {{"Entries", Entries.has_value()}};
633  };
634 
635  static bool classof(const Chunk *S) {
636  return S->Kind == ChunkKind::SymtabShndxSection;
637  }
638 };
639 
641  llvm::yaml::Hex32 Offset;
642  llvm::yaml::Hex32 Value;
643 };
644 
646  std::optional<std::vector<ARMIndexTableEntry>> Entries;
647 
648  ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
649 
650  std::vector<std::pair<StringRef, bool>> getEntries() const override {
651  return {{"Entries", Entries.has_value()}};
652  };
653 
654  static bool classof(const Chunk *S) {
655  return S->Kind == ChunkKind::ARMIndexTable;
656  }
657 };
658 
659 // Represents .MIPS.abiflags section
661  llvm::yaml::Hex16 Version;
662  MIPS_ISA ISALevel;
663  llvm::yaml::Hex8 ISARevision;
664  MIPS_AFL_REG GPRSize;
665  MIPS_AFL_REG CPR1Size;
666  MIPS_AFL_REG CPR2Size;
667  MIPS_ABI_FP FpABI;
668  MIPS_AFL_EXT ISAExtension;
669  MIPS_AFL_ASE ASEs;
670  MIPS_AFL_FLAGS1 Flags1;
671  llvm::yaml::Hex32 Flags2;
672 
674 
675  static bool classof(const Chunk *S) {
676  return S->Kind == ChunkKind::MipsABIFlags;
677  }
678 };
679 
681  ELF_PT Type;
682  ELF_PF Flags;
683  llvm::yaml::Hex64 VAddr;
684  llvm::yaml::Hex64 PAddr;
685  std::optional<llvm::yaml::Hex64> Align;
686  std::optional<llvm::yaml::Hex64> FileSize;
687  std::optional<llvm::yaml::Hex64> MemSize;
688  std::optional<llvm::yaml::Hex64> Offset;
689  std::optional<StringRef> FirstSec;
690  std::optional<StringRef> LastSec;
691 
692  // This vector contains all chunks from [FirstSec, LastSec].
693  std::vector<Chunk *> Chunks;
694 };
695 
696 struct Object {
698  std::vector<ProgramHeader> ProgramHeaders;
699 
700  // An object might contain output section descriptions as well as
701  // custom data that does not belong to any section.
702  std::vector<std::unique_ptr<Chunk>> Chunks;
703 
704  // Although in reality the symbols reside in a section, it is a lot
705  // cleaner and nicer if we read them from the YAML as a separate
706  // top-level key, which automatically ensures that invariants like there
707  // being a single SHT_SYMTAB section are upheld.
708  std::optional<std::vector<Symbol>> Symbols;
709  std::optional<std::vector<Symbol>> DynamicSymbols;
710  std::optional<DWARFYAML::Data> DWARF;
711 
712  std::vector<Section *> getSections() {
713  std::vector<Section *> Ret;
714  for (const std::unique_ptr<Chunk> &Sec : Chunks)
715  if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
716  Ret.push_back(S);
717  return Ret;
718  }
719 
721  for (const std::unique_ptr<Chunk> &C : Chunks)
722  if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
723  return *S;
724  llvm_unreachable("the section header table chunk must always be present");
725  }
726 
727  ELF_ELFOSABI getOSAbi() const;
728  unsigned getMachine() const;
729 };
730 
732  const NoBitsSection &S);
733 
734 } // end namespace ELFYAML
735 } // end namespace llvm
736 
746 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
754 
755 namespace llvm {
756 namespace yaml {
757 
758 template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
759  static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
760  raw_ostream &Out);
761  static StringRef input(StringRef Scalar, void *Ctx,
762  ELFYAML::YAMLIntUInt &Val);
763  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
764 };
765 
766 template <>
767 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
768  static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
769 };
770 
771 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
772  static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
773 };
774 
775 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_NT> {
776  static void enumeration(IO &IO, ELFYAML::ELF_NT &Value);
777 };
778 
779 template <>
780 struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
781  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
782 };
783 
784 template <>
785 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
786  static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
787 };
788 
789 template <>
790 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
791  static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
792 };
793 
794 template <>
795 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
796  static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
797 };
798 
799 template <>
800 struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
801  static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
802 };
803 
804 template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
805  static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
806 };
807 
808 template <>
809 struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
810  static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
811 };
812 
813 template <>
814 struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
815  static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
816 };
817 
818 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
819  static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
820 };
821 
822 template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
823  static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
824 };
825 
826 template <>
827 struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
828  static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
829 };
830 
831 template <>
832 struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
833  static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
834 };
835 
836 template <>
837 struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
838  static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
839 };
840 
841 template <>
842 struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
843  static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
844 };
845 
846 template <>
847 struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
848  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
849 };
850 
851 template <>
852 struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
853  static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
854 };
855 
856 template <>
857 struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
858  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
859 };
860 
861 template <>
862 struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
863  static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
864 };
865 
866 template <>
867 struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
868  static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
869 };
870 
871 template <>
872 struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
873  static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
874 };
875 
876 template <>
877 struct MappingTraits<ELFYAML::FileHeader> {
878  static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
879 };
880 
881 template <> struct MappingTraits<ELFYAML::SectionHeader> {
882  static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
883 };
884 
885 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
886  static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
887  static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
888 };
889 
890 template <>
891 struct MappingTraits<ELFYAML::Symbol> {
892  static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
893  static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
894 };
895 
896 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
897  static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
898 };
899 
900 template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
901  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
902 };
903 
904 template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
905  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &Rel);
906 };
907 
908 template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
909  static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
910 };
911 
912 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
913  static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
914 };
915 
916 template <> struct MappingTraits<ELFYAML::NoteEntry> {
917  static void mapping(IO &IO, ELFYAML::NoteEntry &N);
918 };
919 
920 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
921  static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
922 };
923 
924 template <> struct MappingTraits<ELFYAML::VerneedEntry> {
925  static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
926 };
927 
928 template <> struct MappingTraits<ELFYAML::VernauxEntry> {
929  static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
930 };
931 
932 template <> struct MappingTraits<ELFYAML::LinkerOption> {
933  static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
934 };
935 
936 template <> struct MappingTraits<ELFYAML::CallGraphEntryWeight> {
937  static void mapping(IO &IO, ELFYAML::CallGraphEntryWeight &E);
938 };
939 
940 template <> struct MappingTraits<ELFYAML::Relocation> {
941  static void mapping(IO &IO, ELFYAML::Relocation &Rel);
942 };
943 
944 template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
945  static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
946 };
947 
948 template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
949  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
950  static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
951 };
952 
953 template <>
954 struct MappingTraits<ELFYAML::Object> {
955  static void mapping(IO &IO, ELFYAML::Object &Object);
956 };
957 
958 template <> struct MappingTraits<ELFYAML::SectionOrType> {
959  static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
960 };
961 
962 } // end namespace yaml
963 } // end namespace llvm
964 
965 #endif // LLVM_OBJECTYAML_ELFYAML_H
llvm::ELFYAML::BBAddrMapSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:323
llvm::ELFYAML::FileHeader::Machine
std::optional< ELF_EM > Machine
Definition: ELFYAML.h:119
llvm::ELFYAML::BBAddrMapEntry::Address
llvm::yaml::Hex64 Address
Definition: ELFYAML.h:168
llvm::ELFYAML::Chunk::Chunk
Chunk(ChunkKind K, bool Implicit)
Definition: ELFYAML.h:222
llvm::ELFYAML::StackSizeEntry::Address
llvm::yaml::Hex64 Address
Definition: ELFYAML.h:174
llvm::ELFYAML::Symbol::Index
std::optional< ELF_SHN > Index
Definition: ELFYAML.h:141
llvm::ELFYAML::BBAddrMapSection::BBAddrMapSection
BBAddrMapSection()
Definition: ELFYAML.h:321
llvm::ELFYAML::LinkerOptionsSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:499
llvm::ELF::SHT_MIPS_ABIFLAGS
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:1064
llvm::ELFYAML::Chunk::ChunkKind::SectionHeaderTable
@ SectionHeaderTable
llvm::ELFYAML::Section::Link
std::optional< StringRef > Link
Definition: ELFYAML.h:230
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::ELFYAML::NoteSection
Definition: ELFYAML.h:381
llvm::ELFYAML::AddrsigSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:486
llvm::ELFYAML::shouldAllocateFileSpace
bool shouldAllocateFileSpace(ArrayRef< ProgramHeader > Phdrs, const NoBitsSection &S)
Definition: ELFEmitter.cpp:1222
llvm::ELFYAML::ProgramHeader::Chunks
std::vector< Chunk * > Chunks
Definition: ELFYAML.h:693
llvm::ELFYAML::getDefaultShEntSize
unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType, StringRef SecName)
Definition: ELFYAML.h:77
llvm::ELFYAML::Chunk::ChunkKind::NoBits
@ NoBits
llvm::ELFYAML::Fill
Definition: ELFYAML.h:284
llvm::ELFYAML::GroupSection::GroupSection
GroupSection()
Definition: ELFYAML.h:581
llvm::ELFYAML::NoteSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:386
Note
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles Note
Definition: README.txt:239
StringRef.h
llvm::ELFYAML::Relocation::Offset
llvm::yaml::Hex64 Offset
Definition: ELFYAML.h:591
llvm::ELFYAML::RawContentSection::RawContentSection
RawContentSection()
Definition: ELFYAML.h:365
llvm::ELFYAML::MipsABIFlags::ASEs
MIPS_AFL_ASE ASEs
Definition: ELFYAML.h:669
llvm::ELFYAML::CallGraphProfileSection
Definition: ELFYAML.h:528
llvm::ELFYAML::FileHeader::Type
ELF_ET Type
Definition: ELFYAML.h:118
llvm::ELFYAML::LinkerOption
Definition: ELFYAML.h:489
output
Current output
Definition: README.txt:1350
llvm::ELFYAML::VerdefEntry
Definition: ELFYAML.h:554
llvm::ELFYAML::VernauxEntry::Name
StringRef Name
Definition: ELFYAML.h:453
llvm::ELFYAML::HashSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:397
llvm::ELFYAML::Chunk::ChunkKind::GnuHash
@ GnuHash
llvm::ELFYAML::GroupSection
Definition: ELFYAML.h:575
llvm::ELFYAML::FileHeader
Definition: ELFYAML.h:113
llvm::ELFYAML::Symbol::Name
StringRef Name
Definition: ELFYAML.h:138
llvm::ELFYAML::NoBitsSection
Definition: ELFYAML.h:375
llvm::ELFYAML::GroupSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:583
LLVM_YAML_IS_SEQUENCE_VECTOR
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
llvm::ELFYAML::ProgramHeader
Definition: ELFYAML.h:680
llvm::ELFYAML::Chunk::ChunkKind::MipsABIFlags
@ MipsABIFlags
llvm::ELFYAML::Chunk::~Chunk
virtual ~Chunk()
llvm::ELFYAML::RelrSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:617
llvm::ELFYAML::Chunk::Offset
std::optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:216
llvm::ELFYAML::Relocation::Symbol
std::optional< StringRef > Symbol
Definition: ELFYAML.h:594
llvm::ELFYAML::GnuHashHeader::Shift2
llvm::yaml::Hex32 Shift2
Definition: ELFYAML.h:428
llvm::ELFYAML::RelocationSection::RelocatableSec
StringRef RelocatableSec
Definition: ELFYAML.h:599
llvm::object::Elf_Mips_ABIFlags
Definition: ELFTypes.h:782
llvm::ELFYAML::LinkerOptionsSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:503
llvm::ELFYAML::HashSection::HashSection
HashSection()
Definition: ELFYAML.h:406
llvm::ELFYAML::Symbol::Value
std::optional< llvm::yaml::Hex64 > Value
Definition: ELFYAML.h:143
llvm::ELFYAML::AddrsigSection
Definition: ELFYAML.h:477
llvm::ELFYAML::ProgramHeader::Offset
std::optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:688
llvm::ELFYAML::Fill::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:286
llvm::ELFYAML::Symbol::Type
ELF_STT Type
Definition: ELFYAML.h:139
llvm::ELFYAML::SectionHeader::Name
StringRef Name
Definition: ELFYAML.h:134
llvm::ELFYAML::Chunk::ChunkKind::Relocation
@ Relocation
llvm::ELFYAML::Object::getOSAbi
ELF_ELFOSABI getOSAbi() const
Definition: ELFYAML.cpp:33
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:119
llvm::ELFYAML::SymverSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:547
llvm::ELFYAML::GnuHashHeader::MaskWords
std::optional< llvm::yaml::Hex32 > MaskWords
Definition: ELFYAML.h:425
llvm::ELFYAML::Chunk::ChunkKind::DependentLibraries
@ DependentLibraries
llvm::yaml::MappingTraits
Definition: ModuleSummaryIndex.h:53
llvm::ELFYAML::Chunk::Kind
ChunkKind Kind
Definition: ELFYAML.h:214
llvm::ELFYAML::SymtabShndxSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:631
llvm::RISCVFeatures::validate
void validate(const Triple &TT, const FeatureBitset &FeatureBits)
Definition: RISCVBaseInfo.cpp:99
llvm::ELFYAML::RawContentSection
Definition: ELFYAML.h:362
llvm::ELFYAML::VerdefSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:568
llvm::ELFYAML::MipsABIFlags::CPR2Size
MIPS_AFL_REG CPR2Size
Definition: ELFYAML.h:666
llvm::ELFYAML::DynamicSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:355
llvm::ELFYAML::NoteSection::NoteSection
NoteSection()
Definition: ELFYAML.h:384
llvm::ELFYAML::RawContentSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:367
llvm::ELFYAML::SectionHeader
Definition: ELFYAML.h:133
llvm::ELFYAML::Section::Flags
std::optional< ELF_SHF > Flags
Definition: ELFYAML.h:228
llvm::ELFYAML::VernauxEntry::Hash
uint32_t Hash
Definition: ELFYAML.h:450
llvm::ELFYAML::VerneedSection::VerneedSection
VerneedSection()
Definition: ELFYAML.h:466
llvm::ELFYAML::Chunk::ChunkKind
ChunkKind
Definition: ELFYAML.h:185
llvm::yaml::ScalarTraits< ELFYAML::YAMLIntUInt >::mustQuote
static QuotingType mustQuote(StringRef)
Definition: ELFYAML.h:763
llvm::ELFYAML::CallGraphProfileSection::Entries
std::optional< std::vector< CallGraphEntryWeight > > Entries
Definition: ELFYAML.h:529
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:998
llvm::ELFYAML::SectionHeaderTable::getNumHeaders
size_t getNumHeaders(size_t SectionsNum) const
Definition: ELFYAML.h:305
llvm::ELFYAML::Object::DWARF
std::optional< DWARFYAML::Data > DWARF
Definition: ELFYAML.h:710
llvm::ELFYAML::Section::ShType
std::optional< ELF_SHT > ShType
Definition: ELFYAML.h:278
llvm::ELFYAML::GnuHashHeader::NBuckets
std::optional< llvm::yaml::Hex32 > NBuckets
Definition: ELFYAML.h:415
llvm::ELFYAML::VerdefSection::Info
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:564
llvm::ELFYAML::RelocationSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:607
llvm::ELFYAML::VerdefEntry::VerNames
std::vector< StringRef > VerNames
Definition: ELFYAML.h:559
llvm::ELFYAML::FileHeader::EShNum
std::optional< llvm::yaml::Hex16 > EShNum
Definition: ELFYAML.h:129
llvm::ELFYAML::FileHeader::EPhEntSize
std::optional< llvm::yaml::Hex16 > EPhEntSize
Definition: ELFYAML.h:125
llvm::ELFYAML::GnuHashSection::Header
std::optional< GnuHashHeader > Header
Definition: ELFYAML.h:432
llvm::ELFYAML::GnuHashSection::GnuHashSection
GnuHashSection()
Definition: ELFYAML.h:437
llvm::ELFYAML::Chunk::ChunkKind::RawContent
@ RawContent
llvm::ELFYAML::RelocationSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:603
llvm::ELFYAML::Section::ShAddrAlign
std::optional< llvm::yaml::Hex64 > ShAddrAlign
Definition: ELFYAML.h:251
llvm::ELFYAML::Object::getSections
std::vector< Section * > getSections()
Definition: ELFYAML.h:712
ELF.h
llvm::ELFYAML::NoteEntry::Type
ELF_NT Type
Definition: ELFYAML.h:181
llvm::ELFYAML::Chunk::ChunkKind::Verdef
@ Verdef
llvm::ELFYAML::MipsABIFlags::MipsABIFlags
MipsABIFlags()
Definition: ELFYAML.h:673
llvm::ELFYAML::SectionHeaderTable::isDefault
bool isDefault() const
Definition: ELFYAML.h:313
llvm::ELFYAML::Section::ShSize
std::optional< llvm::yaml::Hex64 > ShSize
Definition: ELFYAML.h:269
llvm::ELFYAML::RawContentSection::ContentBuf
std::optional< std::vector< uint8_t > > ContentBuf
Definition: ELFYAML.h:372
llvm::ELFYAML::Relocation
Definition: ELFYAML.h:590
llvm::ELFYAML::GnuHashSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:446
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ELFYAML::SymverSection::Entries
std::optional< std::vector< uint16_t > > Entries
Definition: ELFYAML.h:543
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ELFYAML::CallGraphProfileSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:537
llvm::ELFYAML::VerneedEntry
Definition: ELFYAML.h:456
llvm::ELFYAML::Symbol::Other
std::optional< uint8_t > Other
Definition: ELFYAML.h:145
llvm::ELFYAML::ARMIndexTableSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:654
llvm::ELFYAML::BBAddrMapEntry::BBEntries
std::optional< std::vector< BBEntry > > BBEntries
Definition: ELFYAML.h:170
llvm::ELFYAML::Chunk::ChunkKind::Symver
@ Symver
llvm::ELFYAML::VerneedEntry::File
StringRef File
Definition: ELFYAML.h:458
llvm::ELFYAML::AddrsigSection::AddrsigSection
AddrsigSection()
Definition: ELFYAML.h:480
false
Definition: StackSlotColoring.cpp:141
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:1031
llvm::ELFYAML::VerdefSection::Entries
std::optional< std::vector< VerdefEntry > > Entries
Definition: ELFYAML.h:563
YAML.h
llvm::ELFYAML::SymtabShndxSection::Entries
std::optional< std::vector< uint32_t > > Entries
Definition: ELFYAML.h:627
llvm::ELFYAML::FileHeader::EShEntSize
std::optional< llvm::yaml::Hex16 > EShEntSize
Definition: ELFYAML.h:127
llvm::ELFYAML::MipsABIFlags::Flags2
llvm::yaml::Hex32 Flags2
Definition: ELFYAML.h:671
llvm::ELFYAML::GnuHashSection
Definition: ELFYAML.h:431
llvm::ELFYAML::VerdefEntry::Hash
std::optional< uint32_t > Hash
Definition: ELFYAML.h:558
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:1000
llvm::ELFYAML::VerdefEntry::Flags
std::optional< uint16_t > Flags
Definition: ELFYAML.h:556
llvm::ELFYAML::Symbol::StName
std::optional< uint32_t > StName
Definition: ELFYAML.h:147
llvm::ELFYAML::LinkerOption::Key
StringRef Key
Definition: ELFYAML.h:490
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::ELFYAML::RelocationSection
Definition: ELFYAML.h:597
llvm::ELFYAML::BBAddrMapEntry::BBEntry::ID
uint32_t ID
Definition: ELFYAML.h:161
llvm::ELFYAML::Chunk::ChunkKind::BBAddrMap
@ BBAddrMap
llvm::ELFYAML::SectionHeaderTable::NoHeaders
std::optional< bool > NoHeaders
Definition: ELFYAML.h:303
input
The initial backend is deliberately restricted to z10 We should add support for later architectures at some point If an asm ties an i32 r result to an i64 input
Definition: README.txt:10
llvm::ELF::SHT_SYMTAB_SHNDX
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:1010
llvm::ELFYAML::HashSection::Bucket
std::optional< std::vector< uint32_t > > Bucket
Definition: ELFYAML.h:394
llvm::ELFYAML::DynamicSection::Entries
std::optional< std::vector< DynamicEntry > > Entries
Definition: ELFYAML.h:351
llvm::ELFYAML::StackSizesSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:341
llvm::ELFYAML::NoBitsSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:378
llvm::ELFYAML::DependentLibrariesSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:513
llvm::ELFYAML::BBAddrMapEntry::Feature
llvm::yaml::Hex8 Feature
Definition: ELFYAML.h:167
llvm::ELFYAML::VerneedSection::Info
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:464
llvm::ELFYAML::DynamicEntry::Tag
ELF_DYNTAG Tag
Definition: ELFYAML.h:155
llvm::ELFYAML::BBAddrMapEntry::BBEntry::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:163
llvm::ELFYAML::SymverSection
Definition: ELFYAML.h:542
llvm::ELFYAML::VerdefSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:572
llvm::ELFYAML::dropUniqueSuffix
StringRef dropUniqueSuffix(StringRef S)
Definition: ELFEmitter.cpp:695
llvm::OutputFileType::Object
@ Object
llvm::ELFYAML::GnuHashSection::HashBuckets
std::optional< std::vector< llvm::yaml::Hex32 > > HashBuckets
Definition: ELFYAML.h:434
DWARFYAML.h
llvm::ELFYAML::Object
Definition: ELFYAML.h:696
llvm::ELFYAML::SectionOrType::sectionNameOrType
StringRef sectionNameOrType
Definition: ELFYAML.h:151
llvm::ELFYAML::Object::getMachine
unsigned getMachine() const
Definition: ELFYAML.cpp:35
llvm::ELFYAML::Section::Address
std::optional< llvm::yaml::Hex64 > Address
Definition: ELFYAML.h:229
llvm::ELFYAML::appendUniqueSuffix
std::string appendUniqueSuffix(StringRef Name, const Twine &Msg)
Definition: ELFEmitter.cpp:688
llvm::ELFYAML::CallGraphProfileSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:533
llvm::ELFYAML::SectionOrType
Definition: ELFYAML.h:150
llvm::ELFYAML::ARMIndexTableEntry::Value
llvm::yaml::Hex32 Value
Definition: ELFYAML.h:642
llvm::ELFYAML::ProgramHeader::MemSize
std::optional< llvm::yaml::Hex64 > MemSize
Definition: ELFYAML.h:687
llvm::ELFYAML::SymtabShndxSection::SymtabShndxSection
SymtabShndxSection()
Definition: ELFYAML.h:629
uint64_t
llvm::ELFYAML::ProgramHeader::FileSize
std::optional< llvm::yaml::Hex64 > FileSize
Definition: ELFYAML.h:686
llvm::ELFYAML::SectionHeaderTable::TypeStr
static constexpr StringRef TypeStr
Definition: ELFYAML.h:315
llvm::ELFYAML::DynamicSection::DynamicSection
DynamicSection()
Definition: ELFYAML.h:353
llvm::ELFYAML::Chunk::ChunkKind::ARMIndexTable
@ ARMIndexTable
llvm::ELFYAML::LinkerOptionsSection::Options
std::optional< std::vector< LinkerOption > > Options
Definition: ELFYAML.h:495
llvm::ELFYAML::SymtabShndxSection
Definition: ELFYAML.h:626
llvm::ELFYAML::NoteSection::Notes
std::optional< std::vector< ELFYAML::NoteEntry > > Notes
Definition: ELFYAML.h:382
llvm::ELFYAML::Section::ShFlags
std::optional< llvm::yaml::Hex64 > ShFlags
Definition: ELFYAML.h:272
llvm::ELFYAML::FileHeader::Flags
ELF_EF Flags
Definition: ELFYAML.h:120
llvm::ELFYAML::ProgramHeader::Type
ELF_PT Type
Definition: ELFYAML.h:681
llvm::ELFYAML::BBAddrMapSection
Definition: ELFYAML.h:318
llvm::ELFYAML::VerneedSection::VerneedV
std::optional< std::vector< VerneedEntry > > VerneedV
Definition: ELFYAML.h:463
LLVM_YAML_STRONG_TYPEDEF
#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)
llvm::ELFYAML::SymverSection::SymverSection
SymverSection()
Definition: ELFYAML.h:545
llvm::ELFYAML::Object::Header
FileHeader Header
Definition: ELFYAML.h:697
llvm::ELFYAML::LinkerOptionsSection
Definition: ELFYAML.h:494
llvm::ELFYAML::FileHeader::EPhNum
std::optional< llvm::yaml::Hex16 > EPhNum
Definition: ELFYAML.h:126
llvm::ELFYAML::FileHeader::Entry
llvm::yaml::Hex64 Entry
Definition: ELFYAML.h:121
llvm::RegState::Implicit
@ Implicit
Not emitted register (e.g. carry, or temporary result).
Definition: MachineInstrBuilder.h:46
llvm::ELFYAML::Fill::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:290
llvm::ELFYAML::CallGraphProfileSection::CallGraphProfileSection
CallGraphProfileSection()
Definition: ELFYAML.h:531
llvm::ELFYAML::StackSizesSection
Definition: ELFYAML.h:332
llvm::ELFYAML::Symbol
Definition: ELFYAML.h:137
llvm::ELFYAML::GnuHashHeader
Definition: ELFYAML.h:411
llvm::ELFYAML::Chunk::Name
StringRef Name
Definition: ELFYAML.h:215
llvm::ELFYAML::Section::Type
ELF_SHT Type
Definition: ELFYAML.h:227
llvm::ELFYAML::VernauxEntry::Other
uint16_t Other
Definition: ELFYAML.h:452
llvm::ELFYAML::ARMIndexTableEntry::Offset
llvm::yaml::Hex32 Offset
Definition: ELFYAML.h:641
llvm::ELFYAML::MipsABIFlags::ISARevision
llvm::yaml::Hex8 ISARevision
Definition: ELFYAML.h:663
llvm::ELFYAML::VernauxEntry::Flags
uint16_t Flags
Definition: ELFYAML.h:451
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:1005
llvm::ELFYAML::Chunk::ChunkKind::SymtabShndxSection
@ SymtabShndxSection
llvm::ELFYAML::BBAddrMapEntry
Definition: ELFYAML.h:159
llvm::ELFYAML::MipsABIFlags
Definition: ELFYAML.h:660
ELFTypes.h
llvm::ELFYAML::Chunk::ChunkKind::Group
@ Group
NoBits
bool NoBits
Definition: ELFObjHandler.cpp:84
llvm::ELFYAML::ARMIndexTableSection
Definition: ELFYAML.h:645
llvm::ELFYAML::Section::Section
Section(ChunkKind Kind, bool IsImplicit=false)
Definition: ELFYAML.h:240
llvm::object::Elf_CGProfile_Impl
Definition: ELFTypes.h:46
llvm::ELFYAML::AddrsigSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:482
llvm::ELFYAML::VerdefEntry::VersionNdx
std::optional< uint16_t > VersionNdx
Definition: ELFYAML.h:557
llvm::ELFYAML::VerdefSection::VerdefSection
VerdefSection()
Definition: ELFYAML.h:566
llvm::ELFYAML::RelocationSection::RelocationSection
RelocationSection()
Definition: ELFYAML.h:601
llvm::irsymtab::storage::Word
support::ulittle32_t Word
Definition: IRSymtab.h:52
llvm::ELFYAML::StackSizesSection::Entries
std::optional< std::vector< StackSizeEntry > > Entries
Definition: ELFYAML.h:333
llvm::ELFYAML::DynamicSection
Definition: ELFYAML.h:350
llvm::ELFYAML::Chunk::ChunkKind::SpecialChunksStart
@ SpecialChunksStart
YAMLTraits.h
llvm::ELFYAML::Chunk::ChunkKind::Addrsig
@ Addrsig
llvm::ELFYAML::FileHeader::EShOff
std::optional< llvm::yaml::Hex64 > EShOff
Definition: ELFYAML.h:128
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:33
llvm::ELFYAML::NoteEntry::Desc
yaml::BinaryRef Desc
Definition: ELFYAML.h:180
llvm::ELFYAML::Object::ProgramHeaders
std::vector< ProgramHeader > ProgramHeaders
Definition: ELFYAML.h:698
llvm::ELFYAML::SectionHeaderTable::Excluded
std::optional< std::vector< SectionHeader > > Excluded
Definition: ELFYAML.h:302
llvm::ELFYAML::FileHeader::Class
ELF_ELFCLASS Class
Definition: ELFYAML.h:114
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:1003
llvm::ELFYAML::SymverSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:551
llvm::ELFYAML::AddrsigSection::Symbols
std::optional< std::vector< YAMLFlowString > > Symbols
Definition: ELFYAML.h:478
llvm::yaml::BinaryRef
Specialized YAMLIO scalar type for representing a binary blob.
Definition: YAML.h:63
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::ELFYAML::NoteEntry
Definition: ELFYAML.h:178
llvm::RoundingMode::Dynamic
@ Dynamic
Denotes mode unknown at compile time.
llvm::ELFYAML::SectionHeaderTable::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:297
uint32_t
llvm::ELFYAML::Chunk::ChunkKind::Dynamic
@ Dynamic
llvm::ELFYAML::ProgramHeader::PAddr
llvm::yaml::Hex64 PAddr
Definition: ELFYAML.h:684
llvm::ELFYAML::Object::Symbols
std::optional< std::vector< Symbol > > Symbols
Definition: ELFYAML.h:708
llvm::ELFYAML::GnuHashSection::BloomFilter
std::optional< std::vector< llvm::yaml::Hex64 > > BloomFilter
Definition: ELFYAML.h:433
llvm::ELFYAML::FileHeader::Data
ELF_ELFDATA Data
Definition: ELFYAML.h:115
llvm::ELFYAML::BBAddrMapEntry::Version
uint8_t Version
Definition: ELFYAML.h:166
llvm::ELFYAML::NoteEntry::Name
StringRef Name
Definition: ELFYAML.h:179
llvm::ELFYAML::MipsABIFlags::CPR1Size
MIPS_AFL_REG CPR1Size
Definition: ELFYAML.h:665
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::ELFYAML::ARMIndexTableSection::Entries
std::optional< std::vector< ARMIndexTableEntry > > Entries
Definition: ELFYAML.h:646
llvm::ELFYAML::DynamicSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:359
llvm::ELFYAML::VerneedSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:468
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:1009
llvm::ELFYAML::Section::OriginalSecNdx
unsigned OriginalSecNdx
Definition: ELFYAML.h:238
llvm::ELFYAML::Relocation::Type
ELF_REL Type
Definition: ELFYAML.h:593
llvm::ELFYAML::GroupSection::Signature
std::optional< StringRef > Signature
Definition: ELFYAML.h:579
llvm::ELFYAML::RelrSection::Entries
std::optional< std::vector< llvm::yaml::Hex64 > > Entries
Definition: ELFYAML.h:613
llvm::ELFYAML::FileHeader::EShStrNdx
std::optional< llvm::yaml::Hex16 > EShStrNdx
Definition: ELFYAML.h:130
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::ELFYAML::ARMIndexTableSection::ARMIndexTableSection
ARMIndexTableSection()
Definition: ELFYAML.h:648
llvm::ELFYAML::SectionHeaderTable
Definition: ELFYAML.h:293
llvm::ELFYAML::Symbol::Size
std::optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:144
llvm::ELFYAML::Chunk::ChunkKind::Fill
@ Fill
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::ELFYAML::MipsABIFlags::Flags1
MIPS_AFL_FLAGS1 Flags1
Definition: ELFYAML.h:670
llvm::ELFYAML::GnuHashSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:439
llvm::ELFYAML::MipsABIFlags::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:675
std
Definition: BitVector.h:851
llvm::ELFYAML::ARMIndexTableSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:650
llvm::ELFYAML::FileHeader::EPhOff
std::optional< llvm::yaml::Hex64 > EPhOff
Definition: ELFYAML.h:124
llvm::ELFYAML::ARMIndexTableEntry
Definition: ELFYAML.h:640
llvm::ELFYAML::LinkerOptionsSection::LinkerOptionsSection
LinkerOptionsSection()
Definition: ELFYAML.h:497
llvm::ELFYAML::VerneedSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:472
llvm::ELF::SHT_RELR
@ SHT_RELR
Definition: ELF.h:1013
llvm::None
constexpr std::nullopt_t None
Definition: None.h:28
uint16_t
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:141
llvm::ELFYAML::Chunk::ChunkKind::Hash
@ Hash
llvm::ELFYAML::DependentLibrariesSection::DependentLibrariesSection
DependentLibrariesSection()
Definition: ELFYAML.h:511
llvm::ELFYAML::VerneedEntry::Version
uint16_t Version
Definition: ELFYAML.h:457
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:996
llvm::ELFYAML::RelrSection
Definition: ELFYAML.h:612
llvm::ELFYAML::MipsABIFlags::ISAExtension
MIPS_AFL_EXT ISAExtension
Definition: ELFYAML.h:668
llvm::ELFYAML::DynamicEntry::Val
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:156
llvm::ELFYAML::LinkerOption::Value
StringRef Value
Definition: ELFYAML.h:491
llvm::ELFYAML::Chunk::ChunkKind::StackSizes
@ StackSizes
llvm::ELFYAML::ProgramHeader::Align
std::optional< llvm::yaml::Hex64 > Align
Definition: ELFYAML.h:685
llvm::ELFYAML::DependentLibrariesSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:517
llvm::ELFYAML::CallGraphEntryWeight
Definition: ELFYAML.h:523
llvm::ELFYAML::Chunk::ChunkKind::CallGraphProfile
@ CallGraphProfile
llvm::sampleprof::SecType
SecType
Definition: SampleProf.h:121
llvm::ELFYAML::Section::AddressAlign
llvm::yaml::Hex64 AddressAlign
Definition: ELFYAML.h:231
llvm::ELFYAML::VerneedEntry::AuxV
std::vector< VernauxEntry > AuxV
Definition: ELFYAML.h:459
llvm::ELFYAML::SymtabShndxSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:635
llvm::ELF::SHT_HASH
@ SHT_HASH
Definition: ELF.h:999
llvm::ELFYAML::RawContentSection::Info
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:363
llvm::ELFYAML::Section::Content
std::optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:234
llvm::ELFYAML::Section::ShName
std::optional< llvm::yaml::Hex64 > ShName
Definition: ELFYAML.h:261
llvm::ELFYAML::RelrSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:621
llvm::ELFYAML::Relocation::Addend
YAMLIntUInt Addend
Definition: ELFYAML.h:592
llvm::ELFYAML::GnuHashHeader::SymNdx
llvm::yaml::Hex32 SymNdx
Definition: ELFYAML.h:419
llvm::ELFYAML::BBAddrMapSection::Entries
std::optional< std::vector< BBAddrMapEntry > > Entries
Definition: ELFYAML.h:319
llvm::ELFYAML::GnuHashSection::HashValues
std::optional< std::vector< llvm::yaml::Hex32 > > HashValues
Definition: ELFYAML.h:435
llvm::ELFYAML::RelocationSection::Relocations
std::optional< std::vector< Relocation > > Relocations
Definition: ELFYAML.h:598
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::ELFYAML::Section::Size
std::optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:235
llvm::ELFYAML::VerdefEntry::Version
std::optional< uint16_t > Version
Definition: ELFYAML.h:555
llvm::ELFYAML::StackSizesSection::nameMatches
static bool nameMatches(StringRef Name)
Definition: ELFYAML.h:345
llvm::ELFYAML::Fill::Fill
Fill()
Definition: ELFYAML.h:288
llvm::ELFYAML::Chunk::ChunkKind::Verneed
@ Verneed
llvm::ELFYAML::BBAddrMapEntry::BBEntry::AddressOffset
llvm::yaml::Hex64 AddressOffset
Definition: ELFYAML.h:162
llvm::ELFYAML::Section
Definition: ELFYAML.h:226
llvm::ELFYAML::DynamicEntry
Definition: ELFYAML.h:154
llvm::ELF::SHT_GNU_versym
@ SHT_GNU_versym
Definition: ELF.h:1041
llvm::ELFYAML::Fill::Pattern
std::optional< yaml::BinaryRef > Pattern
Definition: ELFYAML.h:285
llvm::ELFYAML::VerdefSection
Definition: ELFYAML.h:562
llvm::ELFYAML::Object::getSectionHeaderTable
const SectionHeaderTable & getSectionHeaderTable() const
Definition: ELFYAML.h:720
N
#define N
llvm::ELFYAML::BBAddrMapEntry::BBEntry
Definition: ELFYAML.h:160
llvm::ELFYAML::MipsABIFlags::FpABI
MIPS_ABI_FP FpABI
Definition: ELFYAML.h:667
llvm::ELFYAML::MipsABIFlags::Version
llvm::yaml::Hex16 Version
Definition: ELFYAML.h:661
llvm::ELFYAML::Object::DynamicSymbols
std::optional< std::vector< Symbol > > DynamicSymbols
Definition: ELFYAML.h:709
llvm::ELFYAML::HashSection
Definition: ELFYAML.h:393
llvm::ELFYAML::Section::EntSize
std::optional< llvm::yaml::Hex64 > EntSize
Definition: ELFYAML.h:232
llvm::ELFYAML::StackSizeEntry::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:175
llvm::ELFYAML::HashSection::Chain
std::optional< std::vector< uint32_t > > Chain
Definition: ELFYAML.h:395
llvm::ELFYAML::DependentLibrariesSection::Libs
std::optional< std::vector< YAMLFlowString > > Libs
Definition: ELFYAML.h:509
llvm::ELFYAML::VerneedSection
Definition: ELFYAML.h:462
llvm::ELFYAML::DependentLibrariesSection
Definition: ELFYAML.h:508
llvm::ELFYAML::FileHeader::ABIVersion
llvm::yaml::Hex8 ABIVersion
Definition: ELFYAML.h:117
llvm::ELFYAML::BBAddrMapEntry::BBEntry::Metadata
llvm::yaml::Hex64 Metadata
Definition: ELFYAML.h:164
llvm::ELFYAML::Section::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:242
llvm::ELFYAML::SectionHeaderTable::SectionHeaderTable
SectionHeaderTable(bool IsImplicit)
Definition: ELFYAML.h:294
llvm::ELFYAML::MipsABIFlags::ISALevel
MIPS_ISA ISALevel
Definition: ELFYAML.h:662
llvm::ELFYAML::Chunk::ChunkKind::LinkerOptions
@ LinkerOptions
llvm::ELFYAML::BBAddrMapEntry::NumBlocks
std::optional< uint64_t > NumBlocks
Definition: ELFYAML.h:169
llvm::ELFYAML::Symbol::Section
std::optional< StringRef > Section
Definition: ELFYAML.h:140
llvm::ELFYAML::StackSizesSection::StackSizesSection
StackSizesSection()
Definition: ELFYAML.h:335
llvm::ELFYAML::BBAddrMapSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:327
llvm::ELFYAML::StackSizesSection::getEntries
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:337
llvm::ELFYAML::NoteSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:390
llvm::ELFYAML::MipsABIFlags::GPRSize
MIPS_AFL_REG GPRSize
Definition: ELFYAML.h:664
llvm::ELFYAML::Object::Chunks
std::vector< std::unique_ptr< Chunk > > Chunks
Definition: ELFYAML.h:702
llvm::ELFYAML::ProgramHeader::VAddr
llvm::yaml::Hex64 VAddr
Definition: ELFYAML.h:683
llvm::ELFYAML::FileHeader::OSABI
ELF_ELFOSABI OSABI
Definition: ELFYAML.h:116
llvm::ELFYAML::ProgramHeader::FirstSec
std::optional< StringRef > FirstSec
Definition: ELFYAML.h:689
llvm::ELFYAML::NoBitsSection::NoBitsSection
NoBitsSection()
Definition: ELFYAML.h:376
llvm::ELFYAML::GroupSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:587
llvm::ELFYAML::GroupSection::Members
std::optional< std::vector< SectionOrType > > Members
Definition: ELFYAML.h:578
llvm::ELFYAML::StackSizeEntry
Definition: ELFYAML.h:173
llvm::ELFYAML::HashSection::classof
static bool classof(const Chunk *S)
Definition: ELFYAML.h:408
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::ELFYAML::SectionHeaderTable::Sections
std::optional< std::vector< SectionHeader > > Sections
Definition: ELFYAML.h:301
llvm::ELFYAML::ProgramHeader::LastSec
std::optional< StringRef > LastSec
Definition: ELFYAML.h:690
llvm::ELFYAML::VernauxEntry
Definition: ELFYAML.h:449
llvm::ELFYAML::HashSection::NChain
std::optional< llvm::yaml::Hex64 > NChain
Definition: ELFYAML.h:404
llvm::ELFYAML::Section::getEntries
virtual std::vector< std::pair< StringRef, bool > > getEntries() const
Definition: ELFYAML.h:249
llvm::ELFYAML::CallGraphEntryWeight::Weight
uint64_t Weight
Definition: ELFYAML.h:525
llvm::ELFYAML::Section::ShOffset
std::optional< llvm::yaml::Hex64 > ShOffset
Definition: ELFYAML.h:265
llvm::ELFYAML::Symbol::Binding
ELF_STB Binding
Definition: ELFYAML.h:142
llvm::ELFYAML::Chunk::ChunkKind::Relr
@ Relr
llvm::ELFYAML::Chunk::ChunkKind::Note
@ Note
llvm::ELFYAML::ProgramHeader::Flags
ELF_PF Flags
Definition: ELFYAML.h:682
llvm::ELFYAML::Chunk
Definition: ELFYAML.h:184
llvm::ELFYAML::RelrSection::RelrSection
RelrSection()
Definition: ELFYAML.h:615
llvm::ELFYAML::HashSection::NBucket
std::optional< llvm::yaml::Hex64 > NBucket
Definition: ELFYAML.h:399
llvm::ELFYAML::Chunk::IsImplicit
bool IsImplicit
Definition: ELFYAML.h:220
llvm::ELFYAML::FileHeader::SectionHeaderStringTable
std::optional< StringRef > SectionHeaderStringTable
Definition: ELFYAML.h:122