LLVM  15.0.0git
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/APInt.h"
15 #include "llvm/ADT/MapVector.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/BinaryFormat/ELF.h"
18 #include "llvm/Support/ARMEHABI.h"
19 #include "llvm/Support/Casting.h"
23 #include "llvm/Support/WithColor.h"
24 #include <cassert>
25 #include <cstdint>
26 
27 namespace llvm {
28 
29 ELFYAML::Chunk::~Chunk() = default;
30 
31 namespace ELFYAML {
32 ELF_ELFOSABI Object::getOSAbi() const { return Header.OSABI; }
33 
34 unsigned Object::getMachine() const {
35  if (Header.Machine)
36  return *Header.Machine;
37  return llvm::ELF::EM_NONE;
38 }
39 
41 } // namespace ELFYAML
42 
43 namespace yaml {
44 
46  IO &IO, ELFYAML::ELF_ET &Value) {
47 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
48  ECase(ET_NONE);
49  ECase(ET_REL);
50  ECase(ET_EXEC);
51  ECase(ET_DYN);
52  ECase(ET_CORE);
53 #undef ECase
54  IO.enumFallback<Hex16>(Value);
55 }
56 
58  IO &IO, ELFYAML::ELF_PT &Value) {
59 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
60  ECase(PT_NULL);
61  ECase(PT_LOAD);
64  ECase(PT_NOTE);
65  ECase(PT_SHLIB);
66  ECase(PT_PHDR);
67  ECase(PT_TLS);
72 #undef ECase
73  IO.enumFallback<Hex32>(Value);
74 }
75 
77  IO &IO, ELFYAML::ELF_NT &Value) {
78 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
79  // Generic note types.
81  ECase(NT_ARCH);
84  // Core note types.
89  ECase(NT_AUXV);
101  ECase(NT_PPC_EBB);
102  ECase(NT_PPC_PMU);
111  ECase(NT_386_TLS);
127  ECase(NT_ARM_VFP);
128  ECase(NT_ARM_TLS);
131  ECase(NT_ARM_SVE);
133  ECase(NT_FILE);
135  ECase(NT_SIGINFO);
136  // LLVM-specific notes.
138  // GNU note types
144  // FreeBSD note types.
149  // FreeBSD core note types.
160  // NetBSD core note types.
164  // OpenBSD core note types.
171  // AMD specific notes. (Code Object V2)
178  // AMDGPU specific notes. (Code Object V3)
180  // Android specific notes.
184 #undef ECase
185  IO.enumFallback<Hex32>(Value);
186 }
187 
189  IO &IO, ELFYAML::ELF_EM &Value) {
190 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
191  ECase(EM_NONE);
192  ECase(EM_M32);
193  ECase(EM_SPARC);
194  ECase(EM_386);
195  ECase(EM_68K);
196  ECase(EM_88K);
197  ECase(EM_IAMCU);
198  ECase(EM_860);
199  ECase(EM_MIPS);
200  ECase(EM_S370);
202  ECase(EM_PARISC);
203  ECase(EM_VPP500);
205  ECase(EM_960);
206  ECase(EM_PPC);
207  ECase(EM_PPC64);
208  ECase(EM_S390);
209  ECase(EM_SPU);
210  ECase(EM_V800);
211  ECase(EM_FR20);
212  ECase(EM_RH32);
213  ECase(EM_RCE);
214  ECase(EM_ARM);
215  ECase(EM_ALPHA);
216  ECase(EM_SH);
217  ECase(EM_SPARCV9);
218  ECase(EM_TRICORE);
219  ECase(EM_ARC);
220  ECase(EM_H8_300);
221  ECase(EM_H8_300H);
222  ECase(EM_H8S);
223  ECase(EM_H8_500);
224  ECase(EM_IA_64);
225  ECase(EM_MIPS_X);
227  ECase(EM_68HC12);
228  ECase(EM_MMA);
229  ECase(EM_PCP);
230  ECase(EM_NCPU);
231  ECase(EM_NDR1);
233  ECase(EM_ME16);
234  ECase(EM_ST100);
235  ECase(EM_TINYJ);
236  ECase(EM_X86_64);
237  ECase(EM_PDSP);
238  ECase(EM_PDP10);
239  ECase(EM_PDP11);
240  ECase(EM_FX66);
241  ECase(EM_ST9PLUS);
242  ECase(EM_ST7);
243  ECase(EM_68HC16);
244  ECase(EM_68HC11);
245  ECase(EM_68HC08);
246  ECase(EM_68HC05);
247  ECase(EM_SVX);
248  ECase(EM_ST19);
249  ECase(EM_VAX);
250  ECase(EM_CRIS);
251  ECase(EM_JAVELIN);
253  ECase(EM_ZSP);
254  ECase(EM_MMIX);
255  ECase(EM_HUANY);
256  ECase(EM_PRISM);
257  ECase(EM_AVR);
258  ECase(EM_FR30);
259  ECase(EM_D10V);
260  ECase(EM_D30V);
261  ECase(EM_V850);
262  ECase(EM_M32R);
263  ECase(EM_MN10300);
264  ECase(EM_MN10200);
265  ECase(EM_PJ);
268  ECase(EM_XTENSA);
270  ECase(EM_TMM_GPP);
271  ECase(EM_NS32K);
272  ECase(EM_TPC);
273  ECase(EM_SNP1K);
274  ECase(EM_ST200);
275  ECase(EM_IP2K);
276  ECase(EM_MAX);
277  ECase(EM_CR);
278  ECase(EM_F2MC16);
279  ECase(EM_MSP430);
281  ECase(EM_SE_C33);
282  ECase(EM_SEP);
283  ECase(EM_ARCA);
284  ECase(EM_UNICORE);
285  ECase(EM_EXCESS);
286  ECase(EM_DXP);
288  ECase(EM_CRX);
289  ECase(EM_XGATE);
290  ECase(EM_C166);
291  ECase(EM_M16C);
293  ECase(EM_CE);
294  ECase(EM_M32C);
295  ECase(EM_TSK3000);
296  ECase(EM_RS08);
297  ECase(EM_SHARC);
298  ECase(EM_ECOG2);
299  ECase(EM_SCORE7);
300  ECase(EM_DSP24);
303  ECase(EM_SE_C17);
309  ECase(EM_R32C);
311  ECase(EM_HEXAGON);
312  ECase(EM_8051);
313  ECase(EM_STXP7X);
314  ECase(EM_NDS32);
315  ECase(EM_ECOG1);
316  ECase(EM_ECOG1X);
317  ECase(EM_MAXQ30);
318  ECase(EM_XIMO16);
319  ECase(EM_MANIK);
320  ECase(EM_CRAYNV2);
321  ECase(EM_RX);
322  ECase(EM_METAG);
324  ECase(EM_ECOG16);
325  ECase(EM_CR16);
326  ECase(EM_ETPU);
327  ECase(EM_SLE9X);
328  ECase(EM_L10M);
329  ECase(EM_K10M);
330  ECase(EM_AARCH64);
331  ECase(EM_AVR32);
332  ECase(EM_STM8);
333  ECase(EM_TILE64);
334  ECase(EM_TILEPRO);
336  ECase(EM_CUDA);
337  ECase(EM_TILEGX);
342  ECase(EM_OPEN8);
343  ECase(EM_RL78);
345  ECase(EM_78KOR);
346  ECase(EM_56800EX);
347  ECase(EM_AMDGPU);
348  ECase(EM_RISCV);
349  ECase(EM_LANAI);
350  ECase(EM_BPF);
351  ECase(EM_VE);
352  ECase(EM_CSKY);
354 #undef ECase
355  IO.enumFallback<Hex16>(Value);
356 }
357 
359  IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
360 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
361  // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
362  // here.
363  ECase(ELFCLASS32);
364  ECase(ELFCLASS64);
365 #undef ECase
366 }
367 
369  IO &IO, ELFYAML::ELF_ELFDATA &Value) {
370 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
371  // ELFDATANONE is an invalid data encoding, but we accept it because
372  // we want to be able to produce invalid binaries for the tests.
376 #undef ECase
377 }
378 
380  IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
381 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
407 #undef ECase
408  IO.enumFallback<Hex8>(Value);
409 }
410 
412  ELFYAML::ELF_EF &Value) {
413  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
414  assert(Object && "The IO context is not initialized");
415 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
416 #define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
417  switch (Object->getMachine()) {
418  case ELF::EM_ARM:
427  break;
428  case ELF::EM_MIPS:
472  break;
473  case ELF::EM_HEXAGON:
499  break;
500  case ELF::EM_AVR:
520  break;
521  case ELF::EM_RISCV:
529  break;
530  case ELF::EM_AMDGPU:
586  switch (Object->Header.ABIVersion) {
587  default:
588  // ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags.
593  break;
612  break;
613  }
614  break;
615  default:
616  break;
617  }
618 #undef BCase
619 #undef BCaseMask
620 }
621 
623  IO &IO, ELFYAML::ELF_SHT &Value) {
624  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
625  assert(Object && "The IO context is not initialized");
626 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
627  ECase(SHT_NULL);
629  ECase(SHT_SYMTAB);
630  // FIXME: Issue a diagnostic with this information.
631  ECase(SHT_STRTAB);
632  ECase(SHT_RELA);
633  ECase(SHT_HASH);
635  ECase(SHT_NOTE);
636  ECase(SHT_NOBITS);
637  ECase(SHT_REL);
638  ECase(SHT_SHLIB);
639  ECase(SHT_DYNSYM);
643  ECase(SHT_GROUP);
645  ECase(SHT_RELR);
664  switch (Object->getMachine()) {
665  case ELF::EM_ARM:
671  break;
672  case ELF::EM_HEXAGON:
674  break;
675  case ELF::EM_X86_64:
677  break;
678  case ELF::EM_MIPS:
683  break;
684  case ELF::EM_RISCV:
686  break;
687  case ELF::EM_MSP430:
689  break;
690  default:
691  // Nothing to do.
692  break;
693  }
694 #undef ECase
695  IO.enumFallback<Hex32>(Value);
696 }
697 
699  ELFYAML::ELF_PF &Value) {
700 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
701  BCase(PF_X);
702  BCase(PF_W);
703  BCase(PF_R);
704 }
705 
707  ELFYAML::ELF_SHF &Value) {
708  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
709 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
710  BCase(SHF_WRITE);
711  BCase(SHF_ALLOC);
714  BCase(SHF_MERGE);
719  BCase(SHF_GROUP);
720  BCase(SHF_TLS);
722  switch (Object->getOSAbi()) {
725  break;
726  default:
728  break;
729  }
730  switch (Object->getMachine()) {
731  case ELF::EM_ARM:
733  break;
734  case ELF::EM_HEXAGON:
736  break;
737  case ELF::EM_MIPS:
746  break;
747  case ELF::EM_X86_64:
749  break;
750  default:
751  // Nothing to do.
752  break;
753  }
754 #undef BCase
755 }
756 
758  IO &IO, ELFYAML::ELF_SHN &Value) {
759  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
760  assert(Object && "The IO context is not initialized");
761 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
762  ECase(SHN_UNDEF);
764  ECase(SHN_LOPROC);
765  ECase(SHN_HIPROC);
766  ECase(SHN_LOOS);
767  ECase(SHN_HIOS);
768  ECase(SHN_ABS);
769  ECase(SHN_COMMON);
770  ECase(SHN_XINDEX);
773 
774  if (!IO.outputting() || Object->getMachine() == ELF::EM_MIPS) {
780  }
781 
787 #undef ECase
788  IO.enumFallback<Hex16>(Value);
789 }
790 
792  IO &IO, ELFYAML::ELF_STB &Value) {
793 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
794  ECase(STB_LOCAL);
795  ECase(STB_GLOBAL);
796  ECase(STB_WEAK);
798 #undef ECase
799  IO.enumFallback<Hex8>(Value);
800 }
801 
803  IO &IO, ELFYAML::ELF_STT &Value) {
804 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
805  ECase(STT_NOTYPE);
806  ECase(STT_OBJECT);
807  ECase(STT_FUNC);
809  ECase(STT_FILE);
810  ECase(STT_COMMON);
811  ECase(STT_TLS);
813 #undef ECase
814  IO.enumFallback<Hex8>(Value);
815 }
816 
817 
819  IO &IO, ELFYAML::ELF_RSS &Value) {
820 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
821  ECase(RSS_UNDEF);
822  ECase(RSS_GP);
823  ECase(RSS_GP0);
824  ECase(RSS_LOC);
825 #undef ECase
826 }
827 
829  IO &IO, ELFYAML::ELF_REL &Value) {
830  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
831  assert(Object && "The IO context is not initialized");
832 #define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
833  switch (Object->getMachine()) {
834  case ELF::EM_X86_64:
835 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
836  break;
837  case ELF::EM_MIPS:
838 #include "llvm/BinaryFormat/ELFRelocs/Mips.def"
839  break;
840  case ELF::EM_HEXAGON:
841 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
842  break;
843  case ELF::EM_386:
844  case ELF::EM_IAMCU:
845 #include "llvm/BinaryFormat/ELFRelocs/i386.def"
846  break;
847  case ELF::EM_AARCH64:
848 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
849  break;
850  case ELF::EM_ARM:
851 #include "llvm/BinaryFormat/ELFRelocs/ARM.def"
852  break;
853  case ELF::EM_ARC:
854 #include "llvm/BinaryFormat/ELFRelocs/ARC.def"
855  break;
856  case ELF::EM_RISCV:
857 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
858  break;
859  case ELF::EM_LANAI:
860 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
861  break;
862  case ELF::EM_AMDGPU:
863 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
864  break;
865  case ELF::EM_BPF:
866 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
867  break;
868  case ELF::EM_VE:
869 #include "llvm/BinaryFormat/ELFRelocs/VE.def"
870  break;
871  case ELF::EM_CSKY:
872 #include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
873  break;
874  case ELF::EM_PPC:
875 #include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
876  break;
877  case ELF::EM_PPC64:
878 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
879  break;
880  case ELF::EM_68K:
881 #include "llvm/BinaryFormat/ELFRelocs/M68k.def"
882  break;
883  case ELF::EM_LOONGARCH:
884 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
885  break;
886  default:
887  // Nothing to do.
888  break;
889  }
890 #undef ELF_RELOC
891  IO.enumFallback<Hex32>(Value);
892 }
893 
895  IO &IO, ELFYAML::ELF_DYNTAG &Value) {
896  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
897  assert(Object && "The IO context is not initialized");
898 
899 // Disable architecture specific tags by default. We might enable them below.
900 #define AARCH64_DYNAMIC_TAG(name, value)
901 #define MIPS_DYNAMIC_TAG(name, value)
902 #define HEXAGON_DYNAMIC_TAG(name, value)
903 #define PPC_DYNAMIC_TAG(name, value)
904 #define PPC64_DYNAMIC_TAG(name, value)
905 // Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
906 #define DYNAMIC_TAG_MARKER(name, value)
907 
908 #define STRINGIFY(X) (#X)
909 #define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
910  switch (Object->getMachine()) {
911  case ELF::EM_AARCH64:
912 #undef AARCH64_DYNAMIC_TAG
913 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
914 #include "llvm/BinaryFormat/DynamicTags.def"
915 #undef AARCH64_DYNAMIC_TAG
916 #define AARCH64_DYNAMIC_TAG(name, value)
917  break;
918  case ELF::EM_MIPS:
919 #undef MIPS_DYNAMIC_TAG
920 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
921 #include "llvm/BinaryFormat/DynamicTags.def"
922 #undef MIPS_DYNAMIC_TAG
923 #define MIPS_DYNAMIC_TAG(name, value)
924  break;
925  case ELF::EM_HEXAGON:
926 #undef HEXAGON_DYNAMIC_TAG
927 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
928 #include "llvm/BinaryFormat/DynamicTags.def"
929 #undef HEXAGON_DYNAMIC_TAG
930 #define HEXAGON_DYNAMIC_TAG(name, value)
931  break;
932  case ELF::EM_PPC:
933 #undef PPC_DYNAMIC_TAG
934 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
935 #include "llvm/BinaryFormat/DynamicTags.def"
936 #undef PPC_DYNAMIC_TAG
937 #define PPC_DYNAMIC_TAG(name, value)
938  break;
939  case ELF::EM_PPC64:
940 #undef PPC64_DYNAMIC_TAG
941 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
942 #include "llvm/BinaryFormat/DynamicTags.def"
943 #undef PPC64_DYNAMIC_TAG
944 #define PPC64_DYNAMIC_TAG(name, value)
945  break;
946  case ELF::EM_RISCV:
947 #undef RISCV_DYNAMIC_TAG
948 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
949 #include "llvm/BinaryFormat/DynamicTags.def"
950 #undef RISCV_DYNAMIC_TAG
951 #define RISCV_DYNAMIC_TAG(name, value)
952  break;
953  default:
954 #include "llvm/BinaryFormat/DynamicTags.def"
955  break;
956  }
957 #undef AARCH64_DYNAMIC_TAG
958 #undef MIPS_DYNAMIC_TAG
959 #undef HEXAGON_DYNAMIC_TAG
960 #undef PPC_DYNAMIC_TAG
961 #undef PPC64_DYNAMIC_TAG
962 #undef DYNAMIC_TAG_MARKER
963 #undef STRINGIFY
964 #undef DYNAMIC_TAG
965 
966  IO.enumFallback<Hex64>(Value);
967 }
968 
970  IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
971 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
972  ECase(REG_NONE);
973  ECase(REG_32);
974  ECase(REG_64);
975  ECase(REG_128);
976 #undef ECase
977 }
978 
980  IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
981 #define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
982  ECase(FP_ANY);
983  ECase(FP_DOUBLE);
984  ECase(FP_SINGLE);
985  ECase(FP_SOFT);
986  ECase(FP_OLD_64);
987  ECase(FP_XX);
988  ECase(FP_64);
989  ECase(FP_64A);
990 #undef ECase
991 }
992 
994  IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
995 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
996  ECase(EXT_NONE);
997  ECase(EXT_XLR);
998  ECase(EXT_OCTEON2);
999  ECase(EXT_OCTEONP);
1000  ECase(EXT_LOONGSON_3A);
1001  ECase(EXT_OCTEON);
1002  ECase(EXT_5900);
1003  ECase(EXT_4650);
1004  ECase(EXT_4010);
1005  ECase(EXT_4100);
1006  ECase(EXT_3900);
1007  ECase(EXT_10000);
1008  ECase(EXT_SB1);
1009  ECase(EXT_4111);
1010  ECase(EXT_4120);
1011  ECase(EXT_5400);
1012  ECase(EXT_5500);
1013  ECase(EXT_LOONGSON_2E);
1014  ECase(EXT_LOONGSON_2F);
1015  ECase(EXT_OCTEON3);
1016 #undef ECase
1017 }
1018 
1020  IO &IO, ELFYAML::MIPS_ISA &Value) {
1021  IO.enumCase(Value, "MIPS1", 1);
1022  IO.enumCase(Value, "MIPS2", 2);
1023  IO.enumCase(Value, "MIPS3", 3);
1024  IO.enumCase(Value, "MIPS4", 4);
1025  IO.enumCase(Value, "MIPS5", 5);
1026  IO.enumCase(Value, "MIPS32", 32);
1027  IO.enumCase(Value, "MIPS64", 64);
1028  IO.enumFallback<Hex32>(Value);
1029 }
1030 
1032  IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
1033 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
1034  BCase(DSP);
1035  BCase(DSPR2);
1036  BCase(EVA);
1037  BCase(MCU);
1038  BCase(MDMX);
1039  BCase(MIPS3D);
1040  BCase(MT);
1041  BCase(SMARTMIPS);
1042  BCase(VIRT);
1043  BCase(MSA);
1044  BCase(MIPS16);
1045  BCase(MICROMIPS);
1046  BCase(XPA);
1047  BCase(CRC);
1048  BCase(GINV);
1049 #undef BCase
1050 }
1051 
1053  IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
1054 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
1055  BCase(ODDSPREG);
1056 #undef BCase
1057 }
1058 
1060  IO &IO, ELFYAML::SectionHeader &SHdr) {
1061  IO.mapRequired("Name", SHdr.Name);
1062 }
1063 
1065  ELFYAML::FileHeader &FileHdr) {
1066  IO.mapRequired("Class", FileHdr.Class);
1067  IO.mapRequired("Data", FileHdr.Data);
1068  IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
1069  IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
1070  IO.mapRequired("Type", FileHdr.Type);
1071  IO.mapOptional("Machine", FileHdr.Machine);
1072  IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
1073  IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
1074  IO.mapOptional("SectionHeaderStringTable", FileHdr.SectionHeaderStringTable);
1075 
1076  // obj2yaml does not dump these fields.
1077  assert(!IO.outputting() ||
1078  (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum));
1079  IO.mapOptional("EPhOff", FileHdr.EPhOff);
1080  IO.mapOptional("EPhEntSize", FileHdr.EPhEntSize);
1081  IO.mapOptional("EPhNum", FileHdr.EPhNum);
1082  IO.mapOptional("EShEntSize", FileHdr.EShEntSize);
1083  IO.mapOptional("EShOff", FileHdr.EShOff);
1084  IO.mapOptional("EShNum", FileHdr.EShNum);
1085  IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
1086 }
1087 
1089  IO &IO, ELFYAML::ProgramHeader &Phdr) {
1090  IO.mapRequired("Type", Phdr.Type);
1091  IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
1092  IO.mapOptional("FirstSec", Phdr.FirstSec);
1093  IO.mapOptional("LastSec", Phdr.LastSec);
1094  IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
1095  IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
1096  IO.mapOptional("Align", Phdr.Align);
1097  IO.mapOptional("FileSize", Phdr.FileSize);
1098  IO.mapOptional("MemSize", Phdr.MemSize);
1099  IO.mapOptional("Offset", Phdr.Offset);
1100 }
1101 
1103  IO &IO, ELFYAML::ProgramHeader &FileHdr) {
1104  if (!FileHdr.FirstSec && FileHdr.LastSec)
1105  return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
1106  if (FileHdr.FirstSec && !FileHdr.LastSec)
1107  return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
1108  return "";
1109 }
1110 
1111 LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
1112 
1113 template <> struct ScalarTraits<StOtherPiece> {
1114  static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
1115  Out << Val;
1116  }
1117  static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
1118  Val = Scalar;
1119  return {};
1120  }
1121  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1122 };
1123 template <> struct SequenceElementTraits<StOtherPiece> {
1124  static const bool flow = true;
1125 };
1126 
1127 template <> struct ScalarTraits<ELFYAML::YAMLFlowString> {
1128  static void output(const ELFYAML::YAMLFlowString &Val, void *,
1129  raw_ostream &Out) {
1130  Out << Val;
1131  }
1132  static StringRef input(StringRef Scalar, void *,
1133  ELFYAML::YAMLFlowString &Val) {
1134  Val = Scalar;
1135  return {};
1136  }
1137  static QuotingType mustQuote(StringRef S) {
1138  return ScalarTraits<StringRef>::mustQuote(S);
1139  }
1140 };
1141 template <> struct SequenceElementTraits<ELFYAML::YAMLFlowString> {
1142  static const bool flow = true;
1143 };
1144 
1145 namespace {
1146 
1147 struct NormalizedOther {
1148  NormalizedOther(IO &IO) : YamlIO(IO) {}
1149  NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
1150  assert(Original && "This constructor is only used for outputting YAML and "
1151  "assumes a non-empty Original");
1152  std::vector<StOtherPiece> Ret;
1153  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
1154  for (std::pair<StringRef, uint8_t> &P :
1155  getFlags(Object->getMachine()).takeVector()) {
1156  uint8_t FlagValue = P.second;
1157  if ((*Original & FlagValue) != FlagValue)
1158  continue;
1159  *Original &= ~FlagValue;
1160  Ret.push_back({P.first});
1161  }
1162 
1163  if (*Original != 0) {
1164  UnknownFlagsHolder = std::to_string(*Original);
1165  Ret.push_back({UnknownFlagsHolder});
1166  }
1167 
1168  if (!Ret.empty())
1169  Other = std::move(Ret);
1170  }
1171 
1172  uint8_t toValue(StringRef Name) {
1173  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
1174  MapVector<StringRef, uint8_t> Flags = getFlags(Object->getMachine());
1175 
1176  auto It = Flags.find(Name);
1177  if (It != Flags.end())
1178  return It->second;
1179 
1180  uint8_t Val;
1181  if (to_integer(Name, Val))
1182  return Val;
1183 
1184  YamlIO.setError("an unknown value is used for symbol's 'Other' field: " +
1185  Name);
1186  return 0;
1187  }
1188 
1189  Optional<uint8_t> denormalize(IO &) {
1190  if (!Other)
1191  return None;
1192  uint8_t Ret = 0;
1193  for (StOtherPiece &Val : *Other)
1194  Ret |= toValue(Val);
1195  return Ret;
1196  }
1197 
1198  // st_other field is used to encode symbol visibility and platform-dependent
1199  // flags and values. This method returns a name to value map that is used for
1200  // parsing and encoding this field.
1201  MapVector<StringRef, uint8_t> getFlags(unsigned EMachine) {
1203  // STV_* values are just enumeration values. We add them in a reversed order
1204  // because when we convert the st_other to named constants when printing
1205  // YAML we want to use a maximum number of bits on each step:
1206  // when we have st_other == 3, we want to print it as STV_PROTECTED (3), but
1207  // not as STV_HIDDEN (2) + STV_INTERNAL (1).
1208  Map["STV_PROTECTED"] = ELF::STV_PROTECTED;
1209  Map["STV_HIDDEN"] = ELF::STV_HIDDEN;
1210  Map["STV_INTERNAL"] = ELF::STV_INTERNAL;
1211  // STV_DEFAULT is used to represent the default visibility and has a value
1212  // 0. We want to be able to read it from YAML documents, but there is no
1213  // reason to print it.
1214  if (!YamlIO.outputting())
1215  Map["STV_DEFAULT"] = ELF::STV_DEFAULT;
1216 
1217  // MIPS is not consistent. All of the STO_MIPS_* values are bit flags,
1218  // except STO_MIPS_MIPS16 which overlaps them. It should be checked and
1219  // consumed first when we print the output, because we do not want to print
1220  // any other flags that have the same bits instead.
1221  if (EMachine == ELF::EM_MIPS) {
1222  Map["STO_MIPS_MIPS16"] = ELF::STO_MIPS_MIPS16;
1223  Map["STO_MIPS_MICROMIPS"] = ELF::STO_MIPS_MICROMIPS;
1224  Map["STO_MIPS_PIC"] = ELF::STO_MIPS_PIC;
1225  Map["STO_MIPS_PLT"] = ELF::STO_MIPS_PLT;
1226  Map["STO_MIPS_OPTIONAL"] = ELF::STO_MIPS_OPTIONAL;
1227  }
1228 
1229  if (EMachine == ELF::EM_AARCH64)
1230  Map["STO_AARCH64_VARIANT_PCS"] = ELF::STO_AARCH64_VARIANT_PCS;
1231  if (EMachine == ELF::EM_RISCV)
1232  Map["STO_RISCV_VARIANT_CC"] = ELF::STO_RISCV_VARIANT_CC;
1233  return Map;
1234  }
1235 
1236  IO &YamlIO;
1237  Optional<std::vector<StOtherPiece>> Other;
1238  std::string UnknownFlagsHolder;
1239 };
1240 
1241 } // end anonymous namespace
1242 
1243 void ScalarTraits<ELFYAML::YAMLIntUInt>::output(const ELFYAML::YAMLIntUInt &Val,
1244  void *Ctx, raw_ostream &Out) {
1245  Out << Val;
1246 }
1247 
1249  ELFYAML::YAMLIntUInt &Val) {
1250  const bool Is64 = static_cast<ELFYAML::Object *>(Ctx)->Header.Class ==
1251  ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
1252  StringRef ErrMsg = "invalid number";
1253  // We do not accept negative hex numbers because their meaning is ambiguous.
1254  // For example, would -0xfffffffff mean 1 or INT32_MIN?
1255  if (Scalar.empty() || Scalar.startswith("-0x"))
1256  return ErrMsg;
1257 
1258  if (Scalar.startswith("-")) {
1259  const int64_t MinVal = Is64 ? INT64_MIN : INT32_MIN;
1260  long long Int;
1261  if (getAsSignedInteger(Scalar, /*Radix=*/0, Int) || (Int < MinVal))
1262  return ErrMsg;
1263  Val = Int;
1264  return "";
1265  }
1266 
1267  const uint64_t MaxVal = Is64 ? UINT64_MAX : UINT32_MAX;
1268  unsigned long long UInt;
1269  if (getAsUnsignedInteger(Scalar, /*Radix=*/0, UInt) || (UInt > MaxVal))
1270  return ErrMsg;
1271  Val = UInt;
1272  return "";
1273 }
1274 
1276  IO.mapOptional("Name", Symbol.Name, StringRef());
1277  IO.mapOptional("StName", Symbol.StName);
1278  IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
1279  IO.mapOptional("Section", Symbol.Section);
1280  IO.mapOptional("Index", Symbol.Index);
1281  IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
1282  IO.mapOptional("Value", Symbol.Value);
1283  IO.mapOptional("Size", Symbol.Size);
1284 
1285  // Symbol's Other field is a bit special. It is usually a field that
1286  // represents st_other and holds the symbol visibility. However, on some
1287  // platforms, it can contain bit fields and regular values, or even sometimes a
1288  // crazy mix of them (see comments for NormalizedOther). Because of this, we
1289  // need special handling.
1290  MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
1291  Symbol.Other);
1292  IO.mapOptional("Other", Keys->Other);
1293 }
1294 
1297  if (Symbol.Index && Symbol.Section)
1298  return "Index and Section cannot both be specified for Symbol";
1299  return "";
1300 }
1301 
1302 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
1303  IO.mapOptional("Name", Section.Name, StringRef());
1304  IO.mapRequired("Type", Section.Type);
1305  IO.mapOptional("Flags", Section.Flags);
1306  IO.mapOptional("Address", Section.Address);
1307  IO.mapOptional("Link", Section.Link);
1308  IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
1309  IO.mapOptional("EntSize", Section.EntSize);
1310  IO.mapOptional("Offset", Section.Offset);
1311 
1312  IO.mapOptional("Content", Section.Content);
1313  IO.mapOptional("Size", Section.Size);
1314 
1315  // obj2yaml does not dump these fields. They are expected to be empty when we
1316  // are producing YAML, because yaml2obj sets appropriate values for them
1317  // automatically when they are not explicitly defined.
1318  assert(!IO.outputting() ||
1319  (!Section.ShOffset && !Section.ShSize && !Section.ShName &&
1320  !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign));
1321  IO.mapOptional("ShAddrAlign", Section.ShAddrAlign);
1322  IO.mapOptional("ShName", Section.ShName);
1323  IO.mapOptional("ShOffset", Section.ShOffset);
1324  IO.mapOptional("ShSize", Section.ShSize);
1325  IO.mapOptional("ShFlags", Section.ShFlags);
1326  IO.mapOptional("ShType", Section.ShType);
1327 }
1328 
1329 static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
1330  commonSectionMapping(IO, Section);
1331  IO.mapOptional("Entries", Section.Entries);
1332 }
1333 
1334 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
1335  commonSectionMapping(IO, Section);
1336 
1337  // We also support reading a content as array of bytes using the ContentArray
1338  // key. obj2yaml never prints this field.
1339  assert(!IO.outputting() || !Section.ContentBuf);
1340  IO.mapOptional("ContentArray", Section.ContentBuf);
1341  if (Section.ContentBuf) {
1342  if (Section.Content)
1343  IO.setError("Content and ContentArray can't be used together");
1344  Section.Content = yaml::BinaryRef(*Section.ContentBuf);
1345  }
1346 
1347  IO.mapOptional("Info", Section.Info);
1348 }
1349 
1350 static void sectionMapping(IO &IO, ELFYAML::BBAddrMapSection &Section) {
1351  commonSectionMapping(IO, Section);
1352  IO.mapOptional("Content", Section.Content);
1353  IO.mapOptional("Entries", Section.Entries);
1354 }
1355 
1356 static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
1357  commonSectionMapping(IO, Section);
1358  IO.mapOptional("Entries", Section.Entries);
1359 }
1360 
1361 static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
1362  commonSectionMapping(IO, Section);
1363  IO.mapOptional("Bucket", Section.Bucket);
1364  IO.mapOptional("Chain", Section.Chain);
1365 
1366  // obj2yaml does not dump these fields. They can be used to override nchain
1367  // and nbucket values for creating broken sections.
1368  assert(!IO.outputting() || (!Section.NBucket && !Section.NChain));
1369  IO.mapOptional("NChain", Section.NChain);
1370  IO.mapOptional("NBucket", Section.NBucket);
1371 }
1372 
1373 static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
1374  commonSectionMapping(IO, Section);
1375  IO.mapOptional("Notes", Section.Notes);
1376 }
1377 
1378 
1379 static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
1380  commonSectionMapping(IO, Section);
1381  IO.mapOptional("Header", Section.Header);
1382  IO.mapOptional("BloomFilter", Section.BloomFilter);
1383  IO.mapOptional("HashBuckets", Section.HashBuckets);
1384  IO.mapOptional("HashValues", Section.HashValues);
1385 }
1386 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
1387  commonSectionMapping(IO, Section);
1388 }
1389 
1390 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
1391  commonSectionMapping(IO, Section);
1392  IO.mapOptional("Info", Section.Info);
1393  IO.mapOptional("Entries", Section.Entries);
1394 }
1395 
1396 static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
1397  commonSectionMapping(IO, Section);
1398  IO.mapOptional("Entries", Section.Entries);
1399 }
1400 
1401 static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
1402  commonSectionMapping(IO, Section);
1403  IO.mapOptional("Info", Section.Info);
1404  IO.mapOptional("Dependencies", Section.VerneedV);
1405 }
1406 
1407 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
1408  commonSectionMapping(IO, Section);
1409  IO.mapOptional("Info", Section.RelocatableSec, StringRef());
1410  IO.mapOptional("Relocations", Section.Relocations);
1411 }
1412 
1413 static void sectionMapping(IO &IO, ELFYAML::RelrSection &Section) {
1414  commonSectionMapping(IO, Section);
1415  IO.mapOptional("Entries", Section.Entries);
1416 }
1417 
1418 static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group) {
1419  commonSectionMapping(IO, Group);
1420  IO.mapOptional("Info", Group.Signature);
1421  IO.mapOptional("Members", Group.Members);
1422 }
1423 
1424 static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
1425  commonSectionMapping(IO, Section);
1426  IO.mapOptional("Entries", Section.Entries);
1427 }
1428 
1429 static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
1430  commonSectionMapping(IO, Section);
1431  IO.mapOptional("Symbols", Section.Symbols);
1432 }
1433 
1434 static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
1435  IO.mapOptional("Name", Fill.Name, StringRef());
1436  IO.mapOptional("Pattern", Fill.Pattern);
1437  IO.mapOptional("Offset", Fill.Offset);
1438  IO.mapRequired("Size", Fill.Size);
1439 }
1440 
1441 static void sectionHeaderTableMapping(IO &IO,
1443  IO.mapOptional("Offset", SHT.Offset);
1444  IO.mapOptional("Sections", SHT.Sections);
1445  IO.mapOptional("Excluded", SHT.Excluded);
1446  IO.mapOptional("NoHeaders", SHT.NoHeaders);
1447 }
1448 
1449 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
1450  commonSectionMapping(IO, Section);
1451  IO.mapOptional("Options", Section.Options);
1452 }
1453 
1454 static void sectionMapping(IO &IO,
1456  commonSectionMapping(IO, Section);
1457  IO.mapOptional("Libraries", Section.Libs);
1458 }
1459 
1460 static void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
1461  commonSectionMapping(IO, Section);
1462  IO.mapOptional("Entries", Section.Entries);
1463 }
1464 
1466  IO &IO, ELFYAML::SectionOrType &sectionOrType) {
1467  IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
1468 }
1469 
1470 static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
1471  commonSectionMapping(IO, Section);
1472  IO.mapOptional("Entries", Section.Entries);
1473 }
1474 
1475 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
1476  commonSectionMapping(IO, Section);
1477  IO.mapOptional("Version", Section.Version, Hex16(0));
1478  IO.mapRequired("ISA", Section.ISALevel);
1479  IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
1480  IO.mapOptional("ISAExtension", Section.ISAExtension,
1481  ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
1482  IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
1483  IO.mapOptional("FpABI", Section.FpABI,
1484  ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
1485  IO.mapOptional("GPRSize", Section.GPRSize,
1486  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1487  IO.mapOptional("CPR1Size", Section.CPR1Size,
1488  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1489  IO.mapOptional("CPR2Size", Section.CPR2Size,
1490  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
1491  IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
1492  IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
1493 }
1494 
1495 static StringRef getStringValue(IO &IO, const char *Key) {
1496  StringRef Val;
1497  IO.mapRequired(Key, Val);
1498  return Val;
1499 }
1500 
1501 static void setStringValue(IO &IO, const char *Key, StringRef Val) {
1502  IO.mapRequired(Key, Val);
1503 }
1504 
1505 static bool isInteger(StringRef Val) {
1506  APInt Tmp;
1507  return !Val.getAsInteger(0, Tmp);
1508 }
1509 
1511  IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
1512  ELFYAML::ELF_SHT Type;
1513  StringRef TypeStr;
1514  if (IO.outputting()) {
1515  if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))
1516  Type = S->Type;
1517  else if (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))
1518  TypeStr = SHT->TypeStr;
1519  } else {
1520  // When the Type string does not have a "SHT_" prefix, we know it is not a
1521  // description of a regular ELF output section.
1522  TypeStr = getStringValue(IO, "Type");
1523  if (TypeStr.startswith("SHT_") || isInteger(TypeStr))
1524  IO.mapRequired("Type", Type);
1525  }
1526 
1527  if (TypeStr == "Fill") {
1528  assert(!IO.outputting()); // We don't dump fills currently.
1529  Section.reset(new ELFYAML::Fill());
1530  fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
1531  return;
1532  }
1533 
1534  if (TypeStr == ELFYAML::SectionHeaderTable::TypeStr) {
1535  if (IO.outputting())
1536  setStringValue(IO, "Type", TypeStr);
1537  else
1538  Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));
1539 
1541  IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));
1542  return;
1543  }
1544 
1545  const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
1546  if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
1547  if (!IO.outputting())
1548  Section.reset(new ELFYAML::MipsABIFlags());
1549  sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
1550  return;
1551  }
1552 
1553  if (Obj.getMachine() == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX) {
1554  if (!IO.outputting())
1555  Section.reset(new ELFYAML::ARMIndexTableSection());
1556  sectionMapping(IO, *cast<ELFYAML::ARMIndexTableSection>(Section.get()));
1557  return;
1558  }
1559 
1560  switch (Type) {
1561  case ELF::SHT_DYNAMIC:
1562  if (!IO.outputting())
1563  Section.reset(new ELFYAML::DynamicSection());
1564  sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
1565  break;
1566  case ELF::SHT_REL:
1567  case ELF::SHT_RELA:
1568  if (!IO.outputting())
1569  Section.reset(new ELFYAML::RelocationSection());
1570  sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
1571  break;
1572  case ELF::SHT_RELR:
1573  if (!IO.outputting())
1574  Section.reset(new ELFYAML::RelrSection());
1575  sectionMapping(IO, *cast<ELFYAML::RelrSection>(Section.get()));
1576  break;
1577  case ELF::SHT_GROUP:
1578  if (!IO.outputting())
1579  Section.reset(new ELFYAML::GroupSection());
1580  groupSectionMapping(IO, *cast<ELFYAML::GroupSection>(Section.get()));
1581  break;
1582  case ELF::SHT_NOBITS:
1583  if (!IO.outputting())
1584  Section.reset(new ELFYAML::NoBitsSection());
1585  sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
1586  break;
1587  case ELF::SHT_HASH:
1588  if (!IO.outputting())
1589  Section.reset(new ELFYAML::HashSection());
1590  sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
1591  break;
1592  case ELF::SHT_NOTE:
1593  if (!IO.outputting())
1594  Section.reset(new ELFYAML::NoteSection());
1595  sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
1596  break;
1597  case ELF::SHT_GNU_HASH:
1598  if (!IO.outputting())
1599  Section.reset(new ELFYAML::GnuHashSection());
1600  sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
1601  break;
1602  case ELF::SHT_GNU_verdef:
1603  if (!IO.outputting())
1604  Section.reset(new ELFYAML::VerdefSection());
1605  sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
1606  break;
1607  case ELF::SHT_GNU_versym:
1608  if (!IO.outputting())
1609  Section.reset(new ELFYAML::SymverSection());
1610  sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
1611  break;
1612  case ELF::SHT_GNU_verneed:
1613  if (!IO.outputting())
1614  Section.reset(new ELFYAML::VerneedSection());
1615  sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
1616  break;
1617  case ELF::SHT_SYMTAB_SHNDX:
1618  if (!IO.outputting())
1619  Section.reset(new ELFYAML::SymtabShndxSection());
1620  sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
1621  break;
1622  case ELF::SHT_LLVM_ADDRSIG:
1623  if (!IO.outputting())
1624  Section.reset(new ELFYAML::AddrsigSection());
1625  sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
1626  break;
1628  if (!IO.outputting())
1629  Section.reset(new ELFYAML::LinkerOptionsSection());
1630  sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));
1631  break;
1633  if (!IO.outputting())
1634  Section.reset(new ELFYAML::DependentLibrariesSection());
1635  sectionMapping(IO,
1636  *cast<ELFYAML::DependentLibrariesSection>(Section.get()));
1637  break;
1639  if (!IO.outputting())
1640  Section.reset(new ELFYAML::CallGraphProfileSection());
1641  sectionMapping(IO, *cast<ELFYAML::CallGraphProfileSection>(Section.get()));
1642  break;
1645  if (!IO.outputting())
1646  Section.reset(new ELFYAML::BBAddrMapSection());
1647  sectionMapping(IO, *cast<ELFYAML::BBAddrMapSection>(Section.get()));
1648  break;
1649  default:
1650  if (!IO.outputting()) {
1651  StringRef Name;
1652  IO.mapOptional("Name", Name, StringRef());
1654 
1656  Section = std::make_unique<ELFYAML::StackSizesSection>();
1657  else
1658  Section = std::make_unique<ELFYAML::RawContentSection>();
1659  }
1660 
1661  if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
1662  sectionMapping(IO, *S);
1663  else
1664  sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
1665  }
1666 }
1667 
1669  IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
1670  if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
1671  if (F->Pattern && F->Pattern->binary_size() != 0 && !F->Size)
1672  return "\"Size\" can't be 0 when \"Pattern\" is not empty";
1673  return "";
1674  }
1675 
1676  if (const auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
1677  if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))
1678  return "NoHeaders can't be used together with Offset/Sections/Excluded";
1679  return "";
1680  }
1681 
1682  const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
1683  if (Sec.Size && Sec.Content &&
1684  (uint64_t)(*Sec.Size) < Sec.Content->binary_size())
1685  return "Section size must be greater than or equal to the content size";
1686 
1687  auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
1688  std::string Msg;
1689  for (size_t I = 0, E = EntV.size(); I != E; ++I) {
1690  StringRef Name = EntV[I].first;
1691  if (I == 0) {
1692  Msg = "\"" + Name.str() + "\"";
1693  continue;
1694  }
1695  if (I != EntV.size() - 1)
1696  Msg += ", \"" + Name.str() + "\"";
1697  else
1698  Msg += " and \"" + Name.str() + "\"";
1699  }
1700  return Msg;
1701  };
1702 
1703  std::vector<std::pair<StringRef, bool>> Entries = Sec.getEntries();
1704  const size_t NumUsedEntries = llvm::count_if(
1705  Entries, [](const std::pair<StringRef, bool> &P) { return P.second; });
1706 
1707  if ((Sec.Size || Sec.Content) && NumUsedEntries > 0)
1708  return BuildErrPrefix(Entries) +
1709  " cannot be used with \"Content\" or \"Size\"";
1710 
1711  if (NumUsedEntries > 0 && Entries.size() != NumUsedEntries)
1712  return BuildErrPrefix(Entries) + " must be used together";
1713 
1714  if (const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(C.get())) {
1715  if (RawSection->Flags && RawSection->ShFlags)
1716  return "ShFlags and Flags cannot be used together";
1717  return "";
1718  }
1719 
1720  if (const auto *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {
1721  if (NB->Content)
1722  return "SHT_NOBITS section cannot have \"Content\"";
1723  return "";
1724  }
1725 
1726  if (const auto *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {
1727  if (MF->Content)
1728  return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
1729  "sections";
1730  if (MF->Size)
1731  return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
1732  return "";
1733  }
1734 
1735  return "";
1736 }
1737 
1738 namespace {
1739 
1740 struct NormalizedMips64RelType {
1741  NormalizedMips64RelType(IO &)
1742  : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1743  Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1744  Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1745  SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
1746  NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
1747  : Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
1748  Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
1749 
1750  ELFYAML::ELF_REL denormalize(IO &) {
1751  ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
1752  return Res;
1753  }
1754 
1755  ELFYAML::ELF_REL Type;
1756  ELFYAML::ELF_REL Type2;
1757  ELFYAML::ELF_REL Type3;
1758  ELFYAML::ELF_RSS SpecSym;
1759 };
1760 
1761 } // end anonymous namespace
1762 
1764  IO &IO, ELFYAML::StackSizeEntry &E) {
1765  assert(IO.getContext() && "The IO context is not initialized");
1766  IO.mapOptional("Address", E.Address, Hex64(0));
1767  IO.mapRequired("Size", E.Size);
1768 }
1769 
1771  IO &IO, ELFYAML::BBAddrMapEntry &E) {
1772  assert(IO.getContext() && "The IO context is not initialized");
1773  IO.mapRequired("Version", E.Version);
1774  IO.mapOptional("Feature", E.Feature, Hex8(0));
1775  IO.mapOptional("Address", E.Address, Hex64(0));
1776  IO.mapOptional("NumBlocks", E.NumBlocks);
1777  IO.mapOptional("BBEntries", E.BBEntries);
1778 }
1779 
1782  assert(IO.getContext() && "The IO context is not initialized");
1783  IO.mapRequired("AddressOffset", E.AddressOffset);
1784  IO.mapRequired("Size", E.Size);
1785  IO.mapRequired("Metadata", E.Metadata);
1786 }
1787 
1790  assert(IO.getContext() && "The IO context is not initialized");
1791  IO.mapOptional("NBuckets", E.NBuckets);
1792  IO.mapRequired("SymNdx", E.SymNdx);
1793  IO.mapOptional("MaskWords", E.MaskWords);
1794  IO.mapRequired("Shift2", E.Shift2);
1795 }
1796 
1798  ELFYAML::DynamicEntry &Rel) {
1799  assert(IO.getContext() && "The IO context is not initialized");
1800 
1801  IO.mapRequired("Tag", Rel.Tag);
1802  IO.mapRequired("Value", Rel.Val);
1803 }
1804 
1806  assert(IO.getContext() && "The IO context is not initialized");
1807 
1808  IO.mapOptional("Name", N.Name);
1809  IO.mapOptional("Desc", N.Desc);
1810  IO.mapRequired("Type", N.Type);
1811 }
1812 
1815  assert(IO.getContext() && "The IO context is not initialized");
1816 
1817  IO.mapOptional("Version", E.Version);
1818  IO.mapOptional("Flags", E.Flags);
1819  IO.mapOptional("VersionNdx", E.VersionNdx);
1820  IO.mapOptional("Hash", E.Hash);
1821  IO.mapRequired("Names", E.VerNames);
1822 }
1823 
1826  assert(IO.getContext() && "The IO context is not initialized");
1827 
1828  IO.mapRequired("Version", E.Version);
1829  IO.mapRequired("File", E.File);
1830  IO.mapRequired("Entries", E.AuxV);
1831 }
1832 
1835  assert(IO.getContext() && "The IO context is not initialized");
1836 
1837  IO.mapRequired("Name", E.Name);
1838  IO.mapRequired("Hash", E.Hash);
1839  IO.mapRequired("Flags", E.Flags);
1840  IO.mapRequired("Other", E.Other);
1841 }
1842 
1844  ELFYAML::Relocation &Rel) {
1845  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
1846  assert(Object && "The IO context is not initialized");
1847 
1848  IO.mapOptional("Offset", Rel.Offset, (Hex64)0);
1849  IO.mapOptional("Symbol", Rel.Symbol);
1850 
1851  if (Object->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
1852  Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
1853  MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
1854  IO, Rel.Type);
1855  IO.mapRequired("Type", Key->Type);
1856  IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1857  IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1858  IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
1859  } else
1860  IO.mapRequired("Type", Rel.Type);
1861 
1862  IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);
1863 }
1864 
1866  IO &IO, ELFYAML::ARMIndexTableEntry &E) {
1867  assert(IO.getContext() && "The IO context is not initialized");
1868  IO.mapRequired("Offset", E.Offset);
1869 
1870  StringRef CantUnwind = "EXIDX_CANTUNWIND";
1871  if (IO.outputting() && (uint32_t)E.Value == ARM::EHABI::EXIDX_CANTUNWIND)
1872  IO.mapRequired("Value", CantUnwind);
1873  else if (!IO.outputting() && getStringValue(IO, "Value") == CantUnwind)
1875  else
1876  IO.mapRequired("Value", E.Value);
1877 }
1878 
1880  assert(!IO.getContext() && "The IO context is initialized already");
1881  IO.setContext(&Object);
1882  IO.mapTag("!ELF", true);
1883  IO.mapRequired("FileHeader", Object.Header);
1884  IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
1885  IO.mapOptional("Sections", Object.Chunks);
1886  IO.mapOptional("Symbols", Object.Symbols);
1887  IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
1888  IO.mapOptional("DWARF", Object.DWARF);
1889  if (Object.DWARF) {
1890  Object.DWARF->IsLittleEndian =
1891  Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
1892  Object.DWARF->Is64BitAddrSize =
1893  Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
1894  }
1895  IO.setContext(nullptr);
1896 }
1897 
1899  ELFYAML::LinkerOption &Opt) {
1900  assert(IO.getContext() && "The IO context is not initialized");
1901  IO.mapRequired("Name", Opt.Key);
1902  IO.mapRequired("Value", Opt.Value);
1903 }
1904 
1906  IO &IO, ELFYAML::CallGraphEntryWeight &E) {
1907  assert(IO.getContext() && "The IO context is not initialized");
1908  IO.mapRequired("Weight", E.Weight);
1909 }
1910 
1911 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
1912 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
1913 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
1914 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
1915 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
1916 
1917 } // end namespace yaml
1918 
1919 } // end namespace llvm
llvm::ELF::EF_AMDGPU_MACH_R600_SUMO
@ EF_AMDGPU_MACH_R600_SUMO
Definition: ELF.h:718
llvm::ELF::SHT_HEX_ORDERED
@ SHT_HEX_ORDERED
Definition: ELF.h:1012
llvm::ELF::EF_AMDGPU_MACH
@ EF_AMDGPU_MACH
Definition: ELF.h:697
llvm::ELFYAML::Relocation::Symbol
Optional< StringRef > Symbol
Definition: ELFYAML.h:592
llvm::ELF::EM_MMDSP_PLUS
@ EM_MMDSP_PLUS
Definition: ELF.h:253
llvm::ELF::EM_RX
@ EM_RX
Definition: ELF.h:269
llvm::ELF::STT_FUNC
@ STT_FUNC
Definition: ELF.h:1205
llvm::ELF::EM_V800
@ EM_V800
Definition: ELF.h:152
llvm::ELF::NT_FREEBSD_PROCSTAT_PROC
@ NT_FREEBSD_PROCSTAT_PROC
Definition: ELF.h:1669
llvm::ELF::SHF_HEX_GPREL
@ SHF_HEX_GPREL
Definition: ELF.h:1105
llvm::ELF::EF_HEXAGON_MACH_V3
@ EF_HEXAGON_MACH_V3
Definition: ELF.h:610
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:290
llvm::ELF::NT_FREEBSD_PROCSTAT_RLIMIT
@ NT_FREEBSD_PROCSTAT_RLIMIT
Definition: ELF.h:1674
ARMEHABI.h
llvm::ELF::EF_AVR_ARCH_XMEGA2
@ EF_AVR_ARCH_XMEGA2
Definition: ELF.h:487
llvm::ELF::EM_PDSP
@ EM_PDSP
Definition: ELF.h:179
llvm::ELF::EF_MIPS_ARCH_2
@ EF_MIPS_ARCH_2
Definition: ELF.h:554
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031
@ EF_AMDGPU_MACH_AMDGCN_GFX1031
Definition: ELF.h:757
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_DYNTAG >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value)
Definition: ELFYAML.cpp:894
llvm::ELF::EF_HEXAGON_ISA_V65
@ EF_HEXAGON_ISA_V65
Definition: ELF.h:634
llvm::ELF::NT_TASKSTRUCT
@ NT_TASKSTRUCT
Definition: ELF.h:1510
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::ELFYAML::NoteSection
Definition: ELFYAML.h:379
llvm::ELF::SHT_ANDROID_REL
@ SHT_ANDROID_REL
Definition: ELF.h:977
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030
@ EF_AMDGPU_MACH_AMDGCN_GFX1030
Definition: ELF.h:756
llvm::ELFYAML::SectionHeaderTable::Sections
Optional< std::vector< SectionHeader > > Sections
Definition: ELFYAML.h:299
llvm::yaml::getStringValue
static StringRef getStringValue(IO &IO, const char *Key)
Definition: ELFYAML.cpp:1495
llvm::ELF::SHF_MIPS_STRING
@ SHF_MIPS_STRING
Definition: ELF.h:1130
llvm::ELF::ELFOSABI_LINUX
@ ELFOSABI_LINUX
Definition: ELF.h:345
llvm::ELF::EM_L10M
@ EM_L10M
Definition: ELF.h:278
llvm::ELF::ELFOSABI_AMDGPU_PAL
@ ELFOSABI_AMDGPU_PAL
Definition: ELF.h:361
llvm::ELF::NT_PPC_VMX
@ NT_PPC_VMX
Definition: ELF.h:1519
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_EF >::bitset
static void bitset(IO &IO, ELFYAML::ELF_EF &Value)
Definition: ELFYAML.cpp:411
llvm::ELF::EF_HEXAGON_MACH_V65
@ EF_HEXAGON_MACH_V65
Definition: ELF.h:616
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition: ELF.h:1035
llvm::yaml::fillMapping
static void fillMapping(IO &IO, ELFYAML::Fill &Fill)
Definition: ELFYAML.cpp:1434
llvm::ELF::EM_MCST_ELBRUS
@ EM_MCST_ELBRUS
Definition: ELF.h:272
llvm::ELF::NT_S390_TODPREG
@ NT_S390_TODPREG
Definition: ELF.h:1542
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036
@ EF_AMDGPU_MACH_AMDGCN_GFX1036
Definition: ELF.h:771
llvm::ELF::EM_DSP24
@ EM_DSP24
Definition: ELF.h:246
llvm::ELF::SHN_MIPS_ACOMMON
@ SHN_MIPS_ACOMMON
Definition: ELF.h:569
llvm::ELF::EF_ARM_EABI_UNKNOWN
@ EF_ARM_EABI_UNKNOWN
Definition: ELF.h:438
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX703
@ EF_AMDGPU_MACH_AMDGCN_GFX703
Definition: ELF.h:739
llvm::ELF::EF_ARM_EABIMASK
@ EF_ARM_EABIMASK
Definition: ELF.h:444
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4
@ EF_AMDGPU_FEATURE_XNACK_ANY_V4
Definition: ELF.h:808
llvm::ELF::NT_WIN32PSTATUS
@ NT_WIN32PSTATUS
Definition: ELF.h:1517
llvm::ELFYAML::Fill
Definition: ELFYAML.h:282
llvm::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:1047
llvm::ELF::EF_AVR_ARCH_XMEGA4
@ EF_AVR_ARCH_XMEGA4
Definition: ELF.h:489
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:996
llvm::ELF::NT_PSTATUS
@ NT_PSTATUS
Definition: ELF.h:1512
llvm::ELF::EF_AMDGPU_MACH_R600_RV730
@ EF_AMDGPU_MACH_R600_RV730
Definition: ELF.h:711
llvm::ELF::NT_PPC_TM_CGPR
@ NT_PPC_TM_CGPR
Definition: ELF.h:1526
llvm::ELF::EF_MIPS_ARCH_1
@ EF_MIPS_ARCH_1
Definition: ELF.h:553
llvm::ELF::NT_AMD_HSA_ISA_VERSION
@ NT_AMD_HSA_ISA_VERSION
Definition: ELF.h:1706
llvm::ELF::EF_MIPS_ARCH_5
@ EF_MIPS_ARCH_5
Definition: ELF.h:557
llvm::ELF::EM_M32R
@ EM_M32R
Definition: ELF.h:204
llvm::ELFYAML::FileHeader::EShOff
Optional< llvm::yaml::Hex64 > EShOff
Definition: ELFYAML.h:127
llvm::ELF::NT_ANDROID_TYPE_MEMTAG
@ NT_ANDROID_TYPE_MEMTAG
Definition: ELF.h:1583
llvm::ELF::NT_GNU_GOLD_VERSION
@ NT_GNU_GOLD_VERSION
Definition: ELF.h:1575
llvm::ELF::EF_AVR_LINKRELAX_PREPARED
@ EF_AVR_LINKRELAX_PREPARED
Definition: ELF.h:496
llvm::ELF::NT_FREEBSD_PROCSTAT_OSREL
@ NT_FREEBSD_PROCSTAT_OSREL
Definition: ELF.h:1675
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX601
@ EF_AMDGPU_MACH_AMDGCN_GFX601
Definition: ELF.h:735
llvm::ELF::SHT_ARM_DEBUGOVERLAY
@ SHT_ARM_DEBUGOVERLAY
Definition: ELF.h:1010
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011
@ EF_AMDGPU_MACH_AMDGCN_GFX1011
Definition: ELF.h:754
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::ELF::EM_H8_300H
@ EM_H8_300H
Definition: ELF.h:163
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C
@ EF_AMDGPU_MACH_AMDGCN_GFX90C
Definition: ELF.h:752
llvm::ELFYAML::Relocation::Offset
llvm::yaml::Hex64 Offset
Definition: ELFYAML.h:589
Type2
ELFYAML::ELF_REL Type2
Definition: ELFYAML.cpp:1756
llvm::ELF::SHT_PREINIT_ARRAY
@ SHT_PREINIT_ARRAY
Definition: ELF.h:968
llvm::ELF::NT_AMD_PAL_METADATA
@ NT_AMD_PAL_METADATA
Definition: ELF.h:1710
llvm::ELF::EM_MICROBLAZE
@ EM_MICROBLAZE
Definition: ELF.h:285
llvm::ELF::EF_MIPS_MACH_4111
@ EF_MIPS_MACH_4111
Definition: ELF.h:531
llvm::ELFYAML::CallGraphProfileSection
Definition: ELFYAML.h:526
llvm::ELF::ELFOSABI_AMDGPU_MESA3D
@ ELFOSABI_AMDGPU_MESA3D
Definition: ELF.h:362
llvm::ELFYAML::FileHeader::Type
ELF_ET Type
Definition: ELFYAML.h:117
llvm::yaml::ScalarTraits< StOtherPiece >::input
static StringRef input(StringRef Scalar, void *, StOtherPiece &Val)
Definition: ELFYAML.cpp:1117
llvm::ELF::EM_SNP1K
@ EM_SNP1K
Definition: ELF.h:216
llvm::ELFYAML::LinkerOption
Definition: ELFYAML.h:487
output
Current output
Definition: README.txt:1350
llvm::ELF::NT_GNU_BUILD_ID
@ NT_GNU_BUILD_ID
Definition: ELF.h:1574
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013
@ EF_AMDGPU_MACH_AMDGCN_GFX1013
Definition: ELF.h:768
llvm::ELF::EF_AVR_ARCH_XMEGA6
@ EF_AVR_ARCH_XMEGA6
Definition: ELF.h:491
llvm::ELFYAML::VerdefEntry
Definition: ELFYAML.h:552
llvm::ELF::EF_ARM_EABI_VER5
@ EF_ARM_EABI_VER5
Definition: ELF.h:443
llvm::ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC
@ NT_GNU_BUILD_ATTRIBUTE_FUNC
Definition: ELF.h:1502
llvm::ELF::SHN_HEXAGON_SCOMMON
@ SHN_HEXAGON_SCOMMON
Definition: ELF.h:644
ErrorHandling.h
llvm::ELF::SHN_LOPROC
@ SHN_LOPROC
Definition: ELF.h:942
llvm::ELFYAML::GroupSection
Definition: ELFYAML.h:573
llvm::ELF::EF_HEXAGON_MACH_V69
@ EF_HEXAGON_MACH_V69
Definition: ELF.h:621
llvm::ELF::EF_MIPS_ARCH_4
@ EF_MIPS_ARCH_4
Definition: ELF.h:556
llvm::ELFYAML::FileHeader
Definition: ELFYAML.h:112
MapVector.h
llvm::ELF::EM_HEXAGON
@ EM_HEXAGON
Definition: ELF.h:257
llvm::ELF::EM_R32C
@ EM_R32C
Definition: ELF.h:255
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
@ EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
Definition: ELF.h:823
llvm::ELF::EM_LOONGARCH
@ EM_LOONGARCH
Definition: ELF.h:322
llvm::ELFYAML::NoBitsSection
Definition: ELFYAML.h:373
llvm::ELF::STT_GNU_IFUNC
@ STT_GNU_IFUNC
Definition: ELF.h:1210
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103
@ EF_AMDGPU_MACH_AMDGCN_GFX1103
Definition: ELF.h:770
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100
@ EF_AMDGPU_MACH_AMDGCN_GFX1100
Definition: ELF.h:767
llvm::ELF::EF_HEXAGON_ISA_V5
@ EF_HEXAGON_ISA_V5
Definition: ELF.h:630
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX805
@ EF_AMDGPU_MACH_AMDGCN_GFX805
Definition: ELF.h:762
llvm::ELF::PT_GNU_STACK
@ PT_GNU_STACK
Definition: ELF.h:1355
llvm::ELF::EM_RCE
@ EM_RCE
Definition: ELF.h:155
llvm::ELF::EF_HEXAGON_MACH_V55
@ EF_HEXAGON_MACH_V55
Definition: ELF.h:613
llvm::ELF::SHT_GNU_versym
@ SHT_GNU_versym
Definition: ELF.h:1000
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1063
llvm::ELF::NT_ARM_HW_WATCH
@ NT_ARM_HW_WATCH
Definition: ELF.h:1556
llvm::ELF::EM_ST9PLUS
@ EM_ST9PLUS
Definition: ELF.h:183
llvm::ELF::SHN_LOOS
@ SHN_LOOS
Definition: ELF.h:944
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX602
@ EF_AMDGPU_MACH_AMDGCN_GFX602
Definition: ELF.h:760
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_ISA >::enumeration
static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value)
Definition: ELFYAML.cpp:1019
llvm::ELFYAML::ProgramHeader
Definition: ELFYAML.h:678
llvm::ELF::RSS_GP
@ RSS_GP
Definition: ELF.h:1233
llvm::ELF::EM_LANAI
@ EM_LANAI
Definition: ELF.h:318
llvm::ELF::SHT_SYMTAB_SHNDX
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:970
BCase
#define BCase(X)
llvm::ELFYAML::Chunk::~Chunk
virtual ~Chunk()
APInt.h
llvm::ELF::EM_MMIX
@ EM_MMIX
Definition: ELF.h:196
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:957
llvm::ELF::EM_TI_C5500
@ EM_TI_C5500
Definition: ELF.h:252
llvm::ELF::STO_MIPS_PLT
@ STO_MIPS_PLT
Definition: ELF.h:584
llvm::Mips::AFL_EXT_NONE
@ AFL_EXT_NONE
Definition: MipsABIFlags.h:51
llvm::ELF::EM_NONE
@ EM_NONE
Definition: ELF.h:133
llvm::ELF::EF_MIPS_32BITMODE
@ EF_MIPS_32BITMODE
Definition: ELF.h:511
llvm::ELFYAML::FileHeader::EPhOff
Optional< llvm::yaml::Hex64 > EPhOff
Definition: ELFYAML.h:123
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_STT >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_STT &Value)
Definition: ELFYAML.cpp:802
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::ELF::ET_CORE
@ ET_CORE
Definition: ELF.h:119
llvm::ELF::SHN_HIPROC
@ SHN_HIPROC
Definition: ELF.h:943
llvm::ELF::PT_GNU_PROPERTY
@ PT_GNU_PROPERTY
Definition: ELF.h:1357
llvm::ELF::SHT_MIPS_DWARF
@ SHT_MIPS_DWARF
Definition: ELF.h:1018
llvm::ELF::NT_FREEBSD_PROCSTAT_GROUPS
@ NT_FREEBSD_PROCSTAT_GROUPS
Definition: ELF.h:1672
llvm::ELFYAML::Chunk::Offset
Optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:214
llvm::ELF::SHN_HEXAGON_SCOMMON_1
@ SHN_HEXAGON_SCOMMON_1
Definition: ELF.h:645
llvm::ELF::EF_HEXAGON_ISA_V62
@ EF_HEXAGON_ISA_V62
Definition: ELF.h:633
llvm::ELF::EM_SPARCV9
@ EM_SPARCV9
Definition: ELF.h:159
llvm::ELFYAML::FileHeader::Machine
Optional< ELF_EM > Machine
Definition: ELFYAML.h:118
llvm::ELF::EF_MIPS_PIC
@ EF_MIPS_PIC
Definition: ELF.h:508
YamlIO
IO & YamlIO
Definition: ELFYAML.cpp:1236
llvm::ELF::EM_CUDA
@ EM_CUDA
Definition: ELF.h:286
llvm::ELF::EF_HEXAGON_ISA_V4
@ EF_HEXAGON_ISA_V4
Definition: ELF.h:629
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_SHN >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value)
Definition: ELFYAML.cpp:757
llvm::Optional< uint8_t >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_PT >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_PT &Value)
Definition: ELFYAML.cpp:57
llvm::ELFYAML::AddrsigSection
Definition: ELFYAML.h:475
llvm::ELF::NT_FREEBSD_THRMISC
@ NT_FREEBSD_THRMISC
Definition: ELF.h:1668
llvm::ELF::EF_MIPS_MACH_5400
@ EF_MIPS_MACH_5400
Definition: ELF.h:537
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
llvm::ELF::ET_NONE
@ ET_NONE
Definition: ELF.h:115
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX802
@ EF_AMDGPU_MACH_AMDGCN_GFX802
Definition: ELF.h:743
llvm::ELF::EF_HEXAGON_MACH
@ EF_HEXAGON_MACH
Definition: ELF.h:622
llvm::ELFYAML::Fill::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:284
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1038
llvm::ELFYAML::SectionHeader::Name
StringRef Name
Definition: ELFYAML.h:133
llvm::ELF::EF_MIPS_ABI_O64
@ EF_MIPS_ABI_O64
Definition: ELF.h:519
llvm::ELF::EM_AVR
@ EM_AVR
Definition: ELF.h:199
llvm::ELF::NT_S390_PREFIX
@ NT_S390_PREFIX
Definition: ELF.h:1544
llvm::ELF::STT_TLS
@ STT_TLS
Definition: ELF.h:1209
llvm::ELF::EF_ARM_EABI_VER3
@ EF_ARM_EABI_VER3
Definition: ELF.h:441
llvm::ELF::EF_AMDGPU_MACH_R600_RS880
@ EF_AMDGPU_MACH_R600_RS880
Definition: ELF.h:707
llvm::ELFYAML::FileHeader::EShNum
Optional< llvm::yaml::Hex16 > EShNum
Definition: ELFYAML.h:128
llvm::ELF::EM_NS32K
@ EM_NS32K
Definition: ELF.h:214
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:119
llvm::ELFYAML::Object::getOSAbi
ELF_ELFOSABI getOSAbi() const
Definition: ELFYAML.cpp:32
llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY
@ Val_GNU_MIPS_ABI_FP_ANY
Definition: MipsABIFlags.h:85
llvm::ELF::NT_FREEBSD_NOINIT_TAG
@ NT_FREEBSD_NOINIT_TAG
Definition: ELF.h:1651
llvm::ELF::EM_SEP
@ EM_SEP
Definition: ELF.h:225
llvm::yaml::MappingTraits
Definition: ModuleSummaryIndex.h:51
llvm::RISCVFeatures::validate
void validate(const Triple &TT, const FeatureBitset &FeatureBits)
Definition: RISCVBaseInfo.cpp:97
llvm::ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN
@ NT_GNU_BUILD_ATTRIBUTE_OPEN
Definition: ELF.h:1501
llvm::ELFYAML::RawContentSection
Definition: ELFYAML.h:360
llvm::ELF::EF_AMDGPU_MACH_R600_RV710
@ EF_AMDGPU_MACH_R600_RV710
Definition: ELF.h:710
llvm::ELF::EF_MIPS_MACH_4100
@ EF_MIPS_MACH_4100
Definition: ELF.h:528
llvm::ELFYAML::FileHeader::SectionHeaderStringTable
Optional< StringRef > SectionHeaderStringTable
Definition: ELFYAML.h:121
llvm::ELF::EM_VAX
@ EM_VAX
Definition: ELF.h:191
llvm::ELF::SHN_MIPS_SUNDEFINED
@ SHN_MIPS_SUNDEFINED
Definition: ELF.h:573
llvm::ELF::EM_TSK3000
@ EM_TSK3000
Definition: ELF.h:240
llvm::ELF::SHT_FINI_ARRAY
@ SHT_FINI_ARRAY
Definition: ELF.h:967
llvm::ELF::NT_AMD_HSA_METADATA
@ NT_AMD_HSA_METADATA
Definition: ELF.h:1708
llvm::ELF::ELFOSABI_HPUX
@ ELFOSABI_HPUX
Definition: ELF.h:342
llvm::ELF::ELFOSABI_ARM
@ ELFOSABI_ARM
Definition: ELF.h:363
llvm::ELF::SHT_LLVM_DEPENDENT_LIBRARIES
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition: ELF.h:983
llvm::count_if
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
Definition: STLExtras.h:1716
llvm::ELF::EF_MIPS_ARCH_ASE_MDMX
@ EF_MIPS_ARCH_ASE_MDMX
Definition: ELF.h:549
llvm::ELF::EM_CE
@ EM_CE
Definition: ELF.h:238
llvm::ELF::ELFOSABI_OPENVMS
@ ELFOSABI_OPENVMS
Definition: ELF.h:354
llvm::ELF::NT_PPC_TM_CPPR
@ NT_PPC_TM_CPPR
Definition: ELF.h:1532
llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::output
static void output(const ELFYAML::YAMLFlowString &Val, void *, raw_ostream &Out)
Definition: ELFYAML.cpp:1128
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX908
@ EF_AMDGPU_MACH_AMDGCN_GFX908
Definition: ELF.h:750
llvm::ELF::SHN_HEXAGON_SCOMMON_4
@ SHN_HEXAGON_SCOMMON_4
Definition: ELF.h:647
llvm::ELF::EF_MIPS_ABI_O32
@ EF_MIPS_ABI_O32
Definition: ELF.h:518
llvm::ELF::NT_PSINFO
@ NT_PSINFO
Definition: ELF.h:1514
llvm::ELF::NT_SIGINFO
@ NT_SIGINFO
Definition: ELF.h:1562
llvm::ELF::EM_ST100
@ EM_ST100
Definition: ELF.h:176
llvm::ELF::ELFOSABI_NSK
@ ELFOSABI_NSK
Definition: ELF.h:355
llvm::ELFYAML::SectionHeader
Definition: ELFYAML.h:132
llvm::ELF::EM_COREA_1ST
@ EM_COREA_1ST
Definition: ELF.h:289
llvm::ELF::SHN_COMMON
@ SHN_COMMON
Definition: ELF.h:947
llvm::ELF::EM_CRX
@ EM_CRX
Definition: ELF.h:232
llvm::ELF::EF_AVR_ARCH_AVR51
@ EF_AVR_ARCH_AVR51
Definition: ELF.h:483
llvm::ELF::SHF_INFO_LINK
@ SHF_INFO_LINK
Definition: ELF.h:1050
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::ELF::ELFOSABI_AIX
@ ELFOSABI_AIX
Definition: ELF.h:348
llvm::ELF::EM_SCORE7
@ EM_SCORE7
Definition: ELF.h:245
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
@ EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
Definition: ELF.h:819
llvm::ELF::EM_78KOR
@ EM_78KOR
Definition: ELF.h:295
llvm::ELF::EF_MIPS_MACH_4650
@ EF_MIPS_MACH_4650
Definition: ELF.h:529
llvm::yaml::sectionHeaderTableMapping
static void sectionHeaderTableMapping(IO &IO, ELFYAML::SectionHeaderTable &SHT)
Definition: ELFYAML.cpp:1441
llvm::yaml::isInteger
static bool isInteger(StringRef Val)
Definition: ELFYAML.cpp:1505
llvm::ELF::SHF_COMPRESSED
@ SHF_COMPRESSED
Definition: ELF.h:1066
llvm::ELF::EM_960
@ EM_960
Definition: ELF.h:147
llvm::ELF::EM_RH32
@ EM_RH32
Definition: ELF.h:154
llvm::ELF::EM_SPU
@ EM_SPU
Definition: ELF.h:151
llvm::ELF::NT_S390_SYSTEM_CALL
@ NT_S390_SYSTEM_CALL
Definition: ELF.h:1546
llvm::ELF::EF_HEXAGON_ISA_V2
@ EF_HEXAGON_ISA_V2
Definition: ELF.h:627
llvm::ELF::SHT_ANDROID_RELR
@ SHT_ANDROID_RELR
Definition: ELF.h:995
llvm::ELF::EM_ST19
@ EM_ST19
Definition: ELF.h:190
llvm::ELF::NT_FREEBSD_ARCH_TAG
@ NT_FREEBSD_ARCH_TAG
Definition: ELF.h:1652
llvm::ELF::PF_X
@ PF_X
Definition: ELF.h:1381
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX900
@ EF_AMDGPU_MACH_AMDGCN_GFX900
Definition: ELF.h:746
llvm::ELF::EM_C166
@ EM_C166
Definition: ELF.h:234
llvm::ELF::EF_RISCV_FLOAT_ABI_SOFT
@ EF_RISCV_FLOAT_ABI_SOFT
Definition: ELF.h:665
llvm::ELF::EM_S370
@ EM_S370
Definition: ELF.h:142
llvm::ELF::EF_ARM_VFP_FLOAT
@ EF_ARM_VFP_FLOAT
Definition: ELF.h:436
llvm::ELF::SHT_LLVM_PART_EHDR
@ SHT_LLVM_PART_EHDR
Definition: ELF.h:986
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFOSABI >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value)
Definition: ELFYAML.cpp:379
llvm::ELF::ELFOSABI_NONE
@ ELFOSABI_NONE
Definition: ELF.h:341
llvm::ELF::STO_AARCH64_VARIANT_PCS
@ STO_AARCH64_VARIANT_PCS
Definition: ELF.h:429
llvm::ELF::EM_68K
@ EM_68K
Definition: ELF.h:137
llvm::ELF::NT_PPC_DSCR
@ NT_PPC_DSCR
Definition: ELF.h:1523
llvm::ELF::EF_HEXAGON_ISA_V67
@ EF_HEXAGON_ISA_V67
Definition: ELF.h:636
llvm::ELF::NT_PPC_TM_SPR
@ NT_PPC_TM_SPR
Definition: ELF.h:1530
llvm::ELF::NT_ARM_PAC_MASK
@ NT_ARM_PAC_MASK
Definition: ELF.h:1558
llvm::ELF::EM_860
@ EM_860
Definition: ELF.h:140
llvm::ELF::NT_PPC_VSX
@ NT_PPC_VSX
Definition: ELF.h:1520
ELF.h
llvm::ELF::EM_ARM
@ EM_ARM
Definition: ELF.h:156
llvm::ELF::NT_GNU_PROPERTY_TYPE_0
@ NT_GNU_PROPERTY_TYPE_0
Definition: ELF.h:1576
llvm::ELF::EM_XTENSA
@ EM_XTENSA
Definition: ELF.h:211
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:991
llvm::ELF::ELFOSABI_OPENBSD
@ ELFOSABI_OPENBSD
Definition: ELF.h:353
llvm::ELF::EM_RS08
@ EM_RS08
Definition: ELF.h:241
llvm::ELF::SHF_MIPS_ADDR
@ SHF_MIPS_ADDR
Definition: ELF.h:1127
llvm::ELF::NT_ARM_TLS
@ NT_ARM_TLS
Definition: ELF.h:1554
llvm::ELFYAML::Relocation
Definition: ELFYAML.h:588
UnknownFlagsHolder
std::string UnknownFlagsHolder
Definition: ELFYAML.cpp:1238
llvm::ELF::NT_ARM_VFP
@ NT_ARM_VFP
Definition: ELF.h:1553
llvm::ELF::EM_LATTICEMICO32
@ EM_LATTICEMICO32
Definition: ELF.h:248
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ELF::NT_LWPSTATUS
@ NT_LWPSTATUS
Definition: ELF.h:1515
llvm::ELF::SHT_HASH
@ SHT_HASH
Definition: ELF.h:959
llvm::ELF::EF_AVR_ARCH_XMEGA3
@ EF_AVR_ARCH_XMEGA3
Definition: ELF.h:488
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1192
llvm::ELF::EF_MIPS_MACH_LS2E
@ EF_MIPS_MACH_LS2E
Definition: ELF.h:541
llvm::ELF::EM_IP2K
@ EM_IP2K
Definition: ELF.h:218
llvm::ELF::PF_W
@ PF_W
Definition: ELF.h:1382
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ELF::EM_EXCESS
@ EM_EXCESS
Definition: ELF.h:229
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX940
@ EF_AMDGPU_MACH_AMDGCN_GFX940
Definition: ELF.h:766
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX810
@ EF_AMDGPU_MACH_AMDGCN_GFX810
Definition: ELF.h:745
llvm::ELF::NT_FREEBSD_PROCSTAT_FILES
@ NT_FREEBSD_PROCSTAT_FILES
Definition: ELF.h:1670
llvm::ELF::EM_OPEN8
@ EM_OPEN8
Definition: ELF.h:292
llvm::ELFYAML::VerneedEntry
Definition: ELFYAML.h:454
llvm::ELF::SHN_MIPS_TEXT
@ SHN_MIPS_TEXT
Definition: ELF.h:570
llvm::ELF::NT_LWPSINFO
@ NT_LWPSINFO
Definition: ELF.h:1516
llvm::ELF::EF_ARM_SOFT_FLOAT
@ EF_ARM_SOFT_FLOAT
Definition: ELF.h:434
llvm::ELF::NT_X86_XSTATE
@ NT_X86_XSTATE
Definition: ELF.h:1537
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_ABI_FP >::enumeration
static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value)
Definition: ELFYAML.cpp:979
llvm::getAsUnsignedInteger
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:492
ELFYAML.h
llvm::ELF::EF_AVR_ARCH_AVR25
@ EF_AVR_ARCH_AVR25
Definition: ELF.h:477
llvm::ELF::EF_HEXAGON_ISA
@ EF_HEXAGON_ISA
Definition: ELF.h:639
llvm::ELF::EF_AMDGPU_MACH_R600_REDWOOD
@ EF_AMDGPU_MACH_R600_REDWOOD
Definition: ELF.h:717
llvm::ELF::NT_ANDROID_TYPE_IDENT
@ NT_ANDROID_TYPE_IDENT
Definition: ELF.h:1581
llvm::ELF::NT_S390_GS_CB
@ NT_S390_GS_CB
Definition: ELF.h:1550
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_REL >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_REL &Value)
Definition: ELFYAML.cpp:828
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:486
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010
@ EF_AMDGPU_MACH_AMDGCN_GFX1010
Definition: ELF.h:753
UINT64_MAX
#define UINT64_MAX
Definition: DataTypes.h:77
llvm::ELF::NT_PPC_TM_CVSX
@ NT_PPC_TM_CVSX
Definition: ELF.h:1529
llvm::ELF::EM_CRAYNV2
@ EM_CRAYNV2
Definition: ELF.h:268
llvm::ELFYAML::FileHeader::EShStrNdx
Optional< llvm::yaml::Hex16 > EShStrNdx
Definition: ELFYAML.h:129
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V5
@ ELFABIVERSION_AMDGPU_HSA_V5
Definition: ELF.h:377
llvm::ELF::EF_HEXAGON_MACH_V60
@ EF_HEXAGON_MACH_V60
Definition: ELF.h:614
llvm::ELF::EM_SVX
@ EM_SVX
Definition: ELF.h:189
llvm::ELF::SHF_MIPS_LOCAL
@ SHF_MIPS_LOCAL
Definition: ELF.h:1115
llvm::ELF::EF_AVR_ARCH_AVR5
@ EF_AVR_ARCH_AVR5
Definition: ELF.h:482
llvm::ELF::PT_TLS
@ PT_TLS
Definition: ELF.h:1343
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX704
@ EF_AMDGPU_MACH_AMDGCN_GFX704
Definition: ELF.h:740
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012
@ EF_AMDGPU_MACH_AMDGCN_GFX1012
Definition: ELF.h:755
llvm::ELFYAML::GnuHashSection
Definition: ELFYAML.h:429
MipsABIFlags.h
llvm::ELF::EF_MIPS_MACH_OCTEON3
@ EF_MIPS_MACH_OCTEON3
Definition: ELF.h:536
llvm::ELF::EF_AMDGPU_MACH_R600_JUNIPER
@ EF_AMDGPU_MACH_R600_JUNIPER
Definition: ELF.h:716
llvm::ELF::NT_PPC_TM_CTAR
@ NT_PPC_TM_CTAR
Definition: ELF.h:1531
llvm::ELF::EM_OPENRISC
@ EM_OPENRISC
Definition: ELF.h:208
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_SHF >::bitset
static void bitset(IO &IO, ELFYAML::ELF_SHF &Value)
Definition: ELFYAML.cpp:706
llvm::ELF::NT_NETBSDCORE_AUXV
@ NT_NETBSDCORE_AUXV
Definition: ELF.h:1683
llvm::ELF::SHF_MIPS_NOSTRIP
@ SHF_MIPS_NOSTRIP
Definition: ELF.h:1118
llvm::ELF::EF_MIPS_ARCH_64R6
@ EF_MIPS_ARCH_64R6
Definition: ELF.h:563
llvm::ELF::EM_PDP11
@ EM_PDP11
Definition: ELF.h:181
llvm::yaml::ScalarBitSetTraits< ELFYAML::MIPS_AFL_ASE >::bitset
static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value)
Definition: ELFYAML.cpp:1031
llvm::ELFYAML::LinkerOption::Key
StringRef Key
Definition: ELFYAML.h:488
llvm::ELF::EM_NDS32
@ EM_NDS32
Definition: ELF.h:261
llvm::ELF::SHN_ABS
@ SHN_ABS
Definition: ELF.h:946
llvm::ELF::EM_MIPS_X
@ EM_MIPS_X
Definition: ELF.h:167
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034
@ EF_AMDGPU_MACH_AMDGCN_GFX1034
Definition: ELF.h:764
llvm::ELF::EF_MIPS_MACH
@ EF_MIPS_MACH
Definition: ELF.h:544
llvm::ELF::EM_SH
@ EM_SH
Definition: ELF.h:158
llvm::ELF::SHT_ANDROID_RELA
@ SHT_ANDROID_RELA
Definition: ELF.h:978
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX909
@ EF_AMDGPU_MACH_AMDGCN_GFX909
Definition: ELF.h:751
llvm::ELF::ELFOSABI_AMDGPU_HSA
@ ELFOSABI_AMDGPU_HSA
Definition: ELF.h:360
llvm::ELFYAML::RelocationSection
Definition: ELFYAML.h:595
llvm::ELF::ELFOSABI_AROS
@ ELFOSABI_AROS
Definition: ELF.h:356
llvm::ELF::ELFOSABI_C6000_LINUX
@ ELFOSABI_C6000_LINUX
Definition: ELF.h:365
llvm::ELF::EF_AVR_ARCH_AVR35
@ EF_AVR_ARCH_AVR35
Definition: ELF.h:480
SpecSym
ELFYAML::ELF_RSS SpecSym
Definition: ELFYAML.cpp:1758
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition: ELF.h:1221
llvm::ELF::NT_S390_TODCMP
@ NT_S390_TODCMP
Definition: ELF.h:1541
llvm::ELF::EF_MIPS_MACH_5500
@ EF_MIPS_MACH_5500
Definition: ELF.h:539
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX705
@ EF_AMDGPU_MACH_AMDGCN_GFX705
Definition: ELF.h:761
llvm::ELF::SHT_SHLIB
@ SHT_SHLIB
Definition: ELF.h:964
llvm::ELF::EM_ST200
@ EM_ST200
Definition: ELF.h:217
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::SHF_MIPS_GPREL
@ SHF_MIPS_GPREL
Definition: ELF.h:1121
llvm::ELF::STT_SECTION
@ STT_SECTION
Definition: ELF.h:1206
llvm::ELF::EM_RISCV
@ EM_RISCV
Definition: ELF.h:317
llvm::ELF::EM_TMM_GPP
@ EM_TMM_GPP
Definition: ELF.h:213
llvm::ELF::EM_IAMCU
@ EM_IAMCU
Definition: ELF.h:139
llvm::ELF::EM_CRIS
@ EM_CRIS
Definition: ELF.h:192
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4
@ EF_AMDGPU_FEATURE_XNACK_OFF_V4
Definition: ELF.h:810
llvm::StringRef::getAsInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:514
llvm::None
const NoneType None
Definition: None.h:24
llvm::ELF::EF_HEXAGON_MACH_V66
@ EF_HEXAGON_MACH_V66
Definition: ELF.h:617
llvm::ELF::SHF_MIPS_MERGE
@ SHF_MIPS_MERGE
Definition: ELF.h:1124
llvm::ELF::EF_MIPS_ARCH_3
@ EF_MIPS_ARCH_3
Definition: ELF.h:555
llvm::ELF::SHT_LLVM_ODRTAB
@ SHT_LLVM_ODRTAB
Definition: ELF.h:979
llvm::ELF::NT_AMD_HSA_ISA_NAME
@ NT_AMD_HSA_ISA_NAME
Definition: ELF.h:1709
llvm::ELF::SHT_MIPS_ABIFLAGS
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:1019
llvm::ELFYAML::DynamicEntry::Tag
ELF_DYNTAG Tag
Definition: ELFYAML.h:154
llvm::ELF::EM_ME16
@ EM_ME16
Definition: ELF.h:175
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:962
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4
@ EF_AMDGPU_FEATURE_SRAMECC_ON_V4
Definition: ELF.h:825
llvm::ELF::PT_LOAD
@ PT_LOAD
Definition: ELF.h:1337
llvm::ELFYAML::SymverSection
Definition: ELFYAML.h:540
llvm::ELF::STV_HIDDEN
@ STV_HIDDEN
Definition: ELF.h:1223
llvm::ELF::EM_BPF
@ EM_BPF
Definition: ELF.h:319
llvm::ELFYAML::dropUniqueSuffix
StringRef dropUniqueSuffix(StringRef S)
Definition: ELFEmitter.cpp:694
llvm::ELFYAML::ProgramHeader::LastSec
Optional< StringRef > LastSec
Definition: ELFYAML.h:688
llvm::ELF::NT_FILE
@ NT_FILE
Definition: ELF.h:1560
llvm::ELF::NT_ARM_HW_BREAK
@ NT_ARM_HW_BREAK
Definition: ELF.h:1555
llvm::ELF::RSS_GP0
@ RSS_GP0
Definition: ELF.h:1234
llvm::ELF::EF_MIPS_MACH_SB1
@ EF_MIPS_MACH_SB1
Definition: ELF.h:532
llvm::OutputFileType::Object
@ Object
llvm::ELF::NT_OPENBSD_REGS
@ NT_OPENBSD_REGS
Definition: ELF.h:1691
llvm::ELF::EM_ECOG1X
@ EM_ECOG1X
Definition: ELF.h:264
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:960
llvm::ELF::EM_MIPS_RS3_LE
@ EM_MIPS_RS3_LE
Definition: ELF.h:143
llvm::ELFYAML::Object
Definition: ELFYAML.h:694
llvm::ELFYAML::SectionHeaderTable::NoHeaders
Optional< bool > NoHeaders
Definition: ELFYAML.h:301
llvm::ELF::EF_MIPS_ARCH_32R2
@ EF_MIPS_ARCH_32R2
Definition: ELF.h:560
llvm::ELF::SHF_GROUP
@ SHF_GROUP
Definition: ELF.h:1060
llvm::ELF::EF_MIPS_MACH_OCTEON2
@ EF_MIPS_MACH_OCTEON2
Definition: ELF.h:535
llvm::ELF::EF_MIPS_ARCH_64
@ EF_MIPS_ARCH_64
Definition: ELF.h:559
llvm::yaml::ScalarBitSetTraits< ELFYAML::MIPS_AFL_FLAGS1 >::bitset
static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value)
Definition: ELFYAML.cpp:1052
llvm::ELF::NT_PRPSINFO
@ NT_PRPSINFO
Definition: ELF.h:1509
llvm::ELFYAML::SectionOrType::sectionNameOrType
StringRef sectionNameOrType
Definition: ELFYAML.h:150
llvm::ELFYAML::Fill::Pattern
Optional< yaml::BinaryRef > Pattern
Definition: ELFYAML.h:283
llvm::ELFYAML::GroupSection::Members
Optional< std::vector< SectionOrType > > Members
Definition: ELFYAML.h:576
llvm::ELFYAML::Object::getMachine
unsigned getMachine() const
Definition: ELFYAML.cpp:34
llvm::ELF::SHT_LLVM_SYMPART
@ SHT_LLVM_SYMPART
Definition: ELF.h:985
Type3
ELFYAML::ELF_REL Type3
Definition: ELFYAML.cpp:1757
llvm::ELF::NT_S390_CTRS
@ NT_S390_CTRS
Definition: ELF.h:1543
llvm::ELF::NT_S390_VXRS_LOW
@ NT_S390_VXRS_LOW
Definition: ELF.h:1548
llvm::ELF::ET_DYN
@ ET_DYN
Definition: ELF.h:118
llvm::ELF::NT_FPREGSET
@ NT_FPREGSET
Definition: ELF.h:1508
llvm::ELF::EF_RISCV_FLOAT_ABI_DOUBLE
@ EF_RISCV_FLOAT_ABI_DOUBLE
Definition: ELF.h:667
llvm::ELF::SHT_MSP430_ATTRIBUTES
@ SHT_MSP430_ATTRIBUTES
Definition: ELF.h:1021
llvm::ELF::EM_TI_C2000
@ EM_TI_C2000
Definition: ELF.h:251
llvm::ELF::EF_MIPS_MACH_5900
@ EF_MIPS_MACH_5900
Definition: ELF.h:538
llvm::ELF::ET_EXEC
@ ET_EXEC
Definition: ELF.h:117
llvm::ELF::EM_RL78
@ EM_RL78
Definition: ELF.h:293
llvm::ELF::NT_AUXV
@ NT_AUXV
Definition: ELF.h:1511
llvm::ELF::EF_MIPS_MACH_LS2F
@ EF_MIPS_MACH_LS2F
Definition: ELF.h:542
llvm::ELF::EM_8051
@ EM_8051
Definition: ELF.h:258
llvm::ELF::NT_PPC_PMU
@ NT_PPC_PMU
Definition: ELF.h:1525
llvm::ELFYAML::SectionOrType
Definition: ELFYAML.h:149
llvm::ELF::EM_CSKY
@ EM_CSKY
Definition: ELF.h:321
llvm::ELF::EM_PCP
@ EM_PCP
Definition: ELF.h:171
llvm::ELF::SHT_NULL
@ SHT_NULL
Definition: ELF.h:954
llvm::ELF::PT_DYNAMIC
@ PT_DYNAMIC
Definition: ELF.h:1338
llvm::ELF::EF_ARM_EABI_VER2
@ EF_ARM_EABI_VER2
Definition: ELF.h:440
llvm::MapVector::find
iterator find(const KeyT &Key)
Definition: MapVector.h:148
llvm::ELF::EM_ARCA
@ EM_ARCA
Definition: ELF.h:226
llvm::ELF::ELFOSABI_IRIX
@ ELFOSABI_IRIX
Definition: ELF.h:349
MSA
Code Generation Notes for MSA
Definition: MSA.txt:2
llvm::ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS
@ NT_FREEBSD_PROCSTAT_PSSTRINGS
Definition: ELF.h:1676
uint64_t
llvm::ELF::EF_AMDGPU_MACH_R600_R630
@ EF_AMDGPU_MACH_R600_R630
Definition: ELF.h:706
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_PF >::bitset
static void bitset(IO &IO, ELFYAML::ELF_PF &Value)
Definition: ELFYAML.cpp:698
llvm::ELFYAML::SectionHeaderTable::TypeStr
static constexpr StringRef TypeStr
Definition: ELFYAML.h:313
llvm::ELF::NT_AMD_HSA_CODE_OBJECT_VERSION
@ NT_AMD_HSA_CODE_OBJECT_VERSION
Definition: ELF.h:1704
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:956
llvm::ELF::STT_NOTYPE
@ STT_NOTYPE
Definition: ELF.h:1203
llvm::ELF::NT_GNU_ABI_TAG
@ NT_GNU_ABI_TAG
Definition: ELF.h:1572
llvm::ELF::EM_XIMO16
@ EM_XIMO16
Definition: ELF.h:266
llvm::ELF::SHN_AMDGPU_LDS
@ SHN_AMDGPU_LDS
Definition: ELF.h:1699
llvm::ELF::NT_ANDROID_TYPE_KUSER
@ NT_ANDROID_TYPE_KUSER
Definition: ELF.h:1582
llvm::ELFYAML::ProgramHeader::Align
Optional< llvm::yaml::Hex64 > Align
Definition: ELFYAML.h:683
llvm::ELFYAML::SymtabShndxSection
Definition: ELFYAML.h:624
llvm::ELF::EM_TILEGX
@ EM_TILEGX
Definition: ELF.h:287
llvm::ELFYAML::ProgramHeader::FirstSec
Optional< StringRef > FirstSec
Definition: ELFYAML.h:687
llvm::ELF::SHT_ARM_EXIDX
@ SHT_ARM_EXIDX
Definition: ELF.h:1005
llvm::ELF::EM_STXP7X
@ EM_STXP7X
Definition: ELF.h:259
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFDATA >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value)
Definition: ELFYAML.cpp:368
llvm::ELF::EM_PPC64
@ EM_PPC64
Definition: ELF.h:149
llvm::ELFYAML::FileHeader::Flags
ELF_EF Flags
Definition: ELFYAML.h:119
llvm::ELF::SHF_X86_64_LARGE
@ SHF_X86_64_LARGE
Definition: ELF.h:1101
llvm::ELF::EM_SPARC32PLUS
@ EM_SPARC32PLUS
Definition: ELF.h:146
llvm::ELFYAML::ProgramHeader::Type
ELF_PT Type
Definition: ELFYAML.h:679
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1191
llvm::ELFYAML::BBAddrMapSection
Definition: ELFYAML.h:316
LLVM_YAML_STRONG_TYPEDEF
#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)
llvm::ELF::EF_AMDGPU_MACH_R600_CYPRESS
@ EF_AMDGPU_MACH_R600_CYPRESS
Definition: ELF.h:715
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::ELF::EM_JAVELIN
@ EM_JAVELIN
Definition: ELF.h:193
llvm::ELFYAML::Object::Header
FileHeader Header
Definition: ELFYAML.h:695
llvm::ELF::EF_AMDGPU_MACH_NONE
@ EF_AMDGPU_MACH_NONE
Definition: ELF.h:700
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:141
llvm::ELFYAML::LinkerOptionsSection
Definition: ELFYAML.h:492
llvm::ELF::EF_AMDGPU_MACH_R600_CAYMAN
@ EF_AMDGPU_MACH_R600_CAYMAN
Definition: ELF.h:722
llvm::ELF::PT_GNU_RELRO
@ PT_GNU_RELRO
Definition: ELF.h:1356
llvm::ELF::EM_88K
@ EM_88K
Definition: ELF.h:138
llvm::ELF::SHN_XINDEX
@ SHN_XINDEX
Definition: ELF.h:948
llvm::ELF::NT_S390_LAST_BREAK
@ NT_S390_LAST_BREAK
Definition: ELF.h:1545
llvm::ELF::EM_ARC_COMPACT2
@ EM_ARC_COMPACT2
Definition: ELF.h:291
llvm::ELF::NT_386_IOPERM
@ NT_386_IOPERM
Definition: ELF.h:1536
llvm::ELFYAML::FileHeader::Entry
llvm::yaml::Hex64 Entry
Definition: ELFYAML.h:120
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::ELF::SHN_HEXAGON_SCOMMON_2
@ SHN_HEXAGON_SCOMMON_2
Definition: ELF.h:646
llvm::ELF::EF_MIPS_MACH_XLR
@ EF_MIPS_MACH_XLR
Definition: ELF.h:534
llvm::ELF::EM_MAX
@ EM_MAX
Definition: ELF.h:219
llvm::ELF::SHN_HIRESERVE
@ SHN_HIRESERVE
Definition: ELF.h:949
llvm::ELF::SHT_LLVM_ADDRSIG
@ SHT_LLVM_ADDRSIG
Definition: ELF.h:981
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032
@ EF_AMDGPU_MACH_AMDGCN_GFX1032
Definition: ELF.h:758
llvm::ELF::EM_DSPIC30F
@ EM_DSPIC30F
Definition: ELF.h:236
llvm::ELF::NT_OPENBSD_XFPREGS
@ NT_OPENBSD_XFPREGS
Definition: ELF.h:1693
llvm::ELFYAML::StackSizesSection
Definition: ELFYAML.h:330
llvm::ELF::EF_RISCV_TSO
@ EF_RISCV_TSO
Definition: ELF.h:670
llvm::ELF::EM_M32C
@ EM_M32C
Definition: ELF.h:239
llvm::ELFYAML::Symbol
Definition: ELFYAML.h:136
llvm::ELFYAML::GnuHashHeader
Definition: ELFYAML.h:409
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX702
@ EF_AMDGPU_MACH_AMDGCN_GFX702
Definition: ELF.h:738
llvm::ELFYAML::Chunk::Name
StringRef Name
Definition: ELFYAML.h:213
llvm::ELF::EF_MIPS_MICROMIPS
@ EF_MIPS_MICROMIPS
Definition: ELF.h:547
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:992
llvm::ELF::STO_MIPS_MIPS16
@ STO_MIPS_MIPS16
Definition: ELF.h:587
llvm::ELF::EF_MIPS_ARCH_32R6
@ EF_MIPS_ARCH_32R6
Definition: ELF.h:562
llvm::ELF::EM_XGATE
@ EM_XGATE
Definition: ELF.h:233
llvm::ELF::NT_PPC_TAR
@ NT_PPC_TAR
Definition: ELF.h:1521
llvm::ELF::NT_S390_HIGH_GPRS
@ NT_S390_HIGH_GPRS
Definition: ELF.h:1539
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ELF::EM_K10M
@ EM_K10M
Definition: ELF.h:279
llvm::ELF::SHF_LINK_ORDER
@ SHF_LINK_ORDER
Definition: ELF.h:1053
llvm::ELF::EF_AVR_ARCH_AVR3
@ EF_AVR_ARCH_AVR3
Definition: ELF.h:478
llvm::ELF::EF_HEXAGON_ISA_V68
@ EF_HEXAGON_ISA_V68
Definition: ELF.h:637
llvm::ELF::EM_TINYJ
@ EM_TINYJ
Definition: ELF.h:177
llvm::ELF::ELFOSABI_NETBSD
@ ELFOSABI_NETBSD
Definition: ELF.h:343
llvm::ELFYAML::BBAddrMapEntry
Definition: ELFYAML.h:158
llvm::ELF::EF_MIPS_NOREORDER
@ EF_MIPS_NOREORDER
Definition: ELF.h:507
llvm::ELF::SHT_MIPS_OPTIONS
@ SHT_MIPS_OPTIONS
Definition: ELF.h:1017
llvm::ELFYAML::MipsABIFlags
Definition: ELFYAML.h:658
llvm::ELF::EF_MIPS_MACH_LS3A
@ EF_MIPS_MACH_LS3A
Definition: ELF.h:543
llvm::ELF::STO_MIPS_PIC
@ STO_MIPS_PIC
Definition: ELF.h:585
llvm::ELF::EF_MIPS_FP64
@ EF_MIPS_FP64
Definition: ELF.h:513
llvm::ELF::EF_RISCV_FLOAT_ABI_QUAD
@ EF_RISCV_FLOAT_ABI_QUAD
Definition: ELF.h:668
llvm::ELF::SHT_RELR
@ SHT_RELR
Definition: ELF.h:973
llvm::ELFYAML::ARMIndexTableSection
Definition: ELFYAML.h:643
llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::input
static StringRef input(StringRef Scalar, void *, ELFYAML::YAMLFlowString &Val)
Definition: ELFYAML.cpp:1132
llvm::ELF::EM_BLACKFIN
@ EM_BLACKFIN
Definition: ELF.h:223
llvm::ELF::EF_AVR_ARCH_AVRTINY
@ EF_AVR_ARCH_AVRTINY
Definition: ELF.h:485
llvm::ELF::NT_AMD_HSA_HSAIL
@ NT_AMD_HSA_HSAIL
Definition: ELF.h:1705
llvm::ELF::NT_PPC_TM_CFPR
@ NT_PPC_TM_CFPR
Definition: ELF.h:1527
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:958
llvm::ELF::RSS_LOC
@ RSS_LOC
Definition: ELF.h:1235
llvm::yaml::sectionMapping
static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section)
Definition: ELFYAML.cpp:1329
llvm::ELF::EM_VIDEOCORE3
@ EM_VIDEOCORE3
Definition: ELF.h:247
llvm::ELF::EM_AMDGPU
@ EM_AMDGPU
Definition: ELF.h:316
llvm::ELF::EM_M16C
@ EM_M16C
Definition: ELF.h:235
llvm::ELF::EM_NCPU
@ EM_NCPU
Definition: ELF.h:172
llvm::ELF::EM_H8S
@ EM_H8S
Definition: ELF.h:164
llvm::ELF::EM_ALPHA
@ EM_ALPHA
Definition: ELF.h:157
llvm::ELF::NT_PRXFPREG
@ NT_PRXFPREG
Definition: ELF.h:1561
llvm::ELFYAML::DynamicSection
Definition: ELFYAML.h:348
llvm::ELF::EF_MIPS_MACH_OCTEON
@ EF_MIPS_MACH_OCTEON
Definition: ELF.h:533
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::ELFYAML::SectionHeaderTable::Excluded
Optional< std::vector< SectionHeader > > Excluded
Definition: ELFYAML.h:300
llvm::ELF::EF_AMDGPU_MACH_R600_TURKS
@ EF_AMDGPU_MACH_R600_TURKS
Definition: ELF.h:723
llvm::yaml::ScalarTraits< StOtherPiece >::output
static void output(const StOtherPiece &Val, void *, raw_ostream &Out)
Definition: ELFYAML.cpp:1114
llvm::ELF::EM_MN10300
@ EM_MN10300
Definition: ELF.h:205
YAMLTraits.h
llvm::ELF::STV_INTERNAL
@ STV_INTERNAL
Definition: ELF.h:1222
llvm::ELF::EM_D30V
@ EM_D30V
Definition: ELF.h:202
llvm::ELF::SHT_X86_64_UNWIND
@ SHT_X86_64_UNWIND
Definition: ELF.h:1014
llvm::ELF::EF_HEXAGON_ISA_V60
@ EF_HEXAGON_ISA_V60
Definition: ELF.h:632
llvm::ELF::EF_MIPS_ARCH
@ EF_MIPS_ARCH
Definition: ELF.h:564
llvm::ELF::EF_AVR_ARCH_AVR6
@ EF_AVR_ARCH_AVR6
Definition: ELF.h:484
llvm::ELFYAML::FileHeader::EShEntSize
Optional< llvm::yaml::Hex16 > EShEntSize
Definition: ELFYAML.h:126
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_AFL_REG >::enumeration
static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value)
Definition: ELFYAML.cpp:969
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ELF::NT_LLVM_HWASAN_GLOBALS
@ NT_LLVM_HWASAN_GLOBALS
Definition: ELF.h:1567
llvm::ELF::EM_SHARC
@ EM_SHARC
Definition: ELF.h:242
llvm::ELF::SHN_HEXAGON_SCOMMON_8
@ SHN_HEXAGON_SCOMMON_8
Definition: ELF.h:648
llvm::ELF::SHT_NOTE
@ SHT_NOTE
Definition: ELF.h:961
llvm::ELFYAML::FileHeader::Class
ELF_ELFCLASS Class
Definition: ELFYAML.h:113
llvm::ELF::SHF_MIPS_NAMES
@ SHF_MIPS_NAMES
Definition: ELF.h:1112
llvm::ELF::SHF_GNU_RETAIN
@ SHF_GNU_RETAIN
Definition: ELF.h:1069
llvm::yaml::ScalarTraits< StOtherPiece >::mustQuote
static QuotingType mustQuote(StringRef)
Definition: ELFYAML.cpp:1121
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ET >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_ET &Value)
Definition: ELFYAML.cpp:45
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::ELF::EF_AVR_ARCH_AVR1
@ EF_AVR_ARCH_AVR1
Definition: ELF.h:475
llvm::ELF::EF_MIPS_ARCH_32
@ EF_MIPS_ARCH_32
Definition: ELF.h:558
llvm::ELF::ELFDATA2LSB
@ ELFDATA2LSB
Definition: ELF.h:335
llvm::ELF::SHF_ARM_PURECODE
@ SHF_ARM_PURECODE
Definition: ELF.h:1133
llvm::yaml::BinaryRef
Specialized YAMLIO scalar type for representing a binary blob.
Definition: YAML.h:63
llvm::ELF::SHT_ARM_OVERLAYSECTION
@ SHT_ARM_OVERLAYSECTION
Definition: ELF.h:1011
llvm::ELF::EF_ARM_EABI_VER4
@ EF_ARM_EABI_VER4
Definition: ELF.h:442
llvm::ELF::EM_PDP10
@ EM_PDP10
Definition: ELF.h:180
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_RSS >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value)
Definition: ELFYAML.cpp:818
llvm::ELFYAML::NoteEntry
Definition: ELFYAML.h:176
llvm::ELF::NT_OPENBSD_FPREGS
@ NT_OPENBSD_FPREGS
Definition: ELF.h:1692
uint32_t
llvm::ELF::EM_TRIMEDIA
@ EM_TRIMEDIA
Definition: ELF.h:256
llvm::ELFYAML::ProgramHeader::PAddr
llvm::yaml::Hex64 PAddr
Definition: ELFYAML.h:682
llvm::ELF::EM_VIDEOCORE
@ EM_VIDEOCORE
Definition: ELF.h:212
llvm::ELF::EM_H8_500
@ EM_H8_500
Definition: ELF.h:165
llvm::ELF::PT_SHLIB
@ PT_SHLIB
Definition: ELF.h:1341
llvm::ELF::NT_ARCH
@ NT_ARCH
Definition: ELF.h:1500
llvm::ELFYAML::FileHeader::Data
ELF_ELFDATA Data
Definition: ELFYAML.h:114
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::ELF::EM_FX66
@ EM_FX66
Definition: ELF.h:182
llvm::ELF::EF_HEXAGON_MACH_V68
@ EF_HEXAGON_MACH_V68
Definition: ELF.h:620
llvm::ELF::EM_56800EX
@ EM_56800EX
Definition: ELF.h:296
llvm::ELF::SHN_LORESERVE
@ SHN_LORESERVE
Definition: ELF.h:941
llvm::ELF::NT_GNU_HWCAP
@ NT_GNU_HWCAP
Definition: ELF.h:1573
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_AFL_EXT >::enumeration
static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value)
Definition: ELFYAML.cpp:993
llvm::ELF::EM_H8_300
@ EM_H8_300
Definition: ELF.h:162
llvm::ELFYAML::Relocation::Type
ELF_REL Type
Definition: ELFYAML.h:591
llvm::yaml::commonSectionMapping
static void commonSectionMapping(IO &IO, ELFYAML::Section &Section)
Definition: ELFYAML.cpp:1302
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:280
llvm::ELF::EM_68HC16
@ EM_68HC16
Definition: ELF.h:185
llvm::ELF::EM_ST7
@ EM_ST7
Definition: ELF.h:184
llvm::ELF::NT_S390_VXRS_HIGH
@ NT_S390_VXRS_HIGH
Definition: ELF.h:1549
llvm::ELF::EF_MIPS_ARCH_64R2
@ EF_MIPS_ARCH_64R2
Definition: ELF.h:561
llvm::ELF::EF_AMDGPU_MACH_R600_RV770
@ EF_AMDGPU_MACH_R600_RV770
Definition: ELF.h:712
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4
@ EF_AMDGPU_FEATURE_XNACK_ON_V4
Definition: ELF.h:812
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:969
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_V4
@ EF_AMDGPU_FEATURE_XNACK_V4
Definition: ELF.h:804
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035
@ EF_AMDGPU_MACH_AMDGCN_GFX1035
Definition: ELF.h:763
llvm::MapVector::end
iterator end()
Definition: MapVector.h:72
llvm::ELF::STB_GNU_UNIQUE
@ STB_GNU_UNIQUE
Definition: ELF.h:1194
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::ELF::EM_FR20
@ EM_FR20
Definition: ELF.h:153
llvm::ELF::EM_ARC
@ EM_ARC
Definition: ELF.h:161
llvm::ARM::EHABI::EXIDX_CANTUNWIND
@ EXIDX_CANTUNWIND
Special entry for the function never unwind.
Definition: ARMEHABI.h:35
llvm::ELF::PT_INTERP
@ PT_INTERP
Definition: ELF.h:1339
llvm::ELFYAML::SectionHeaderTable
Definition: ELFYAML.h:291
llvm::ELF::ELFOSABI_SOLARIS
@ ELFOSABI_SOLARIS
Definition: ELF.h:347
llvm::yaml::groupSectionMapping
static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group)
Definition: ELFYAML.cpp:1418
llvm::ELF::NT_OPENBSD_WCOOKIE
@ NT_OPENBSD_WCOOKIE
Definition: ELF.h:1694
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V4
@ ELFABIVERSION_AMDGPU_HSA_V4
Definition: ELF.h:376
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX801
@ EF_AMDGPU_MACH_AMDGCN_GFX801
Definition: ELF.h:742
llvm::ELF::NT_S390_TDB
@ NT_S390_TDB
Definition: ELF.h:1547
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1224
WithColor.h
llvm::ELF::EF_RISCV_FLOAT_ABI
@ EF_RISCV_FLOAT_ABI
Definition: ELF.h:664
llvm::ELF::SHN_HIOS
@ SHN_HIOS
Definition: ELF.h:945
llvm::ELF::PT_GNU_EH_FRAME
@ PT_GNU_EH_FRAME
Definition: ELF.h:1351
llvm::ELF::SHF_SUNW_NODISCARD
@ SHF_SUNW_NODISCARD
Definition: ELF.h:1079
llvm::ELF::SHT_GNU_verdef
@ SHT_GNU_verdef
Definition: ELF.h:998
llvm::ELF::ELFOSABI_CLOUDABI
@ ELFOSABI_CLOUDABI
Definition: ELF.h:358
llvm::ELF::RSS_UNDEF
@ RSS_UNDEF
Definition: ELF.h:1232
llvm::ELF::EM_PARISC
@ EM_PARISC
Definition: ELF.h:144
llvm::ELF::EF_AVR_ARCH_AVR31
@ EF_AVR_ARCH_AVR31
Definition: ELF.h:479
llvm::ELF::EF_HEXAGON_ISA_V3
@ EF_HEXAGON_ISA_V3
Definition: ELF.h:628
llvm::ELFYAML::FileHeader::EPhEntSize
Optional< llvm::yaml::Hex16 > EPhEntSize
Definition: ELFYAML.h:124
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::ELF::EF_MIPS_NAN2008
@ EF_MIPS_NAN2008
Definition: ELF.h:515
llvm::ELFYAML::ARMIndexTableEntry
Definition: ELFYAML.h:638
llvm::ELF::EF_AMDGPU_MACH_R600_CAICOS
@ EF_AMDGPU_MACH_R600_CAICOS
Definition: ELF.h:721
llvm::ELF::EM_TRICORE
@ EM_TRICORE
Definition: ELF.h:160
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_STB >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_STB &Value)
Definition: ELFYAML.cpp:791
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_V4
@ EF_AMDGPU_FEATURE_SRAMECC_V4
Definition: ELF.h:817
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_EM >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_EM &Value)
Definition: ELFYAML.cpp:188
llvm::ELF::STO_MIPS_MICROMIPS
@ STO_MIPS_MICROMIPS
Definition: ELF.h:586
llvm::ELF::ELFOSABI_FREEBSD
@ ELFOSABI_FREEBSD
Definition: ELF.h:350
llvm::ELF::NT_FREEBSD_FEATURE_CTL
@ NT_FREEBSD_FEATURE_CTL
Definition: ELF.h:1653
llvm::ELF::EF_MIPS_MACH_4010
@ EF_MIPS_MACH_4010
Definition: ELF.h:527
llvm::ELF::EM_CYPRESS_M8C
@ EM_CYPRESS_M8C
Definition: ELF.h:254
llvm::ELF::SHT_ARM_PREEMPTMAP
@ SHT_ARM_PREEMPTMAP
Definition: ELF.h:1007
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:27
llvm::ELFYAML::RelrSection
Definition: ELFYAML.h:610
llvm::ELF::EF_AVR_ARCH_XMEGA7
@ EF_AVR_ARCH_XMEGA7
Definition: ELF.h:492
llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::mustQuote
static QuotingType mustQuote(StringRef S)
Definition: ELFYAML.cpp:1137
llvm::ELF::EM_STARCORE
@ EM_STARCORE
Definition: ELF.h:174
llvm::ELF::EF_HEXAGON_MACH_V2
@ EF_HEXAGON_MACH_V2
Definition: ELF.h:609
llvm::ELFYAML::DynamicEntry::Val
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:155
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1044
llvm::ELF::NT_PRSTATUS
@ NT_PRSTATUS
Definition: ELF.h:1507
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition: ELF.h:1204
llvm::ELF::SHF_OS_NONCONFORMING
@ SHF_OS_NONCONFORMING
Definition: ELF.h:1057
llvm::ELF::ELFDATA2MSB
@ ELFDATA2MSB
Definition: ELF.h:336
llvm::ELF::NT_S390_TIMER
@ NT_S390_TIMER
Definition: ELF.h:1540
llvm::ELF::NT_VERSION
@ NT_VERSION
Definition: ELF.h:1499
llvm::ELF::EM_SLE9X
@ EM_SLE9X
Definition: ELF.h:277
llvm::ELFYAML::LinkerOption::Value
StringRef Value
Definition: ELFYAML.h:489
llvm::ELF::EM_S390
@ EM_S390
Definition: ELF.h:150
llvm::ELF::ELFOSABI_TRU64
@ ELFOSABI_TRU64
Definition: ELF.h:351
llvm::ELF::EF_HEXAGON_MACH_V4
@ EF_HEXAGON_MACH_V4
Definition: ELF.h:611
llvm::ELF::EF_RISCV_RVE
@ EF_RISCV_RVE
Definition: ELF.h:669
llvm::ELF::SHT_GNU_verneed
@ SHT_GNU_verneed
Definition: ELF.h:999
llvm::ELF::EM_D10V
@ EM_D10V
Definition: ELF.h:201
Casting.h
llvm::ELF::NT_PPC_EBB
@ NT_PPC_EBB
Definition: ELF.h:1524
llvm::ELF::EF_AMDGPU_MACH_R600_RV670
@ EF_AMDGPU_MACH_R600_RV670
Definition: ELF.h:708
llvm::ELF::NT_OPENBSD_AUXV
@ NT_OPENBSD_AUXV
Definition: ELF.h:1690
llvm::ELF::NT_PPC_TM_CVMX
@ NT_PPC_TM_CVMX
Definition: ELF.h:1528
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:963
llvm::ELF::PT_NOTE
@ PT_NOTE
Definition: ELF.h:1340
llvm::ELFYAML::CallGraphEntryWeight
Definition: ELFYAML.h:521
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
@ EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
Definition: ELF.h:821
llvm::ELF::EF_MIPS_MACH_9000
@ EF_MIPS_MACH_9000
Definition: ELF.h:540
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::ELF::EM_NDR1
@ EM_NDR1
Definition: ELF.h:173
llvm::ELF::EM_MAXQ30
@ EM_MAXQ30
Definition: ELF.h:265
llvm::ELF::SHT_LLVM_BB_ADDR_MAP_V0
@ SHT_LLVM_BB_ADDR_MAP_V0
Definition: ELF.h:988
llvm::ELF::NT_FREEBSD_ABI_TAG
@ NT_FREEBSD_ABI_TAG
Definition: ELF.h:1650
llvm::ELF::ELFOSABI_FENIXOS
@ ELFOSABI_FENIXOS
Definition: ELF.h:357
llvm::ELF::NT_PPC_PPR
@ NT_PPC_PPR
Definition: ELF.h:1522
llvm::ELFYAML::Section::Content
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:232
llvm::ELF::NT_386_TLS
@ NT_386_TLS
Definition: ELF.h:1535
llvm::ELFYAML::GroupSection::Signature
Optional< StringRef > Signature
Definition: ELFYAML.h:577
llvm::ELF::EM_ECOG1
@ EM_ECOG1
Definition: ELF.h:263
llvm::ELF::SHT_INIT_ARRAY
@ SHT_INIT_ARRAY
Definition: ELF.h:966
llvm::ELF::EM_TPC
@ EM_TPC
Definition: ELF.h:215
llvm::ELFYAML::Relocation::Addend
YAMLIntUInt Addend
Definition: ELFYAML.h:590
llvm::ELF::NT_PPC_TM_CDSCR
@ NT_PPC_TM_CDSCR
Definition: ELF.h:1533
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFCLASS >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value)
Definition: ELFYAML.cpp:358
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX803
@ EF_AMDGPU_MACH_AMDGCN_GFX803
Definition: ELF.h:744
llvm::ELF::ET_REL
@ ET_REL
Definition: ELF.h:116
llvm::ELF::EM_SPARC
@ EM_SPARC
Definition: ELF.h:135
llvm::ELF::SHT_GNU_HASH
@ SHT_GNU_HASH
Definition: ELF.h:997
llvm::ELF::EF_HEXAGON_MACH_V5
@ EF_HEXAGON_MACH_V5
Definition: ELF.h:612
llvm::ELF::EF_MIPS_ARCH_ASE_M16
@ EF_MIPS_ARCH_ASE_M16
Definition: ELF.h:548
llvm::ELF::SHT_LLVM_LINKER_OPTIONS
@ SHT_LLVM_LINKER_OPTIONS
Definition: ELF.h:980
llvm::ELF::EM_TI_C6000
@ EM_TI_C6000
Definition: ELF.h:250
llvm::ELF::EM_MMA
@ EM_MMA
Definition: ELF.h:170
llvm::ELF::EM_HUANY
@ EM_HUANY
Definition: ELF.h:197
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_NT >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_NT &Value)
Definition: ELFYAML.cpp:76
llvm::ELF::NT_FPREGS
@ NT_FPREGS
Definition: ELF.h:1513
llvm::ELF::EM_TILE64
@ EM_TILE64
Definition: ELF.h:283
llvm::ELFYAML::Section::Size
Optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:233
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:965
llvm::ELFYAML::ProgramHeader::Offset
Optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:686
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX906
@ EF_AMDGPU_MACH_AMDGCN_GFX906
Definition: ELF.h:749
llvm::getAsSignedInteger
bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)
Definition: StringRef.cpp:502
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_V3
@ EF_AMDGPU_FEATURE_SRAMECC_V3
Definition: ELF.h:799
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX701
@ EF_AMDGPU_MACH_AMDGCN_GFX701
Definition: ELF.h:737
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX600
@ EF_AMDGPU_MACH_AMDGCN_GFX600
Definition: ELF.h:734
llvm::ELF::EM_MN10200
@ EM_MN10200
Definition: ELF.h:206
llvm::ELF::EM_MANIK
@ EM_MANIK
Definition: ELF.h:267
llvm::ELFYAML::StackSizesSection::nameMatches
static bool nameMatches(StringRef Name)
Definition: ELFYAML.h:343
llvm::ELF::EM_ECOG16
@ EM_ECOG16
Definition: ELF.h:273
llvm::ELF::EF_AVR_ARCH_AVR4
@ EF_AVR_ARCH_AVR4
Definition: ELF.h:481
llvm::ELF::EM_PRISM
@ EM_PRISM
Definition: ELF.h:198
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102
@ EF_AMDGPU_MACH_AMDGCN_GFX1102
Definition: ELF.h:773
llvm::ELF::PF_R
@ PF_R
Definition: ELF.h:1383
llvm::ELF::EM_V850
@ EM_V850
Definition: ELF.h:203
llvm::ELF::EM_FR30
@ EM_FR30
Definition: ELF.h:200
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:940
llvm::ELFYAML::ProgramHeader::FileSize
Optional< llvm::yaml::Hex64 > FileSize
Definition: ELFYAML.h:684
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX700
@ EF_AMDGPU_MACH_AMDGCN_GFX700
Definition: ELF.h:736
llvm::ELF::SHF_MIPS_NODUPES
@ SHF_MIPS_NODUPES
Definition: ELF.h:1109
llvm::ELF::NT_S390_GS_BC
@ NT_S390_GS_BC
Definition: ELF.h:1551
llvm::ELF::PT_PHDR
@ PT_PHDR
Definition: ELF.h:1342
llvm::ELF::EM_PPC
@ EM_PPC
Definition: ELF.h:148
llvm::ELFYAML::Section
Definition: ELFYAML.h:224
llvm::ELF::SHT_RISCV_ATTRIBUTES
@ SHT_RISCV_ATTRIBUTES
Definition: ELF.h:1023
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:955
llvm::ELFYAML::DynamicEntry
Definition: ELFYAML.h:153
llvm::ELF::EF_MIPS_ABI
@ EF_MIPS_ABI
Definition: ELF.h:522
llvm::ELF::NT_FREEBSD_PROCSTAT_AUXV
@ NT_FREEBSD_PROCSTAT_AUXV
Definition: ELF.h:1677
llvm::ELF::EM_ETPU
@ EM_ETPU
Definition: ELF.h:276
llvm::ELFYAML::VerdefSection
Definition: ELFYAML.h:560
llvm::ELF::STO_MIPS_OPTIONAL
@ STO_MIPS_OPTIONAL
Definition: ELF.h:583
llvm::ELF::EF_HEXAGON_ISA_V66
@ EF_HEXAGON_ISA_V66
Definition: ELF.h:635
N
#define N
llvm::ELF::EM_X86_64
@ EM_X86_64
Definition: ELF.h:178
llvm::ELF::EM_TILEPRO
@ EM_TILEPRO
Definition: ELF.h:284
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:85
llvm::ELF::EF_MIPS_CPIC
@ EF_MIPS_CPIC
Definition: ELF.h:509
llvm::ELFYAML::BBAddrMapEntry::BBEntry
Definition: ELFYAML.h:159
llvm::ELF::EM_MSP430
@ EM_MSP430
Definition: ELF.h:222
llvm::ELF::EF_AVR_ARCH_XMEGA5
@ EF_AVR_ARCH_XMEGA5
Definition: ELF.h:490
llvm::ELF::EF_HEXAGON_ISA_V55
@ EF_HEXAGON_ISA_V55
Definition: ELF.h:631
llvm::ELF::ELFCLASS64
@ ELFCLASS64
Definition: ELF.h:329
llvm::ELF::EM_COREA_2ND
@ EM_COREA_2ND
Definition: ELF.h:290
llvm::ELF::NT_ARM_SVE
@ NT_ARM_SVE
Definition: ELF.h:1557
llvm::ELF::EM_STM8
@ EM_STM8
Definition: ELF.h:282
llvm::ELF::EF_MIPS_ABI2
@ EF_MIPS_ABI2
Definition: ELF.h:510
llvm::ELF::EM_68HC11
@ EM_68HC11
Definition: ELF.h:186
llvm::ELF::SHN_MIPS_SCOMMON
@ SHN_MIPS_SCOMMON
Definition: ELF.h:572
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_SHT >::enumeration
static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value)
Definition: ELFYAML.cpp:622
llvm::ELF::NT_AMDGPU_METADATA
@ NT_AMDGPU_METADATA
Definition: ELF.h:1716
llvm::ELF::SHT_LLVM_PART_PHDR
@ SHT_LLVM_PART_PHDR
Definition: ELF.h:987
llvm::ELF::EF_AMDGPU_MACH_R600_BARTS
@ EF_AMDGPU_MACH_R600_BARTS
Definition: ELF.h:720
llvm::ELF::EM_CR
@ EM_CR
Definition: ELF.h:220
llvm::ELFYAML::HashSection
Definition: ELFYAML.h:391
llvm::ELF::STT_FILE
@ STT_FILE
Definition: ELF.h:1207
llvm::ELF::NT_NETBSDCORE_LWPSTATUS
@ NT_NETBSDCORE_LWPSTATUS
Definition: ELF.h:1684
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033
@ EF_AMDGPU_MACH_AMDGCN_GFX1033
Definition: ELF.h:759
llvm::ELF::EM_CLOUDSHIELD
@ EM_CLOUDSHIELD
Definition: ELF.h:288
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101
@ EF_AMDGPU_MACH_AMDGCN_GFX1101
Definition: ELF.h:772
BCaseMask
#define BCaseMask(X, M)
llvm::ELF::EF_MIPS_ABI_EABI64
@ EF_MIPS_ABI_EABI64
Definition: ELF.h:521
llvm::ELF::EM_CR16
@ EM_CR16
Definition: ELF.h:274
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A
@ EF_AMDGPU_MACH_AMDGCN_GFX90A
Definition: ELF.h:765
llvm::ELF::ELFOSABI_C6000_ELFABI
@ ELFOSABI_C6000_ELFABI
Definition: ELF.h:364
llvm::ELFYAML::VerneedSection
Definition: ELFYAML.h:460
ECase
#define ECase(X)
llvm::ELF::EM_METAG
@ EM_METAG
Definition: ELF.h:270
llvm::ELF::EF_AVR_ARCH_AVR2
@ EF_AVR_ARCH_AVR2
Definition: ELF.h:476
llvm::ELF::ELFOSABI_GNU
@ ELFOSABI_GNU
Definition: ELF.h:344
llvm::ELF::EM_SE_C33
@ EM_SE_C33
Definition: ELF.h:224
llvm::ELFYAML::DependentLibrariesSection
Definition: ELFYAML.h:506
llvm::ELFYAML::FileHeader::ABIVersion
llvm::yaml::Hex8 ABIVersion
Definition: ELFYAML.h:116
llvm::ELFYAML::ProgramHeader::MemSize
Optional< llvm::yaml::Hex64 > MemSize
Definition: ELFYAML.h:685
llvm::ELF::ELFOSABI_HURD
@ ELFOSABI_HURD
Definition: ELF.h:346
llvm::ELF::EF_MIPS_ABI_EABI32
@ EF_MIPS_ABI_EABI32
Definition: ELF.h:520
llvm::ELF::EM_AVR32
@ EM_AVR32
Definition: ELF.h:281
llvm::ELF::SHT_MIPS_REGINFO
@ SHT_MIPS_REGINFO
Definition: ELF.h:1016
llvm::ELF::EM_VE
@ EM_VE
Definition: ELF.h:320
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX902
@ EF_AMDGPU_MACH_AMDGCN_GFX902
Definition: ELF.h:747
llvm::ELF::EM_FIREPATH
@ EM_FIREPATH
Definition: ELF.h:194
llvm::ELF::ELFCLASS32
@ ELFCLASS32
Definition: ELF.h:328
llvm::ELF::SHN_MIPS_DATA
@ SHN_MIPS_DATA
Definition: ELF.h:571
llvm::ELF::EM_AARCH64
@ EM_AARCH64
Definition: ELF.h:280
llvm::ELF::EM_UNICORE
@ EM_UNICORE
Definition: ELF.h:227
llvm::ELF::PT_NULL
@ PT_NULL
Definition: ELF.h:1336
llvm::ELF::EM_M32
@ EM_M32
Definition: ELF.h:134
llvm::ELF::NT_FREEBSD_PROCSTAT_VMMAP
@ NT_FREEBSD_PROCSTAT_VMMAP
Definition: ELF.h:1671
llvm::ELF::STO_RISCV_VARIANT_CC
@ STO_RISCV_VARIANT_CC
Definition: ELF.h:681
llvm::ELF::EF_AVR_ARCH_MASK
@ EF_AVR_ARCH_MASK
Definition: ELF.h:494
llvm::ELF::EF_AMDGPU_MACH_R600_CEDAR
@ EF_AMDGPU_MACH_R600_CEDAR
Definition: ELF.h:714
llvm::ELF::EF_AVR_ARCH_XMEGA1
@ EF_AVR_ARCH_XMEGA1
Definition: ELF.h:486
llvm::ELFYAML::ProgramHeader::VAddr
llvm::yaml::Hex64 VAddr
Definition: ELFYAML.h:681
llvm::ELF::EM_DXP
@ EM_DXP
Definition: ELF.h:230
llvm::ELF::EF_HEXAGON_MACH_V67T
@ EF_HEXAGON_MACH_V67T
Definition: ELF.h:619
llvm::ELFYAML::FileHeader::OSABI
ELF_ELFOSABI OSABI
Definition: ELFYAML.h:115
llvm::ELF::NT_OPENBSD_PROCINFO
@ NT_OPENBSD_PROCINFO
Definition: ELF.h:1689
llvm::Mips::AFL_REG_NONE
@ AFL_REG_NONE
Definition: MipsABIFlags.h:24
llvm::ELF::EF_ARM_EABI_VER1
@ EF_ARM_EABI_VER1
Definition: ELF.h:439
llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX904
@ EF_AMDGPU_MACH_AMDGCN_GFX904
Definition: ELF.h:748
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
@ EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
Definition: ELF.h:806
llvm::ELF::EF_HEXAGON_ISA_V69
@ EF_HEXAGON_ISA_V69
Definition: ELF.h:638
llvm::ELF::EM_ALTERA_NIOS2
@ EM_ALTERA_NIOS2
Definition: ELF.h:231
llvm::ELF::EF_RISCV_RVC
@ EF_RISCV_RVC
Definition: ELF.h:663
llvm::ELF::EM_68HC08
@ EM_68HC08
Definition: ELF.h:187
llvm::ELF::EM_ARC_COMPACT
@ EM_ARC_COMPACT
Definition: ELF.h:209
llvm::ELF::EF_MIPS_MACH_3900
@ EF_MIPS_MACH_3900
Definition: ELF.h:526
llvm::ELFYAML::StackSizeEntry
Definition: ELFYAML.h:171
llvm::ELF::EF_AMDGPU_MACH_R600_R600
@ EF_AMDGPU_MACH_R600_R600
Definition: ELF.h:705
llvm::ELF::EM_386
@ EM_386
Definition: ELF.h:136
llvm::ELF::EM_68HC05
@ EM_68HC05
Definition: ELF.h:188
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::ELF::ELFOSABI_STANDALONE
@ ELFOSABI_STANDALONE
Definition: ELF.h:366
llvm::ELF::STT_COMMON
@ STT_COMMON
Definition: ELF.h:1208
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V3
@ ELFABIVERSION_AMDGPU_HSA_V3
Definition: ELF.h:375
llvm::ELF::SHF_EXECINSTR
@ SHF_EXECINSTR
Definition: ELF.h:1041
llvm::ELFYAML::VernauxEntry
Definition: ELFYAML.h:447
llvm::ELF::EM_ECOG2
@ EM_ECOG2
Definition: ELF.h:244
llvm::ELF::EM_COLDFIRE
@ EM_COLDFIRE
Definition: ELF.h:168
llvm::ELF::EM_ZSP
@ EM_ZSP
Definition: ELF.h:195
llvm::ELFYAML::Section::getEntries
virtual std::vector< std::pair< StringRef, bool > > getEntries() const
Definition: ELFYAML.h:247
llvm::ELF::NT_FREEBSD_PROCSTAT_UMASK
@ NT_FREEBSD_PROCSTAT_UMASK
Definition: ELF.h:1673
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1193
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1072
llvm::ELF::EM_SE_C17
@ EM_SE_C17
Definition: ELF.h:249
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_V3
@ EF_AMDGPU_FEATURE_XNACK_V3
Definition: ELF.h:794
llvm::ELF::EF_HEXAGON_MACH_V62
@ EF_HEXAGON_MACH_V62
Definition: ELF.h:615
llvm::ELFYAML::ProgramHeader::Flags
ELF_PF Flags
Definition: ELFYAML.h:680
llvm::ELF::EM_VIDEOCORE5
@ EM_VIDEOCORE5
Definition: ELF.h:294
llvm::ELFYAML::FileHeader::EPhNum
Optional< llvm::yaml::Hex16 > EPhNum
Definition: ELFYAML.h:125
llvm::ELF::EM_PJ
@ EM_PJ
Definition: ELF.h:207
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1237
llvm::ELF::ELFDATANONE
@ ELFDATANONE
Definition: ELF.h:334
llvm::ELF::EM_VPP500
@ EM_VPP500
Definition: ELF.h:145
llvm::ELF::EF_RISCV_FLOAT_ABI_SINGLE
@ EF_RISCV_FLOAT_ABI_SINGLE
Definition: ELF.h:666
llvm::ELF::EF_HEXAGON_MACH_V67
@ EF_HEXAGON_MACH_V67
Definition: ELF.h:618
llvm::ELF::ELFOSABI_MODESTO
@ ELFOSABI_MODESTO
Definition: ELF.h:352
llvm::ELF::EM_F2MC16
@ EM_F2MC16
Definition: ELF.h:221
llvm::ELF::NT_NETBSDCORE_PROCINFO
@ NT_NETBSDCORE_PROCINFO
Definition: ELF.h:1682
llvm::ELF::EM_IA_64
@ EM_IA_64
Definition: ELF.h:166
llvm::ELF::SHT_ARM_ATTRIBUTES
@ SHT_ARM_ATTRIBUTES
Definition: ELF.h:1009
llvm::yaml::setStringValue
static void setStringValue(IO &IO, const char *Key, StringRef Val)
Definition: ELFYAML.cpp:1501
llvm::ELF::EF_MIPS_MACH_4120
@ EF_MIPS_MACH_4120
Definition: ELF.h:530
INT64_MIN
#define INT64_MIN
Definition: DataTypes.h:74
llvm::ELF::EM_68HC12
@ EM_68HC12
Definition: ELF.h:169