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