LLVM  10.0.0svn
ELFYAML.cpp
Go to the documentation of this file.
1 //===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
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 // This file defines classes for handling the YAML representation of ELF.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/ADT/MapVector.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/BinaryFormat/ELF.h"
17 #include "llvm/Support/Casting.h"
21 #include "llvm/Support/WithColor.h"
22 #include <cassert>
23 #include <cstdint>
24 
25 namespace llvm {
26 
27 ELFYAML::Section::~Section() = default;
28 
29 namespace yaml {
30 
32  IO &IO, ELFYAML::ELF_ET &Value) {
33 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
34  ECase(ET_NONE);
35  ECase(ET_REL);
36  ECase(ET_EXEC);
37  ECase(ET_DYN);
38  ECase(ET_CORE);
39 #undef ECase
40  IO.enumFallback<Hex16>(Value);
41 }
42 
44  IO &IO, ELFYAML::ELF_PT &Value) {
45 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
46  ECase(PT_NULL);
47  ECase(PT_LOAD);
50  ECase(PT_NOTE);
51  ECase(PT_SHLIB);
52  ECase(PT_PHDR);
53  ECase(PT_TLS);
57 #undef ECase
58  IO.enumFallback<Hex32>(Value);
59 }
60 
62  IO &IO, ELFYAML::ELF_EM &Value) {
63 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
64  ECase(EM_NONE);
65  ECase(EM_M32);
66  ECase(EM_SPARC);
67  ECase(EM_386);
68  ECase(EM_68K);
69  ECase(EM_88K);
70  ECase(EM_IAMCU);
71  ECase(EM_860);
72  ECase(EM_MIPS);
73  ECase(EM_S370);
78  ECase(EM_960);
79  ECase(EM_PPC);
80  ECase(EM_PPC64);
81  ECase(EM_S390);
82  ECase(EM_SPU);
83  ECase(EM_V800);
84  ECase(EM_FR20);
85  ECase(EM_RH32);
86  ECase(EM_RCE);
87  ECase(EM_ARM);
88  ECase(EM_ALPHA);
89  ECase(EM_SH);
92  ECase(EM_ARC);
95  ECase(EM_H8S);
97  ECase(EM_IA_64);
100  ECase(EM_68HC12);
101  ECase(EM_MMA);
102  ECase(EM_PCP);
103  ECase(EM_NCPU);
104  ECase(EM_NDR1);
106  ECase(EM_ME16);
107  ECase(EM_ST100);
108  ECase(EM_TINYJ);
109  ECase(EM_X86_64);
110  ECase(EM_PDSP);
111  ECase(EM_PDP10);
112  ECase(EM_PDP11);
113  ECase(EM_FX66);
114  ECase(EM_ST9PLUS);
115  ECase(EM_ST7);
116  ECase(EM_68HC16);
117  ECase(EM_68HC11);
118  ECase(EM_68HC08);
119  ECase(EM_68HC05);
120  ECase(EM_SVX);
121  ECase(EM_ST19);
122  ECase(EM_VAX);
123  ECase(EM_CRIS);
124  ECase(EM_JAVELIN);
126  ECase(EM_ZSP);
127  ECase(EM_MMIX);
128  ECase(EM_HUANY);
129  ECase(EM_PRISM);
130  ECase(EM_AVR);
131  ECase(EM_FR30);
132  ECase(EM_D10V);
133  ECase(EM_D30V);
134  ECase(EM_V850);
135  ECase(EM_M32R);
136  ECase(EM_MN10300);
137  ECase(EM_MN10200);
138  ECase(EM_PJ);
141  ECase(EM_XTENSA);
143  ECase(EM_TMM_GPP);
144  ECase(EM_NS32K);
145  ECase(EM_TPC);
146  ECase(EM_SNP1K);
147  ECase(EM_ST200);
148  ECase(EM_IP2K);
149  ECase(EM_MAX);
150  ECase(EM_CR);
151  ECase(EM_F2MC16);
152  ECase(EM_MSP430);
154  ECase(EM_SE_C33);
155  ECase(EM_SEP);
156  ECase(EM_ARCA);
157  ECase(EM_UNICORE);
158  ECase(EM_EXCESS);
159  ECase(EM_DXP);
161  ECase(EM_CRX);
162  ECase(EM_XGATE);
163  ECase(EM_C166);
164  ECase(EM_M16C);
166  ECase(EM_CE);
167  ECase(EM_M32C);
168  ECase(EM_TSK3000);
169  ECase(EM_RS08);
170  ECase(EM_SHARC);
171  ECase(EM_ECOG2);
172  ECase(EM_SCORE7);
173  ECase(EM_DSP24);
176  ECase(EM_SE_C17);
182  ECase(EM_R32C);
184  ECase(EM_HEXAGON);
185  ECase(EM_8051);
186  ECase(EM_STXP7X);
187  ECase(EM_NDS32);
188  ECase(EM_ECOG1);
189  ECase(EM_ECOG1X);
190  ECase(EM_MAXQ30);
191  ECase(EM_XIMO16);
192  ECase(EM_MANIK);
193  ECase(EM_CRAYNV2);
194  ECase(EM_RX);
195  ECase(EM_METAG);
197  ECase(EM_ECOG16);
198  ECase(EM_CR16);
199  ECase(EM_ETPU);
200  ECase(EM_SLE9X);
201  ECase(EM_L10M);
202  ECase(EM_K10M);
203  ECase(EM_AARCH64);
204  ECase(EM_AVR32);
205  ECase(EM_STM8);
206  ECase(EM_TILE64);
207  ECase(EM_TILEPRO);
208  ECase(EM_CUDA);
209  ECase(EM_TILEGX);
214  ECase(EM_OPEN8);
215  ECase(EM_RL78);
217  ECase(EM_78KOR);
218  ECase(EM_56800EX);
219  ECase(EM_AMDGPU);
220  ECase(EM_RISCV);
221  ECase(EM_LANAI);
222  ECase(EM_BPF);
223 #undef ECase
224  IO.enumFallback<Hex16>(Value);
225 }
226 
228  IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
229 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
230  // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
231  // here.
232  ECase(ELFCLASS32);
233  ECase(ELFCLASS64);
234 #undef ECase
235 }
236 
238  IO &IO, ELFYAML::ELF_ELFDATA &Value) {
239 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
240  // ELFDATANONE is an invalid data encoding, but we accept it because
241  // we want to be able to produce invalid binaries for the tests.
245 #undef ECase
246 }
247 
249  IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
250 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
275 #undef ECase
276 }
277 
279  ELFYAML::ELF_EF &Value) {
280  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
281  assert(Object && "The IO context is not initialized");
282 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
283 #define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
284  switch (Object->Header.Machine) {
285  case ELF::EM_ARM:
294  break;
295  case ELF::EM_MIPS:
339  break;
340  case ELF::EM_HEXAGON:
357  break;
358  case ELF::EM_AVR:
376  break;
377  case ELF::EM_RISCV:
384  break;
385  case ELF::EM_AMDGPU:
425  break;
426  case ELF::EM_X86_64:
427  break;
428  default:
429  llvm_unreachable("Unsupported architecture");
430  }
431 #undef BCase
432 #undef BCaseMask
433 }
434 
436  IO &IO, ELFYAML::ELF_SHT &Value) {
437  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
438  assert(Object && "The IO context is not initialized");
439 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
440  ECase(SHT_NULL);
442  ECase(SHT_SYMTAB);
443  // FIXME: Issue a diagnostic with this information.
444  ECase(SHT_STRTAB);
445  ECase(SHT_RELA);
446  ECase(SHT_HASH);
448  ECase(SHT_NOTE);
449  ECase(SHT_NOBITS);
450  ECase(SHT_REL);
451  ECase(SHT_SHLIB);
452  ECase(SHT_DYNSYM);
456  ECase(SHT_GROUP);
458  ECase(SHT_RELR);
475  switch (Object->Header.Machine) {
476  case ELF::EM_ARM:
482  break;
483  case ELF::EM_HEXAGON:
485  break;
486  case ELF::EM_X86_64:
488  break;
489  case ELF::EM_MIPS:
494  break;
495  default:
496  // Nothing to do.
497  break;
498  }
499 #undef ECase
500  IO.enumFallback<Hex32>(Value);
501 }
502 
504  ELFYAML::ELF_PF &Value) {
505 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
506  BCase(PF_X);
507  BCase(PF_W);
508  BCase(PF_R);
509 }
510 
512  ELFYAML::ELF_SHF &Value) {
513  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
514 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
515  BCase(SHF_WRITE);
516  BCase(SHF_ALLOC);
519  BCase(SHF_MERGE);
524  BCase(SHF_GROUP);
525  BCase(SHF_TLS);
527  switch (Object->Header.Machine) {
528  case ELF::EM_ARM:
530  break;
531  case ELF::EM_HEXAGON:
533  break;
534  case ELF::EM_MIPS:
543  break;
544  case ELF::EM_X86_64:
546  break;
547  default:
548  // Nothing to do.
549  break;
550  }
551 #undef BCase
552 }
553 
555  IO &IO, ELFYAML::ELF_SHN &Value) {
556 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
557  ECase(SHN_UNDEF);
559  ECase(SHN_LOPROC);
560  ECase(SHN_HIPROC);
561  ECase(SHN_LOOS);
562  ECase(SHN_HIOS);
563  ECase(SHN_ABS);
564  ECase(SHN_COMMON);
565  ECase(SHN_XINDEX);
573 #undef ECase
574  IO.enumFallback<Hex16>(Value);
575 }
576 
578  IO &IO, ELFYAML::ELF_STB &Value) {
579 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
580  ECase(STB_LOCAL);
581  ECase(STB_GLOBAL);
582  ECase(STB_WEAK);
584 #undef ECase
585  IO.enumFallback<Hex8>(Value);
586 }
587 
589  IO &IO, ELFYAML::ELF_STT &Value) {
590 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
591  ECase(STT_NOTYPE);
592  ECase(STT_OBJECT);
593  ECase(STT_FUNC);
595  ECase(STT_FILE);
596  ECase(STT_COMMON);
597  ECase(STT_TLS);
599 #undef ECase
600  IO.enumFallback<Hex8>(Value);
601 }
602 
603 
605  IO &IO, ELFYAML::ELF_RSS &Value) {
606 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
607  ECase(RSS_UNDEF);
608  ECase(RSS_GP);
609  ECase(RSS_GP0);
610  ECase(RSS_LOC);
611 #undef ECase
612 }
613 
615  IO &IO, ELFYAML::ELF_REL &Value) {
616  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
617  assert(Object && "The IO context is not initialized");
618 #define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
619  switch (Object->Header.Machine) {
620  case ELF::EM_X86_64:
621 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
622  break;
623  case ELF::EM_MIPS:
624 #include "llvm/BinaryFormat/ELFRelocs/Mips.def"
625  break;
626  case ELF::EM_HEXAGON:
627 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
628  break;
629  case ELF::EM_386:
630  case ELF::EM_IAMCU:
631 #include "llvm/BinaryFormat/ELFRelocs/i386.def"
632  break;
633  case ELF::EM_AARCH64:
634 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
635  break;
636  case ELF::EM_ARM:
637 #include "llvm/BinaryFormat/ELFRelocs/ARM.def"
638  break;
639  case ELF::EM_ARC:
640 #include "llvm/BinaryFormat/ELFRelocs/ARC.def"
641  break;
642  case ELF::EM_RISCV:
643 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
644  break;
645  case ELF::EM_LANAI:
646 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
647  break;
648  case ELF::EM_AMDGPU:
649 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
650  break;
651  case ELF::EM_BPF:
652 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
653  break;
654  case ELF::EM_PPC64:
655 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
656  break;
657  default:
658  llvm_unreachable("Unsupported architecture");
659  }
660 #undef ELF_RELOC
661  IO.enumFallback<Hex32>(Value);
662 }
663 
665  IO &IO, ELFYAML::ELF_DYNTAG &Value) {
666  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
667  assert(Object && "The IO context is not initialized");
668 
669 // Disable architecture specific tags by default. We might enable them below.
670 #define AARCH64_DYNAMIC_TAG(name, value)
671 #define MIPS_DYNAMIC_TAG(name, value)
672 #define HEXAGON_DYNAMIC_TAG(name, value)
673 #define PPC_DYNAMIC_TAG(name, value)
674 #define PPC64_DYNAMIC_TAG(name, value)
675 // Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
676 #define DYNAMIC_TAG_MARKER(name, value)
677 
678 #define STRINGIFY(X) (#X)
679 #define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
680  switch (Object->Header.Machine) {
681  case ELF::EM_AARCH64:
682 #undef AARCH64_DYNAMIC_TAG
683 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
684 #include "llvm/BinaryFormat/DynamicTags.def"
685 #undef AARCH64_DYNAMIC_TAG
686 #define AARCH64_DYNAMIC_TAG(name, value)
687  break;
688  case ELF::EM_MIPS:
689 #undef MIPS_DYNAMIC_TAG
690 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
691 #include "llvm/BinaryFormat/DynamicTags.def"
692 #undef MIPS_DYNAMIC_TAG
693 #define MIPS_DYNAMIC_TAG(name, value)
694  break;
695  case ELF::EM_HEXAGON:
696 #undef HEXAGON_DYNAMIC_TAG
697 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
698 #include "llvm/BinaryFormat/DynamicTags.def"
699 #undef HEXAGON_DYNAMIC_TAG
700 #define HEXAGON_DYNAMIC_TAG(name, value)
701  break;
702  case ELF::EM_PPC:
703 #undef PPC_DYNAMIC_TAG
704 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
705 #include "llvm/BinaryFormat/DynamicTags.def"
706 #undef PPC_DYNAMIC_TAG
707 #define PPC_DYNAMIC_TAG(name, value)
708  break;
709  case ELF::EM_PPC64:
710 #undef PPC64_DYNAMIC_TAG
711 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
712 #include "llvm/BinaryFormat/DynamicTags.def"
713 #undef PPC64_DYNAMIC_TAG
714 #define PPC64_DYNAMIC_TAG(name, value)
715  break;
716  default:
717 #include "llvm/BinaryFormat/DynamicTags.def"
718  break;
719  }
720 #undef AARCH64_DYNAMIC_TAG
721 #undef MIPS_DYNAMIC_TAG
722 #undef HEXAGON_DYNAMIC_TAG
723 #undef PPC_DYNAMIC_TAG
724 #undef PPC64_DYNAMIC_TAG
725 #undef DYNAMIC_TAG_MARKER
726 #undef STRINGIFY
727 #undef DYNAMIC_TAG
728 
729  IO.enumFallback<Hex64>(Value);
730 }
731 
733  IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
734 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
735  ECase(REG_NONE);
736  ECase(REG_32);
737  ECase(REG_64);
738  ECase(REG_128);
739 #undef ECase
740 }
741 
743  IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
744 #define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
745  ECase(FP_ANY);
746  ECase(FP_DOUBLE);
747  ECase(FP_SINGLE);
748  ECase(FP_SOFT);
749  ECase(FP_OLD_64);
750  ECase(FP_XX);
751  ECase(FP_64);
752  ECase(FP_64A);
753 #undef ECase
754 }
755 
757  IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
758 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
759  ECase(EXT_NONE);
760  ECase(EXT_XLR);
761  ECase(EXT_OCTEON2);
762  ECase(EXT_OCTEONP);
763  ECase(EXT_LOONGSON_3A);
764  ECase(EXT_OCTEON);
765  ECase(EXT_5900);
766  ECase(EXT_4650);
767  ECase(EXT_4010);
768  ECase(EXT_4100);
769  ECase(EXT_3900);
770  ECase(EXT_10000);
771  ECase(EXT_SB1);
772  ECase(EXT_4111);
773  ECase(EXT_4120);
774  ECase(EXT_5400);
775  ECase(EXT_5500);
776  ECase(EXT_LOONGSON_2E);
777  ECase(EXT_LOONGSON_2F);
778  ECase(EXT_OCTEON3);
779 #undef ECase
780 }
781 
783  IO &IO, ELFYAML::MIPS_ISA &Value) {
784  IO.enumCase(Value, "MIPS1", 1);
785  IO.enumCase(Value, "MIPS2", 2);
786  IO.enumCase(Value, "MIPS3", 3);
787  IO.enumCase(Value, "MIPS4", 4);
788  IO.enumCase(Value, "MIPS5", 5);
789  IO.enumCase(Value, "MIPS32", 32);
790  IO.enumCase(Value, "MIPS64", 64);
791 }
792 
794  IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
795 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
796  BCase(DSP);
797  BCase(DSPR2);
798  BCase(EVA);
799  BCase(MCU);
800  BCase(MDMX);
801  BCase(MIPS3D);
802  BCase(MT);
803  BCase(SMARTMIPS);
804  BCase(VIRT);
805  BCase(MSA);
806  BCase(MIPS16);
807  BCase(MICROMIPS);
808  BCase(XPA);
809 #undef BCase
810 }
811 
813  IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
814 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
815  BCase(ODDSPREG);
816 #undef BCase
817 }
818 
820  ELFYAML::FileHeader &FileHdr) {
821  IO.mapRequired("Class", FileHdr.Class);
822  IO.mapRequired("Data", FileHdr.Data);
823  IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
824  IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
825  IO.mapRequired("Type", FileHdr.Type);
826  IO.mapRequired("Machine", FileHdr.Machine);
827  IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
828  IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
829 
830  IO.mapOptional("SHEntSize", FileHdr.SHEntSize);
831  IO.mapOptional("SHOff", FileHdr.SHOff);
832  IO.mapOptional("SHNum", FileHdr.SHNum);
833  IO.mapOptional("SHStrNdx", FileHdr.SHStrNdx);
834 }
835 
837  IO &IO, ELFYAML::ProgramHeader &Phdr) {
838  IO.mapRequired("Type", Phdr.Type);
839  IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
840  IO.mapOptional("Sections", Phdr.Sections);
841  IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
842  IO.mapOptional("PAddr", Phdr.PAddr, Hex64(0));
843  IO.mapOptional("Align", Phdr.Align);
844  IO.mapOptional("FileSize", Phdr.FileSize);
845  IO.mapOptional("MemSize", Phdr.MemSize);
846  IO.mapOptional("Offset", Phdr.Offset);
847 }
848 
849 LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
850 
851 template <> struct ScalarTraits<StOtherPiece> {
852  static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
853  Out << Val;
854  }
855  static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
856  Val = Scalar;
857  return {};
858  }
859  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
860 };
861 template <> struct SequenceElementTraits<StOtherPiece> {
862  static const bool flow = true;
863 };
864 
865 namespace {
866 
867 struct NormalizedOther {
868  NormalizedOther(IO &IO) : YamlIO(IO) {}
869  NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
870  assert(Original && "This constructor is only used for outputting YAML and "
871  "assumes a non-empty Original");
872  std::vector<StOtherPiece> Ret;
873  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
874  for (std::pair<StringRef, uint8_t> &P :
875  getFlags(Object->Header.Machine).takeVector()) {
876  uint8_t FlagValue = P.second;
877  if ((*Original & FlagValue) != FlagValue)
878  continue;
879  *Original &= ~FlagValue;
880  Ret.push_back({P.first});
881  }
882 
883  if (*Original != 0) {
884  UnknownFlagsHolder = std::to_string(*Original);
885  Ret.push_back({UnknownFlagsHolder});
886  }
887 
888  if (!Ret.empty())
889  Other = std::move(Ret);
890  }
891 
892  uint8_t toValue(StringRef Name) {
893  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
894  MapVector<StringRef, uint8_t> Flags = getFlags(Object->Header.Machine);
895 
896  auto It = Flags.find(Name);
897  if (It != Flags.end())
898  return It->second;
899 
900  uint8_t Val;
901  if (to_integer(Name, Val))
902  return Val;
903 
904  YamlIO.setError("an unknown value is used for symbol's 'Other' field: " +
905  Name);
906  return 0;
907  }
908 
909  Optional<uint8_t> denormalize(IO &) {
910  if (!Other)
911  return None;
912  uint8_t Ret = 0;
913  for (StOtherPiece &Val : *Other)
914  Ret |= toValue(Val);
915  return Ret;
916  }
917 
918  // st_other field is used to encode symbol visibility and platform-dependent
919  // flags and values. This method returns a name to value map that is used for
920  // parsing and encoding this field.
921  MapVector<StringRef, uint8_t> getFlags(unsigned EMachine) {
923  // STV_* values are just enumeration values. We add them in a reversed order
924  // because when we convert the st_other to named constants when printing
925  // YAML we want to use a maximum number of bits on each step:
926  // when we have st_other == 3, we want to print it as STV_PROTECTED (3), but
927  // not as STV_HIDDEN (2) + STV_INTERNAL (1).
928  Map["STV_PROTECTED"] = ELF::STV_PROTECTED;
929  Map["STV_HIDDEN"] = ELF::STV_HIDDEN;
930  Map["STV_INTERNAL"] = ELF::STV_INTERNAL;
931  // STV_DEFAULT is used to represent the default visibility and has a value
932  // 0. We want to be able to read it from YAML documents, but there is no
933  // reason to print it.
934  if (!YamlIO.outputting())
935  Map["STV_DEFAULT"] = ELF::STV_DEFAULT;
936 
937  // MIPS is not consistent. All of the STO_MIPS_* values are bit flags,
938  // except STO_MIPS_MIPS16 which overlaps them. It should be checked and
939  // consumed first when we print the output, because we do not want to print
940  // any other flags that have the same bits instead.
941  if (EMachine == ELF::EM_MIPS) {
942  Map["STO_MIPS_MIPS16"] = ELF::STO_MIPS_MIPS16;
943  Map["STO_MIPS_MICROMIPS"] = ELF::STO_MIPS_MICROMIPS;
944  Map["STO_MIPS_PIC"] = ELF::STO_MIPS_PIC;
945  Map["STO_MIPS_PLT"] = ELF::STO_MIPS_PLT;
946  Map["STO_MIPS_OPTIONAL"] = ELF::STO_MIPS_OPTIONAL;
947  }
948  return Map;
949  }
950 
951  IO &YamlIO;
952  Optional<std::vector<StOtherPiece>> Other;
953  std::string UnknownFlagsHolder;
954 };
955 
956 } // end anonymous namespace
957 
959  IO.mapOptional("Name", Symbol.Name, StringRef());
960  IO.mapOptional("NameIndex", Symbol.NameIndex);
961  IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
962  IO.mapOptional("Section", Symbol.Section, StringRef());
963  IO.mapOptional("Index", Symbol.Index);
964  IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
965  IO.mapOptional("Value", Symbol.Value, Hex64(0));
966  IO.mapOptional("Size", Symbol.Size, Hex64(0));
967 
968  // Symbol's Other field is a bit special. It is usually a field that
969  // represents st_other and holds the symbol visibility. However, on some
970  // platforms, it can contain bit fields and regular values, or even sometimes a
971  // crazy mix of them (see comments for NormalizedOther). Because of this, we
972  // need special handling.
973  MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
974  Symbol.Other);
975  IO.mapOptional("Other", Keys->Other);
976 }
977 
980  if (Symbol.Index && Symbol.Section.data())
981  return "Index and Section cannot both be specified for Symbol";
982  if (Symbol.NameIndex && !Symbol.Name.empty())
983  return "Name and NameIndex cannot both be specified for Symbol";
984  return StringRef();
985 }
986 
988  IO.mapOptional("Name", Section.Name, StringRef());
989  IO.mapRequired("Type", Section.Type);
990  IO.mapOptional("Flags", Section.Flags);
991  IO.mapOptional("Address", Section.Address, Hex64(0));
992  IO.mapOptional("Link", Section.Link, StringRef());
993  IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
994  IO.mapOptional("EntSize", Section.EntSize);
995 
996  // obj2yaml does not dump these fields. They are expected to be empty when we
997  // are producing YAML, because yaml2obj sets appropriate values for them
998  // automatically when they are not explicitly defined.
999  assert(!IO.outputting() ||
1000  (!Section.ShOffset.hasValue() && !Section.ShSize.hasValue()));
1001  IO.mapOptional("ShName", Section.ShName);
1002  IO.mapOptional("ShOffset", Section.ShOffset);
1003  IO.mapOptional("ShSize", Section.ShSize);
1004 }
1005 
1007  commonSectionMapping(IO, Section);
1008  IO.mapOptional("Entries", Section.Entries);
1009  IO.mapOptional("Content", Section.Content);
1010 }
1011 
1013  commonSectionMapping(IO, Section);
1014  IO.mapOptional("Content", Section.Content);
1015  IO.mapOptional("Size", Section.Size);
1016  IO.mapOptional("Info", Section.Info);
1017 }
1018 
1020  commonSectionMapping(IO, Section);
1021  IO.mapOptional("Size", Section.Size, Hex64(0));
1022 }
1023 
1025  commonSectionMapping(IO, Section);
1026  IO.mapRequired("Info", Section.Info);
1027  IO.mapRequired("Entries", Section.Entries);
1028 }
1029 
1031  commonSectionMapping(IO, Section);
1032  IO.mapRequired("Entries", Section.Entries);
1033 }
1034 
1036  commonSectionMapping(IO, Section);
1037  IO.mapRequired("Info", Section.Info);
1038  IO.mapRequired("Dependencies", Section.VerneedV);
1039 }
1040 
1042  commonSectionMapping(IO, Section);
1043  IO.mapOptional("Info", Section.RelocatableSec, StringRef());
1044  IO.mapOptional("Relocations", Section.Relocations);
1045 }
1046 
1047 static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
1048  commonSectionMapping(IO, Group);
1049  IO.mapOptional("Info", Group.Signature, StringRef());
1050  IO.mapRequired("Members", Group.Members);
1051 }
1052 
1054  commonSectionMapping(IO, Section);
1055  IO.mapRequired("Entries", Section.Entries);
1056 }
1057 
1059  IO &IO, ELFYAML::SectionOrType &sectionOrType) {
1060  IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
1061 }
1062 
1064  IO &IO, ELFYAML::SectionName &sectionName) {
1065  IO.mapRequired("Section", sectionName.Section);
1066 }
1067 
1069  commonSectionMapping(IO, Section);
1070  IO.mapOptional("Version", Section.Version, Hex16(0));
1071  IO.mapRequired("ISA", Section.ISALevel);
1072  IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
1073  IO.mapOptional("ISAExtension", Section.ISAExtension,
1074  ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
1075  IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
1076  IO.mapOptional("FpABI", Section.FpABI,
1077  ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
1078  IO.mapOptional("GPRSize", Section.GPRSize,
1079  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1080  IO.mapOptional("CPR1Size", Section.CPR1Size,
1081  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1082  IO.mapOptional("CPR2Size", Section.CPR2Size,
1083  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1084  IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
1085  IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
1086 }
1087 
1089  IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
1090  ELFYAML::ELF_SHT sectionType;
1091  if (IO.outputting())
1092  sectionType = Section->Type;
1093  else
1094  IO.mapRequired("Type", sectionType);
1095 
1096  switch (sectionType) {
1097  case ELF::SHT_DYNAMIC:
1098  if (!IO.outputting())
1099  Section.reset(new ELFYAML::DynamicSection());
1100  sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
1101  break;
1102  case ELF::SHT_REL:
1103  case ELF::SHT_RELA:
1104  if (!IO.outputting())
1105  Section.reset(new ELFYAML::RelocationSection());
1106  sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
1107  break;
1108  case ELF::SHT_GROUP:
1109  if (!IO.outputting())
1110  Section.reset(new ELFYAML::Group());
1111  groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
1112  break;
1113  case ELF::SHT_NOBITS:
1114  if (!IO.outputting())
1115  Section.reset(new ELFYAML::NoBitsSection());
1116  sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
1117  break;
1119  if (!IO.outputting())
1120  Section.reset(new ELFYAML::MipsABIFlags());
1121  sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
1122  break;
1123  case ELF::SHT_GNU_verdef:
1124  if (!IO.outputting())
1125  Section.reset(new ELFYAML::VerdefSection());
1126  sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
1127  break;
1128  case ELF::SHT_GNU_versym:
1129  if (!IO.outputting())
1130  Section.reset(new ELFYAML::SymverSection());
1131  sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
1132  break;
1133  case ELF::SHT_GNU_verneed:
1134  if (!IO.outputting())
1135  Section.reset(new ELFYAML::VerneedSection());
1136  sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
1137  break;
1138  case ELF::SHT_SYMTAB_SHNDX:
1139  if (!IO.outputting())
1140  Section.reset(new ELFYAML::SymtabShndxSection());
1141  sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
1142  break;
1143  default:
1144  if (!IO.outputting())
1145  Section.reset(new ELFYAML::RawContentSection());
1146  sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
1147  }
1148 }
1149 
1151  IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
1152  const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
1153  if (!RawSection)
1154  return {};
1155  if (RawSection->Size && RawSection->Content &&
1156  (uint64_t)(*RawSection->Size) < RawSection->Content->binary_size())
1157  return "Section size must be greater than or equal to the content size";
1158  return {};
1159 }
1160 
1161 namespace {
1162 
1163 struct NormalizedMips64RelType {
1164  NormalizedMips64RelType(IO &)
1165  : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1166  Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1167  Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1168  SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
1169  NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
1170  : Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
1171  Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
1172 
1173  ELFYAML::ELF_REL denormalize(IO &) {
1174  ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
1175  return Res;
1176  }
1177 
1178  ELFYAML::ELF_REL Type;
1179  ELFYAML::ELF_REL Type2;
1180  ELFYAML::ELF_REL Type3;
1181  ELFYAML::ELF_RSS SpecSym;
1182 };
1183 
1184 } // end anonymous namespace
1185 
1187  ELFYAML::DynamicEntry &Rel) {
1188  assert(IO.getContext() && "The IO context is not initialized");
1189 
1190  IO.mapRequired("Tag", Rel.Tag);
1191  IO.mapRequired("Value", Rel.Val);
1192 }
1193 
1196  assert(IO.getContext() && "The IO context is not initialized");
1197 
1198  IO.mapRequired("Version", E.Version);
1199  IO.mapRequired("Flags", E.Flags);
1200  IO.mapRequired("VersionNdx", E.VersionNdx);
1201  IO.mapRequired("Hash", E.Hash);
1202  IO.mapRequired("Names", E.VerNames);
1203 }
1204 
1207  assert(IO.getContext() && "The IO context is not initialized");
1208 
1209  IO.mapRequired("Version", E.Version);
1210  IO.mapRequired("File", E.File);
1211  IO.mapRequired("Entries", E.AuxV);
1212 }
1213 
1216  assert(IO.getContext() && "The IO context is not initialized");
1217 
1218  IO.mapRequired("Name", E.Name);
1219  IO.mapRequired("Hash", E.Hash);
1220  IO.mapRequired("Flags", E.Flags);
1221  IO.mapRequired("Other", E.Other);
1222 }
1223 
1225  ELFYAML::Relocation &Rel) {
1226  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
1227  assert(Object && "The IO context is not initialized");
1228 
1229  IO.mapRequired("Offset", Rel.Offset);
1230  IO.mapOptional("Symbol", Rel.Symbol);
1231 
1232  if (Object->Header.Machine == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
1233  Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
1234  MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
1235  IO, Rel.Type);
1236  IO.mapRequired("Type", Key->Type);
1237  IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1238  IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1239  IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
1240  } else
1241  IO.mapRequired("Type", Rel.Type);
1242 
1243  IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
1244 }
1245 
1247  assert(!IO.getContext() && "The IO context is initialized already");
1248  IO.setContext(&Object);
1249  IO.mapTag("!ELF", true);
1250  IO.mapRequired("FileHeader", Object.Header);
1251  IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
1252  IO.mapOptional("Sections", Object.Sections);
1253  IO.mapOptional("Symbols", Object.Symbols);
1254  IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
1255  IO.setContext(nullptr);
1256 }
1257 
1258 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
1259 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
1260 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
1261 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
1262 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
1263 
1264 } // end namespace yaml
1265 
1266 } // end namespace llvm
const NoneType None
Definition: None.h:23
This file declares classes for handling the YAML representation of ELF.
static void bitset(IO &IO, ELFYAML::ELF_SHF &Value)
Definition: ELFYAML.cpp:511
Optional< ELF_SHF > Flags
Definition: ELFYAML.h:136
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool to_integer(StringRef S, N &Num, unsigned Base=0)
Convert the string S to an integer of the specified type using the radix Base.
Definition: StringExtras.h:193
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
static void enumeration(IO &IO, ELFYAML::ELF_ET &Value)
Definition: ELFYAML.cpp:31
Optional< llvm::yaml::Hex64 > Align
Definition: ELFYAML.h:92
static void enumeration(IO &IO, ELFYAML::ELF_STT &Value)
Definition: ELFYAML.cpp:588
Optional< ELF_SHN > Index
Definition: ELFYAML.h:104
static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value)
Definition: ELFYAML.cpp:554
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:952
llvm::yaml::Hex64 PAddr
Definition: ELFYAML.h:91
static void bitset(IO &IO, ELFYAML::ELF_PF &Value)
Definition: ELFYAML.cpp:503
std::vector< SectionName > Sections
Definition: ELFYAML.h:96
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:37
llvm::yaml::Hex16 Version
Definition: ELFYAML.h:295
Optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:179
ELFYAML::ELF_REL Type3
Definition: ELFYAML.cpp:1180
llvm::yaml::Hex64 Info
Definition: ELFYAML.h:243
llvm::yaml::Hex64 Address
Definition: ELFYAML.h:137
static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value)
Definition: ELFYAML.cpp:604
FileHeader Header
Definition: ELFYAML.h:315
static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value)
Definition: ELFYAML.cpp:435
llvm::yaml::Hex64 Entry
Definition: ELFYAML.h:75
static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value)
Definition: ELFYAML.cpp:812
llvm::yaml::Hex64 AddressAlign
Definition: ELFYAML.h:139
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:190
std::vector< DynamicEntry > Entries
Definition: ELFYAML.h:167
StringRef Section
Definition: ELFYAML.h:103
static void groupSectionMapping(IO &IO, ELFYAML::Group &Group)
Definition: ELFYAML.cpp:1047
static void enumeration(IO &IO, ELFYAML::ELF_EM &Value)
Definition: ELFYAML.cpp:61
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:107
std::vector< Symbol > Symbols
Definition: ELFYAML.h:322
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
llvm::yaml::Hex8 ABIVersion
Definition: ELFYAML.h:71
llvm::yaml::Hex64 Info
Definition: ELFYAML.h:214
Key
PAL metadata keys.
static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value)
Definition: ELFYAML.cpp:227
Optional< llvm::yaml::Hex64 > EntSize
Definition: ELFYAML.h:140
ELFYAML::ELF_RSS SpecSym
Definition: ELFYAML.cpp:1181
static StringRef input(StringRef Scalar, void *, StOtherPiece &Val)
Definition: ELFYAML.cpp:855
static void output(const StOtherPiece &Val, void *, raw_ostream &Out)
Definition: ELFYAML.cpp:852
iterator find(const KeyT &Key)
Definition: MapVector.h:147
static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value)
Definition: ELFYAML.cpp:782
Optional< uint8_t > Other
Definition: ELFYAML.h:108
Optional< llvm::yaml::Hex64 > ShSize
Definition: ELFYAML.h:163
std::vector< ProgramHeader > ProgramHeaders
Definition: ELFYAML.h:316
std::vector< VernauxEntry > AuxV
Definition: ELFYAML.h:209
static void commonSectionMapping(IO &IO, ELFYAML::Section &Section)
Definition: ELFYAML.cpp:987
#define P(N)
static void enumeration(IO &IO, ELFYAML::ELF_PT &Value)
Definition: ELFYAML.cpp:43
Optional< llvm::yaml::Hex16 > SHStrNdx
Definition: ELFYAML.h:80
std::string UnknownFlagsHolder
Definition: ELFYAML.cpp:953
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value)
Definition: ELFYAML.cpp:664
llvm::yaml::Hex32 Flags2
Definition: ELFYAML.h:305
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define BCase(X)
static void enumeration(IO &IO, ELFYAML::ELF_REL &Value)
Definition: ELFYAML.cpp:614
std::vector< uint32_t > Entries
Definition: ELFYAML.h:284
Optional< llvm::yaml::Hex64 > SHOff
Definition: ELFYAML.h:78
std::vector< VerneedEntry > VerneedV
Definition: ELFYAML.h:213
std::vector< StringRef > VerNames
Definition: ELFYAML.h:238
StringRef Signature
Definition: ELFYAML.h:256
static QuotingType mustQuote(StringRef)
Definition: ELFYAML.cpp:859
static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section)
Definition: ELFYAML.cpp:1006
std::vector< std::unique_ptr< Section > > Sections
Definition: ELFYAML.h:317
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:178
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:168
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
llvm::yaml::Hex8 ISARevision
Definition: ELFYAML.h:297
Optional< llvm::yaml::Hex64 > MemSize
Definition: ELFYAML.h:94
static void bitset(IO &IO, ELFYAML::ELF_EF &Value)
Definition: ELFYAML.cpp:278
ELF_ELFCLASS Class
Definition: ELFYAML.h:68
std::vector< SectionOrType > Members
Definition: ELFYAML.h:255
Optional< llvm::yaml::Hex64 > ShOffset
Definition: ELFYAML.h:159
llvm::yaml::Hex64 Offset
Definition: ELFYAML.h:266
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:28
std::vector< Symbol > DynamicSymbols
Definition: ELFYAML.h:323
static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value)
Definition: ELFYAML.cpp:248
Optional< llvm::yaml::Hex16 > SHNum
Definition: ELFYAML.h:79
static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value)
Definition: ELFYAML.cpp:793
Optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:180
Optional< llvm::yaml::Hex64 > ShName
Definition: ELFYAML.h:155
static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value)
Definition: ELFYAML.cpp:756
#define ECase(X)
bool hasValue() const
Definition: Optional.h:259
ELFYAML::ELF_REL Type2
Definition: ELFYAML.cpp:1179
static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value)
Definition: ELFYAML.cpp:742
MIPS_AFL_EXT ISAExtension
Definition: ELFYAML.h:302
llvm::yaml::Hex64 Value
Definition: ELFYAML.h:106
static void enumeration(IO &IO, ELFYAML::ELF_STB &Value)
Definition: ELFYAML.cpp:577
static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value)
Definition: ELFYAML.cpp:237
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
Optional< llvm::yaml::Hex64 > FileSize
Definition: ELFYAML.h:93
std::vector< VerdefEntry > Entries
Definition: ELFYAML.h:242
const std::string to_string(const T &Value)
Definition: ScopedPrinter.h:61
Optional< llvm::yaml::Hex16 > SHEntSize
Definition: ELFYAML.h:77
Optional< uint32_t > NameIndex
Definition: ELFYAML.h:101
MIPS_AFL_FLAGS1 Flags1
Definition: ELFYAML.h:304
IO & YamlIO
Definition: ELFYAML.cpp:951
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
iterator end()
Definition: MapVector.h:71
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:117
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
std::vector< uint16_t > Entries
Definition: ELFYAML.h:224
static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value)
Definition: ELFYAML.cpp:732
ELF_ELFOSABI OSABI
Definition: ELFYAML.h:70
llvm::yaml::Hex64 VAddr
Definition: ELFYAML.h:90
#define BCaseMask(X, M)
Optional< StringRef > Symbol
Definition: ELFYAML.h:269
std::vector< Relocation > Relocations
Definition: ELFYAML.h:273
void validate(const Triple &TT, const FeatureBitset &FeatureBits)
Optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:95