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