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