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