LLVM 19.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"
24#include <cstdint>
25#include <memory>
26#include <optional>
27#include <vector>
28
29namespace llvm {
30namespace ELFYAML {
31
33std::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.
48LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
49LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
50LLVM_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.
58LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)
59// Just use 64, since it can hold 32-bit values too.
62LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
63LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
65
66LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
67LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
70LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
72
74LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)
75
76template <class ELFT>
77unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
78 StringRef SecName) {
79 if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
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);
95 return sizeof(typename ELFT::Dyn);
96 case ELF::SHT_HASH:
97 return sizeof(typename ELFT::Word);
99 return sizeof(typename ELFT::Word);
101 return sizeof(typename ELFT::Half);
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.
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
137struct 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
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
170 llvm::yaml::Hex64 BaseAddress;
171 std::optional<uint64_t> NumBlocks;
172 std::optional<std::vector<BBEntry>> BBEntries;
173 };
174
175 std::optional<uint64_t> NumBBRanges;
176 std::optional<std::vector<BBRangeEntry>> BBRanges;
177
178 llvm::yaml::Hex64 getFunctionAddress() const {
179 if (!BBRanges || BBRanges->empty())
180 return 0;
181 return BBRanges->front().BaseAddress;
182 }
183};
184
186 struct PGOBBEntry {
189 llvm::yaml::Hex32 BrProb;
190 };
191 std::optional<uint64_t> BBFreq;
192 std::optional<std::vector<SuccessorEntry>> Successors;
193 };
194 std::optional<uint64_t> FuncEntryCount;
195 std::optional<std::vector<PGOBBEntry>> PGOBBEntries;
196};
197
199 llvm::yaml::Hex64 Address;
200 llvm::yaml::Hex64 Size;
201};
202
203struct NoteEntry {
206 ELF_NT Type;
207};
208
209struct Chunk {
210 enum class ChunkKind {
211 Dynamic,
212 Group,
215 Relr,
216 NoBits,
217 Note,
218 Hash,
219 GnuHash,
220 Verdef,
221 Verneed,
224 Symver,
227 Addrsig,
231 BBAddrMap,
232
233 // Special chunks.
237 };
238
241 std::optional<llvm::yaml::Hex64> Offset;
242
243 // Usually chunks are not created implicitly, but rather loaded from YAML.
244 // This flag is used to signal whether this is the case or not.
246
247 Chunk(ChunkKind K, bool Implicit) : Kind(K), IsImplicit(Implicit) {}
248 virtual ~Chunk();
249};
250
251struct Section : public Chunk {
252 ELF_SHT Type;
253 std::optional<ELF_SHF> Flags;
254 std::optional<llvm::yaml::Hex64> Address;
255 std::optional<StringRef> Link;
256 llvm::yaml::Hex64 AddressAlign;
257 std::optional<llvm::yaml::Hex64> EntSize;
258
259 std::optional<yaml::BinaryRef> Content;
260 std::optional<llvm::yaml::Hex64> Size;
261
262 // Holds the original section index.
264
266
267 static bool classof(const Chunk *S) {
269 }
270
271 // Some derived sections might have their own special entries. This method
272 // returns a vector of <entry name, is used> pairs. It is used for section
273 // validation.
274 virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
275 return {};
276 };
277
278 // The following members are used to override section fields which is
279 // useful for creating invalid objects.
280
281 // This can be used to override the sh_addralign field.
282 std::optional<llvm::yaml::Hex64> ShAddrAlign;
283
284 // This can be used to override the offset stored in the sh_name field.
285 // It does not affect the name stored in the string table.
286 std::optional<llvm::yaml::Hex64> ShName;
287
288 // This can be used to override the sh_offset field. It does not place the
289 // section data at the offset specified.
290 std::optional<llvm::yaml::Hex64> ShOffset;
291
292 // This can be used to override the sh_size field. It does not affect the
293 // content written.
294 std::optional<llvm::yaml::Hex64> ShSize;
295
296 // This can be used to override the sh_flags field.
297 std::optional<llvm::yaml::Hex64> ShFlags;
298
299 // This can be used to override the sh_type field. It is useful when we
300 // want to use specific YAML keys for a section of a particular type to
301 // describe the content, but still want to have a different final type
302 // for the section.
303 std::optional<ELF_SHT> ShType;
304};
305
306// Fill is a block of data which is placed outside of sections. It is
307// not present in the sections header table, but it might affect the output file
308// size and program headers produced.
309struct Fill : Chunk {
310 std::optional<yaml::BinaryRef> Pattern;
311 llvm::yaml::Hex64 Size;
312
313 Fill() : Chunk(ChunkKind::Fill, /*Implicit=*/false) {}
314
315 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
316};
317
321
322 static bool classof(const Chunk *S) {
324 }
325
326 std::optional<std::vector<SectionHeader>> Sections;
327 std::optional<std::vector<SectionHeader>> Excluded;
328 std::optional<bool> NoHeaders;
329
330 size_t getNumHeaders(size_t SectionsNum) const {
331 if (IsImplicit || isDefault())
332 return SectionsNum;
333 if (NoHeaders)
334 return (*NoHeaders) ? 0 : SectionsNum;
335 return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
336 }
337
338 bool isDefault() const { return !Sections && !Excluded && !NoHeaders; }
339
340 static constexpr StringRef TypeStr = "SectionHeaderTable";
341};
342
344 std::optional<std::vector<BBAddrMapEntry>> Entries;
345 std::optional<std::vector<PGOAnalysisMapEntry>> PGOAnalyses;
346
348
349 std::vector<std::pair<StringRef, bool>> getEntries() const override {
350 return {{"Entries", Entries.has_value()}};
351 };
352
353 static bool classof(const Chunk *S) {
354 return S->Kind == ChunkKind::BBAddrMap;
355 }
356};
357
359 std::optional<std::vector<StackSizeEntry>> Entries;
360
362
363 std::vector<std::pair<StringRef, bool>> getEntries() const override {
364 return {{"Entries", Entries.has_value()}};
365 };
366
367 static bool classof(const Chunk *S) {
368 return S->Kind == ChunkKind::StackSizes;
369 }
370
372 return Name == ".stack_sizes";
373 }
374};
375
377 std::optional<std::vector<DynamicEntry>> Entries;
378
380
381 std::vector<std::pair<StringRef, bool>> getEntries() const override {
382 return {{"Entries", Entries.has_value()}};
383 };
384
385 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
386};
387
389 std::optional<llvm::yaml::Hex64> Info;
390
392
393 static bool classof(const Chunk *S) {
394 return S->Kind == ChunkKind::RawContent;
395 }
396
397 // Is used when a content is read as an array of bytes.
398 std::optional<std::vector<uint8_t>> ContentBuf;
399};
400
403
404 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
405};
406
408 std::optional<std::vector<ELFYAML::NoteEntry>> Notes;
409
411
412 std::vector<std::pair<StringRef, bool>> getEntries() const override {
413 return {{"Notes", Notes.has_value()}};
414 };
415
416 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
417};
418
420 std::optional<std::vector<uint32_t>> Bucket;
421 std::optional<std::vector<uint32_t>> Chain;
422
423 std::vector<std::pair<StringRef, bool>> getEntries() const override {
424 return {{"Bucket", Bucket.has_value()}, {"Chain", Chain.has_value()}};
425 };
426
427 // The following members are used to override section fields.
428 // This is useful for creating invalid objects.
429 std::optional<llvm::yaml::Hex64> NBucket;
430 std::optional<llvm::yaml::Hex64> NChain;
431
433
434 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
435};
436
438 // The number of hash buckets.
439 // Not used when dumping the object, but can be used to override
440 // the real number of buckets when emiting an object from a YAML document.
441 std::optional<llvm::yaml::Hex32> NBuckets;
442
443 // Index of the first symbol in the dynamic symbol table
444 // included in the hash table.
445 llvm::yaml::Hex32 SymNdx;
446
447 // The number of words in the Bloom filter.
448 // Not used when dumping the object, but can be used to override the real
449 // number of words in the Bloom filter when emiting an object from a YAML
450 // document.
451 std::optional<llvm::yaml::Hex32> MaskWords;
452
453 // A shift constant used by the Bloom filter.
454 llvm::yaml::Hex32 Shift2;
455};
456
458 std::optional<GnuHashHeader> Header;
459 std::optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
460 std::optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
461 std::optional<std::vector<llvm::yaml::Hex32>> HashValues;
462
464
465 std::vector<std::pair<StringRef, bool>> getEntries() const override {
466 return {{"Header", Header.has_value()},
467 {"BloomFilter", BloomFilter.has_value()},
468 {"HashBuckets", HashBuckets.has_value()},
469 {"HashValues", HashValues.has_value()}};
470 };
471
472 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
473};
474
480};
481
485 std::vector<VernauxEntry> AuxV;
486};
487
489 std::optional<std::vector<VerneedEntry>> VerneedV;
490 std::optional<llvm::yaml::Hex64> Info;
491
493
494 std::vector<std::pair<StringRef, bool>> getEntries() const override {
495 return {{"Dependencies", VerneedV.has_value()}};
496 };
497
498 static bool classof(const Chunk *S) {
499 return S->Kind == ChunkKind::Verneed;
500 }
501};
502
504 std::optional<std::vector<YAMLFlowString>> Symbols;
505
507
508 std::vector<std::pair<StringRef, bool>> getEntries() const override {
509 return {{"Symbols", Symbols.has_value()}};
510 };
511
512 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
513};
514
518};
519
521 std::optional<std::vector<LinkerOption>> Options;
522
524
525 std::vector<std::pair<StringRef, bool>> getEntries() const override {
526 return {{"Options", Options.has_value()}};
527 };
528
529 static bool classof(const Chunk *S) {
530 return S->Kind == ChunkKind::LinkerOptions;
531 }
532};
533
535 std::optional<std::vector<YAMLFlowString>> Libs;
536
538
539 std::vector<std::pair<StringRef, bool>> getEntries() const override {
540 return {{"Libraries", Libs.has_value()}};
541 };
542
543 static bool classof(const Chunk *S) {
545 }
546};
547
548// Represents the call graph profile section entry.
550 // The weight of the edge.
552};
553
555 std::optional<std::vector<CallGraphEntryWeight>> Entries;
556
558
559 std::vector<std::pair<StringRef, bool>> getEntries() const override {
560 return {{"Entries", Entries.has_value()}};
561 };
562
563 static bool classof(const Chunk *S) {
565 }
566};
567
569 std::optional<std::vector<uint16_t>> Entries;
570
572
573 std::vector<std::pair<StringRef, bool>> getEntries() const override {
574 return {{"Entries", Entries.has_value()}};
575 };
576
577 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
578};
579
581 std::optional<uint16_t> Version;
582 std::optional<uint16_t> Flags;
583 std::optional<uint16_t> VersionNdx;
584 std::optional<uint32_t> Hash;
585 std::vector<StringRef> VerNames;
586};
587
589 std::optional<std::vector<VerdefEntry>> Entries;
590 std::optional<llvm::yaml::Hex64> Info;
591
593
594 std::vector<std::pair<StringRef, bool>> getEntries() const override {
595 return {{"Entries", Entries.has_value()}};
596 };
597
598 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
599};
600
602 // Members of a group contain a flag and a list of section indices
603 // that are part of the group.
604 std::optional<std::vector<SectionOrType>> Members;
605 std::optional<StringRef> Signature; /* Info */
606
608
609 std::vector<std::pair<StringRef, bool>> getEntries() const override {
610 return {{"Members", Members.has_value()}};
611 };
612
613 static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
614};
615
617 llvm::yaml::Hex64 Offset;
618 YAMLIntUInt Addend;
619 ELF_REL Type;
620 std::optional<StringRef> Symbol;
621};
622
624 std::optional<std::vector<Relocation>> Relocations;
626
628
629 std::vector<std::pair<StringRef, bool>> getEntries() const override {
630 return {{"Relocations", Relocations.has_value()}};
631 };
632
633 static bool classof(const Chunk *S) {
634 return S->Kind == ChunkKind::Relocation;
635 }
636};
637
639 std::optional<std::vector<llvm::yaml::Hex64>> Entries;
640
642
643 std::vector<std::pair<StringRef, bool>> getEntries() const override {
644 return {{"Entries", Entries.has_value()}};
645 };
646
647 static bool classof(const Chunk *S) {
648 return S->Kind == ChunkKind::Relr;
649 }
650};
651
653 std::optional<std::vector<uint32_t>> Entries;
654
656
657 std::vector<std::pair<StringRef, bool>> getEntries() const override {
658 return {{"Entries", Entries.has_value()}};
659 };
660
661 static bool classof(const Chunk *S) {
663 }
664};
665
667 llvm::yaml::Hex32 Offset;
668 llvm::yaml::Hex32 Value;
669};
670
672 std::optional<std::vector<ARMIndexTableEntry>> Entries;
673
675
676 std::vector<std::pair<StringRef, bool>> getEntries() const override {
677 return {{"Entries", Entries.has_value()}};
678 };
679
680 static bool classof(const Chunk *S) {
681 return S->Kind == ChunkKind::ARMIndexTable;
682 }
683};
684
685// Represents .MIPS.abiflags section
687 llvm::yaml::Hex16 Version;
688 MIPS_ISA ISALevel;
689 llvm::yaml::Hex8 ISARevision;
690 MIPS_AFL_REG GPRSize;
691 MIPS_AFL_REG CPR1Size;
692 MIPS_AFL_REG CPR2Size;
693 MIPS_ABI_FP FpABI;
694 MIPS_AFL_EXT ISAExtension;
695 MIPS_AFL_ASE ASEs;
696 MIPS_AFL_FLAGS1 Flags1;
697 llvm::yaml::Hex32 Flags2;
698
700
701 static bool classof(const Chunk *S) {
702 return S->Kind == ChunkKind::MipsABIFlags;
703 }
704};
705
707 ELF_PT Type;
708 ELF_PF Flags;
709 llvm::yaml::Hex64 VAddr;
710 llvm::yaml::Hex64 PAddr;
711 std::optional<llvm::yaml::Hex64> Align;
712 std::optional<llvm::yaml::Hex64> FileSize;
713 std::optional<llvm::yaml::Hex64> MemSize;
714 std::optional<llvm::yaml::Hex64> Offset;
715 std::optional<StringRef> FirstSec;
716 std::optional<StringRef> LastSec;
717
718 // This vector contains all chunks from [FirstSec, LastSec].
719 std::vector<Chunk *> Chunks;
720};
721
722struct Object {
724 std::vector<ProgramHeader> ProgramHeaders;
725
726 // An object might contain output section descriptions as well as
727 // custom data that does not belong to any section.
728 std::vector<std::unique_ptr<Chunk>> Chunks;
729
730 // Although in reality the symbols reside in a section, it is a lot
731 // cleaner and nicer if we read them from the YAML as a separate
732 // top-level key, which automatically ensures that invariants like there
733 // being a single SHT_SYMTAB section are upheld.
734 std::optional<std::vector<Symbol>> Symbols;
735 std::optional<std::vector<Symbol>> DynamicSymbols;
736 std::optional<DWARFYAML::Data> DWARF;
737
738 std::vector<Section *> getSections() {
739 std::vector<Section *> Ret;
740 for (const std::unique_ptr<Chunk> &Sec : Chunks)
741 if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
742 Ret.push_back(S);
743 return Ret;
744 }
745
747 for (const std::unique_ptr<Chunk> &C : Chunks)
748 if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
749 return *S;
750 llvm_unreachable("the section header table chunk must always be present");
751 }
752
753 ELF_ELFOSABI getOSAbi() const;
754 unsigned getMachine() const;
755};
756
758 const NoBitsSection &S);
759
760} // end namespace ELFYAML
761} // end namespace llvm
762
770 llvm::ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry)
771LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
772LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
773LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntryWeight)
774LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
775LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
776LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
777LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
778LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
779LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
780LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
781LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
782LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
783LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
784LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)
785
786namespace llvm {
787namespace yaml {
788
789template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
790 static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
791 raw_ostream &Out);
792 static StringRef input(StringRef Scalar, void *Ctx,
793 ELFYAML::YAMLIntUInt &Val);
794 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
795};
796
797template <>
798struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
799 static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
800};
801
802template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
803 static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
804};
805
806template <> struct ScalarEnumerationTraits<ELFYAML::ELF_NT> {
807 static void enumeration(IO &IO, ELFYAML::ELF_NT &Value);
808};
809
810template <>
811struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
812 static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
813};
814
815template <>
816struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
817 static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
818};
819
820template <>
821struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
822 static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
823};
824
825template <>
826struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
827 static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
828};
829
830template <>
831struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
832 static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
833};
834
835template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
836 static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
837};
838
839template <>
840struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
841 static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
842};
843
844template <>
845struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
846 static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
847};
848
849template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
850 static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
851};
852
853template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
854 static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
855};
856
857template <>
858struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
859 static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
860};
861
862template <>
863struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
864 static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
865};
866
867template <>
868struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
869 static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
870};
871
872template <>
873struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
874 static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
875};
876
877template <>
878struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
879 static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
880};
881
882template <>
883struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
884 static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
885};
886
887template <>
888struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
889 static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
890};
891
892template <>
893struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
894 static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
895};
896
897template <>
898struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
899 static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
900};
901
902template <>
903struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
904 static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
905};
906
907template <>
908struct MappingTraits<ELFYAML::FileHeader> {
909 static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
910};
911
912template <> struct MappingTraits<ELFYAML::SectionHeader> {
913 static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
914};
915
916template <> struct MappingTraits<ELFYAML::ProgramHeader> {
917 static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
918 static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
919};
920
921template <>
922struct MappingTraits<ELFYAML::Symbol> {
923 static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
924 static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
925};
926
927template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
928 static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
929};
930
931template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
932 static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &E);
933};
934
935template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBRangeEntry> {
936 static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBRangeEntry &E);
937};
938
939template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
940 static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E);
941};
942
943template <> struct MappingTraits<ELFYAML::PGOAnalysisMapEntry> {
944 static void mapping(IO &IO, ELFYAML::PGOAnalysisMapEntry &Rel);
945};
946
947template <> struct MappingTraits<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry> {
948 static void mapping(IO &IO, ELFYAML::PGOAnalysisMapEntry::PGOBBEntry &Rel);
949};
950
951template <>
952struct MappingTraits<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry> {
953 static void
954 mapping(IO &IO,
955 ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry &Rel);
956};
957
958template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
959 static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
960};
961
962template <> struct MappingTraits<ELFYAML::DynamicEntry> {
963 static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
964};
965
966template <> struct MappingTraits<ELFYAML::NoteEntry> {
967 static void mapping(IO &IO, ELFYAML::NoteEntry &N);
968};
969
970template <> struct MappingTraits<ELFYAML::VerdefEntry> {
971 static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
972};
973
974template <> struct MappingTraits<ELFYAML::VerneedEntry> {
975 static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
976};
977
978template <> struct MappingTraits<ELFYAML::VernauxEntry> {
979 static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
980};
981
982template <> struct MappingTraits<ELFYAML::LinkerOption> {
983 static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
984};
985
986template <> struct MappingTraits<ELFYAML::CallGraphEntryWeight> {
987 static void mapping(IO &IO, ELFYAML::CallGraphEntryWeight &E);
988};
989
990template <> struct MappingTraits<ELFYAML::Relocation> {
991 static void mapping(IO &IO, ELFYAML::Relocation &Rel);
992};
993
994template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
995 static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
996};
997
998template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
999 static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
1000 static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
1001};
1002
1003template <>
1004struct MappingTraits<ELFYAML::Object> {
1005 static void mapping(IO &IO, ELFYAML::Object &Object);
1006};
1007
1008template <> struct MappingTraits<ELFYAML::SectionOrType> {
1009 static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
1010};
1011
1012} // end namespace yaml
1013} // end namespace llvm
1014
1015#endif // LLVM_OBJECTYAML_ELFYAML_H
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file declares classes for handling the YAML representation of DWARF Debug Info.
std::string Name
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Specialized YAMLIO scalar type for representing a binary blob.
Definition: YAML.h:63
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
std::string appendUniqueSuffix(StringRef Name, const Twine &Msg)
Definition: ELFEmitter.cpp:689
unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType, StringRef SecName)
Definition: ELFYAML.h:77
StringRef dropUniqueSuffix(StringRef S)
Definition: ELFEmitter.cpp:696
bool shouldAllocateFileSpace(ArrayRef< ProgramHeader > Phdrs, const NoBitsSection &S)
@ EM_MIPS
Definition: ELF.h:141
@ SHT_GROUP
Definition: ELF.h:1079
@ SHT_REL
Definition: ELF.h:1073
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:1101
@ SHT_SYMTAB
Definition: ELF.h:1066
@ SHT_RELR
Definition: ELF.h:1083
@ SHT_DYNAMIC
Definition: ELF.h:1070
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:1080
@ SHT_RELA
Definition: ELF.h:1068
@ SHT_DYNSYM
Definition: ELF.h:1075
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:1138
@ SHT_GNU_versym
Definition: ELF.h:1112
@ SHT_HASH
Definition: ELF.h:1069
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
llvm::yaml::Hex32 Offset
Definition: ELFYAML.h:667
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:676
static bool classof(const Chunk *S)
Definition: ELFYAML.h:680
std::optional< std::vector< ARMIndexTableEntry > > Entries
Definition: ELFYAML.h:672
std::optional< std::vector< YAMLFlowString > > Symbols
Definition: ELFYAML.h:504
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:508
static bool classof(const Chunk *S)
Definition: ELFYAML.h:512
std::optional< uint64_t > NumBlocks
Definition: ELFYAML.h:171
std::optional< std::vector< BBEntry > > BBEntries
Definition: ELFYAML.h:172
llvm::yaml::Hex64 getFunctionAddress() const
Definition: ELFYAML.h:178
std::optional< uint64_t > NumBBRanges
Definition: ELFYAML.h:175
std::optional< std::vector< BBRangeEntry > > BBRanges
Definition: ELFYAML.h:176
llvm::yaml::Hex8 Feature
Definition: ELFYAML.h:167
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:349
static bool classof(const Chunk *S)
Definition: ELFYAML.h:353
std::optional< std::vector< BBAddrMapEntry > > Entries
Definition: ELFYAML.h:344
std::optional< std::vector< PGOAnalysisMapEntry > > PGOAnalyses
Definition: ELFYAML.h:345
std::optional< std::vector< CallGraphEntryWeight > > Entries
Definition: ELFYAML.h:555
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:559
static bool classof(const Chunk *S)
Definition: ELFYAML.h:563
Chunk(ChunkKind K, bool Implicit)
Definition: ELFYAML.h:247
StringRef Name
Definition: ELFYAML.h:240
std::optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:241
ChunkKind Kind
Definition: ELFYAML.h:239
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:539
static bool classof(const Chunk *S)
Definition: ELFYAML.h:543
std::optional< std::vector< YAMLFlowString > > Libs
Definition: ELFYAML.h:535
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:156
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:381
static bool classof(const Chunk *S)
Definition: ELFYAML.h:385
std::optional< std::vector< DynamicEntry > > Entries
Definition: ELFYAML.h:377
std::optional< llvm::yaml::Hex16 > EPhNum
Definition: ELFYAML.h:126
std::optional< llvm::yaml::Hex64 > EShOff
Definition: ELFYAML.h:128
std::optional< llvm::yaml::Hex64 > EPhOff
Definition: ELFYAML.h:124
ELF_ELFCLASS Class
Definition: ELFYAML.h:114
std::optional< llvm::yaml::Hex16 > EShEntSize
Definition: ELFYAML.h:127
std::optional< llvm::yaml::Hex16 > EPhEntSize
Definition: ELFYAML.h:125
llvm::yaml::Hex8 ABIVersion
Definition: ELFYAML.h:117
std::optional< llvm::yaml::Hex16 > EShNum
Definition: ELFYAML.h:129
llvm::yaml::Hex64 Entry
Definition: ELFYAML.h:121
ELF_ELFOSABI OSABI
Definition: ELFYAML.h:116
std::optional< ELF_EM > Machine
Definition: ELFYAML.h:119
std::optional< StringRef > SectionHeaderStringTable
Definition: ELFYAML.h:122
std::optional< llvm::yaml::Hex16 > EShStrNdx
Definition: ELFYAML.h:130
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:311
std::optional< yaml::BinaryRef > Pattern
Definition: ELFYAML.h:310
static bool classof(const Chunk *S)
Definition: ELFYAML.h:315
std::optional< llvm::yaml::Hex32 > MaskWords
Definition: ELFYAML.h:451
llvm::yaml::Hex32 SymNdx
Definition: ELFYAML.h:445
llvm::yaml::Hex32 Shift2
Definition: ELFYAML.h:454
std::optional< llvm::yaml::Hex32 > NBuckets
Definition: ELFYAML.h:441
std::optional< std::vector< llvm::yaml::Hex64 > > BloomFilter
Definition: ELFYAML.h:459
std::optional< std::vector< llvm::yaml::Hex32 > > HashBuckets
Definition: ELFYAML.h:460
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:465
static bool classof(const Chunk *S)
Definition: ELFYAML.h:472
std::optional< GnuHashHeader > Header
Definition: ELFYAML.h:458
std::optional< std::vector< llvm::yaml::Hex32 > > HashValues
Definition: ELFYAML.h:461
static bool classof(const Chunk *S)
Definition: ELFYAML.h:613
std::optional< std::vector< SectionOrType > > Members
Definition: ELFYAML.h:604
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:609
std::optional< StringRef > Signature
Definition: ELFYAML.h:605
std::optional< std::vector< uint32_t > > Chain
Definition: ELFYAML.h:421
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:423
std::optional< llvm::yaml::Hex64 > NChain
Definition: ELFYAML.h:430
static bool classof(const Chunk *S)
Definition: ELFYAML.h:434
std::optional< std::vector< uint32_t > > Bucket
Definition: ELFYAML.h:420
std::optional< llvm::yaml::Hex64 > NBucket
Definition: ELFYAML.h:429
std::optional< std::vector< LinkerOption > > Options
Definition: ELFYAML.h:521
static bool classof(const Chunk *S)
Definition: ELFYAML.h:529
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:525
llvm::yaml::Hex16 Version
Definition: ELFYAML.h:687
static bool classof(const Chunk *S)
Definition: ELFYAML.h:701
MIPS_AFL_FLAGS1 Flags1
Definition: ELFYAML.h:696
llvm::yaml::Hex8 ISARevision
Definition: ELFYAML.h:689
MIPS_AFL_EXT ISAExtension
Definition: ELFYAML.h:694
llvm::yaml::Hex32 Flags2
Definition: ELFYAML.h:697
static bool classof(const Chunk *S)
Definition: ELFYAML.h:404
yaml::BinaryRef Desc
Definition: ELFYAML.h:205
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:412
std::optional< std::vector< ELFYAML::NoteEntry > > Notes
Definition: ELFYAML.h:408
static bool classof(const Chunk *S)
Definition: ELFYAML.h:416
std::optional< std::vector< Symbol > > DynamicSymbols
Definition: ELFYAML.h:735
unsigned getMachine() const
Definition: ELFYAML.cpp:35
std::optional< DWARFYAML::Data > DWARF
Definition: ELFYAML.h:736
const SectionHeaderTable & getSectionHeaderTable() const
Definition: ELFYAML.h:746
FileHeader Header
Definition: ELFYAML.h:723
std::vector< std::unique_ptr< Chunk > > Chunks
Definition: ELFYAML.h:728
ELF_ELFOSABI getOSAbi() const
Definition: ELFYAML.cpp:33
std::vector< ProgramHeader > ProgramHeaders
Definition: ELFYAML.h:724
std::optional< std::vector< Symbol > > Symbols
Definition: ELFYAML.h:734
std::vector< Section * > getSections()
Definition: ELFYAML.h:738
std::optional< std::vector< SuccessorEntry > > Successors
Definition: ELFYAML.h:192
std::optional< std::vector< PGOBBEntry > > PGOBBEntries
Definition: ELFYAML.h:195
std::optional< uint64_t > FuncEntryCount
Definition: ELFYAML.h:194
std::optional< llvm::yaml::Hex64 > Align
Definition: ELFYAML.h:711
llvm::yaml::Hex64 PAddr
Definition: ELFYAML.h:710
std::optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:714
llvm::yaml::Hex64 VAddr
Definition: ELFYAML.h:709
std::optional< llvm::yaml::Hex64 > MemSize
Definition: ELFYAML.h:713
std::optional< StringRef > FirstSec
Definition: ELFYAML.h:715
std::optional< StringRef > LastSec
Definition: ELFYAML.h:716
std::optional< llvm::yaml::Hex64 > FileSize
Definition: ELFYAML.h:712
std::vector< Chunk * > Chunks
Definition: ELFYAML.h:719
static bool classof(const Chunk *S)
Definition: ELFYAML.h:393
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:389
std::optional< std::vector< uint8_t > > ContentBuf
Definition: ELFYAML.h:398
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:629
std::optional< std::vector< Relocation > > Relocations
Definition: ELFYAML.h:624
static bool classof(const Chunk *S)
Definition: ELFYAML.h:633
std::optional< StringRef > Symbol
Definition: ELFYAML.h:620
llvm::yaml::Hex64 Offset
Definition: ELFYAML.h:617
static bool classof(const Chunk *S)
Definition: ELFYAML.h:647
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:643
std::optional< std::vector< llvm::yaml::Hex64 > > Entries
Definition: ELFYAML.h:639
std::optional< std::vector< SectionHeader > > Excluded
Definition: ELFYAML.h:327
static constexpr StringRef TypeStr
Definition: ELFYAML.h:340
std::optional< bool > NoHeaders
Definition: ELFYAML.h:328
static bool classof(const Chunk *S)
Definition: ELFYAML.h:322
SectionHeaderTable(bool IsImplicit)
Definition: ELFYAML.h:319
size_t getNumHeaders(size_t SectionsNum) const
Definition: ELFYAML.h:330
std::optional< std::vector< SectionHeader > > Sections
Definition: ELFYAML.h:326
std::optional< llvm::yaml::Hex64 > Address
Definition: ELFYAML.h:254
std::optional< StringRef > Link
Definition: ELFYAML.h:255
Section(ChunkKind Kind, bool IsImplicit=false)
Definition: ELFYAML.h:265
std::optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:260
static bool classof(const Chunk *S)
Definition: ELFYAML.h:267
std::optional< llvm::yaml::Hex64 > ShAddrAlign
Definition: ELFYAML.h:282
llvm::yaml::Hex64 AddressAlign
Definition: ELFYAML.h:256
unsigned OriginalSecNdx
Definition: ELFYAML.h:263
std::optional< ELF_SHF > Flags
Definition: ELFYAML.h:253
std::optional< ELF_SHT > ShType
Definition: ELFYAML.h:303
std::optional< llvm::yaml::Hex64 > ShOffset
Definition: ELFYAML.h:290
virtual std::vector< std::pair< StringRef, bool > > getEntries() const
Definition: ELFYAML.h:274
std::optional< llvm::yaml::Hex64 > ShFlags
Definition: ELFYAML.h:297
std::optional< llvm::yaml::Hex64 > ShName
Definition: ELFYAML.h:286
std::optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:259
std::optional< llvm::yaml::Hex64 > EntSize
Definition: ELFYAML.h:257
std::optional< llvm::yaml::Hex64 > ShSize
Definition: ELFYAML.h:294
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:200
llvm::yaml::Hex64 Address
Definition: ELFYAML.h:199
static bool classof(const Chunk *S)
Definition: ELFYAML.h:367
static bool nameMatches(StringRef Name)
Definition: ELFYAML.h:371
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:363
std::optional< std::vector< StackSizeEntry > > Entries
Definition: ELFYAML.h:359
std::optional< ELF_SHN > Index
Definition: ELFYAML.h:141
std::optional< StringRef > Section
Definition: ELFYAML.h:140
std::optional< uint8_t > Other
Definition: ELFYAML.h:145
std::optional< uint32_t > StName
Definition: ELFYAML.h:147
std::optional< llvm::yaml::Hex64 > Value
Definition: ELFYAML.h:143
std::optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:144
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:657
static bool classof(const Chunk *S)
Definition: ELFYAML.h:661
std::optional< std::vector< uint32_t > > Entries
Definition: ELFYAML.h:653
std::optional< std::vector< uint16_t > > Entries
Definition: ELFYAML.h:569
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:573
static bool classof(const Chunk *S)
Definition: ELFYAML.h:577
std::optional< uint16_t > Flags
Definition: ELFYAML.h:582
std::vector< StringRef > VerNames
Definition: ELFYAML.h:585
std::optional< uint16_t > VersionNdx
Definition: ELFYAML.h:583
std::optional< uint16_t > Version
Definition: ELFYAML.h:581
std::optional< uint32_t > Hash
Definition: ELFYAML.h:584
static bool classof(const Chunk *S)
Definition: ELFYAML.h:598
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:594
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:590
std::optional< std::vector< VerdefEntry > > Entries
Definition: ELFYAML.h:589
std::vector< VernauxEntry > AuxV
Definition: ELFYAML.h:485
std::vector< std::pair< StringRef, bool > > getEntries() const override
Definition: ELFYAML.h:494
std::optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:490
static bool classof(const Chunk *S)
Definition: ELFYAML.h:498
std::optional< std::vector< VerneedEntry > > VerneedV
Definition: ELFYAML.h:489