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