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