1 //===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines classes for handling the YAML representation of ELF.
11 //===----------------------------------------------------------------------===//
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"
30 ELFYAML::Chunk::~Chunk() = default;
33 ELF_ELFOSABI
Object::getOSAbi() const { return Header
.OSABI
; }
35 unsigned Object::getMachine() const {
37 return *Header
.Machine
;
38 return llvm::ELF::EM_NONE
;
41 constexpr StringRef
SectionHeaderTable::TypeStr
;
42 } // namespace ELFYAML
46 void ScalarEnumerationTraits
<ELFYAML::ELF_ET
>::enumeration(
47 IO
&IO
, ELFYAML::ELF_ET
&Value
) {
48 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
55 IO
.enumFallback
<Hex16
>(Value
);
58 void ScalarEnumerationTraits
<ELFYAML::ELF_PT
>::enumeration(
59 IO
&IO
, ELFYAML::ELF_PT
&Value
) {
60 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
69 ECase(PT_GNU_EH_FRAME
);
72 ECase(PT_GNU_PROPERTY
);
74 IO
.enumFallback
<Hex32
>(Value
);
77 void ScalarEnumerationTraits
<ELFYAML::ELF_NT
>::enumeration(
78 IO
&IO
, ELFYAML::ELF_NT
&Value
) {
79 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
80 // Generic note types.
83 ECase(NT_GNU_BUILD_ATTRIBUTE_OPEN
);
84 ECase(NT_GNU_BUILD_ATTRIBUTE_FUNC
);
96 ECase(NT_WIN32PSTATUS
);
104 ECase(NT_PPC_TM_CGPR
);
105 ECase(NT_PPC_TM_CFPR
);
106 ECase(NT_PPC_TM_CVMX
);
107 ECase(NT_PPC_TM_CVSX
);
108 ECase(NT_PPC_TM_SPR
);
109 ECase(NT_PPC_TM_CTAR
);
110 ECase(NT_PPC_TM_CPPR
);
111 ECase(NT_PPC_TM_CDSCR
);
113 ECase(NT_386_IOPERM
);
114 ECase(NT_X86_XSTATE
);
115 ECase(NT_S390_HIGH_GPRS
);
116 ECase(NT_S390_TIMER
);
117 ECase(NT_S390_TODCMP
);
118 ECase(NT_S390_TODPREG
);
120 ECase(NT_S390_PREFIX
);
121 ECase(NT_S390_LAST_BREAK
);
122 ECase(NT_S390_SYSTEM_CALL
);
124 ECase(NT_S390_VXRS_LOW
);
125 ECase(NT_S390_VXRS_HIGH
);
126 ECase(NT_S390_GS_CB
);
127 ECase(NT_S390_GS_BC
);
130 ECase(NT_ARM_HW_BREAK
);
131 ECase(NT_ARM_HW_WATCH
);
133 ECase(NT_ARM_PAC_MASK
);
134 ECase(NT_ARM_TAGGED_ADDR_CTRL
);
141 // LLVM-specific notes.
142 ECase(NT_LLVM_HWASAN_GLOBALS
);
144 ECase(NT_GNU_ABI_TAG
);
146 ECase(NT_GNU_BUILD_ID
);
147 ECase(NT_GNU_GOLD_VERSION
);
148 ECase(NT_GNU_PROPERTY_TYPE_0
);
149 // FreeBSD note types.
150 ECase(NT_FREEBSD_ABI_TAG
);
151 ECase(NT_FREEBSD_NOINIT_TAG
);
152 ECase(NT_FREEBSD_ARCH_TAG
);
153 ECase(NT_FREEBSD_FEATURE_CTL
);
154 // FreeBSD core note types.
155 ECase(NT_FREEBSD_THRMISC
);
156 ECase(NT_FREEBSD_PROCSTAT_PROC
);
157 ECase(NT_FREEBSD_PROCSTAT_FILES
);
158 ECase(NT_FREEBSD_PROCSTAT_VMMAP
);
159 ECase(NT_FREEBSD_PROCSTAT_GROUPS
);
160 ECase(NT_FREEBSD_PROCSTAT_UMASK
);
161 ECase(NT_FREEBSD_PROCSTAT_RLIMIT
);
162 ECase(NT_FREEBSD_PROCSTAT_OSREL
);
163 ECase(NT_FREEBSD_PROCSTAT_PSSTRINGS
);
164 ECase(NT_FREEBSD_PROCSTAT_AUXV
);
165 // NetBSD core note types.
166 ECase(NT_NETBSDCORE_PROCINFO
);
167 ECase(NT_NETBSDCORE_AUXV
);
168 ECase(NT_NETBSDCORE_LWPSTATUS
);
169 // OpenBSD core note types.
170 ECase(NT_OPENBSD_PROCINFO
);
171 ECase(NT_OPENBSD_AUXV
);
172 ECase(NT_OPENBSD_REGS
);
173 ECase(NT_OPENBSD_FPREGS
);
174 ECase(NT_OPENBSD_XFPREGS
);
175 ECase(NT_OPENBSD_WCOOKIE
);
176 // AMD specific notes. (Code Object V2)
177 ECase(NT_AMD_HSA_CODE_OBJECT_VERSION
);
178 ECase(NT_AMD_HSA_HSAIL
);
179 ECase(NT_AMD_HSA_ISA_VERSION
);
180 ECase(NT_AMD_HSA_METADATA
);
181 ECase(NT_AMD_HSA_ISA_NAME
);
182 ECase(NT_AMD_PAL_METADATA
);
183 // AMDGPU specific notes. (Code Object V3)
184 ECase(NT_AMDGPU_METADATA
);
185 // Android specific notes.
186 ECase(NT_ANDROID_TYPE_IDENT
);
187 ECase(NT_ANDROID_TYPE_KUSER
);
188 ECase(NT_ANDROID_TYPE_MEMTAG
);
190 IO
.enumFallback
<Hex32
>(Value
);
193 void ScalarEnumerationTraits
<ELFYAML::ELF_EM
>::enumeration(
194 IO
&IO
, ELFYAML::ELF_EM
&Value
) {
195 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
206 ECase(EM_MIPS_RS3_LE
);
209 ECase(EM_SPARC32PLUS
);
272 ECase(EM_ARC_COMPACT
);
292 ECase(EM_ALTERA_NIOS2
);
306 ECase(EM_VIDEOCORE3
);
307 ECase(EM_LATTICEMICO32
);
312 ECase(EM_MMDSP_PLUS
);
313 ECase(EM_CYPRESS_M8C
);
328 ECase(EM_MCST_ELBRUS
);
340 ECase(EM_MICROBLAZE
);
343 ECase(EM_CLOUDSHIELD
);
346 ECase(EM_ARC_COMPACT2
);
349 ECase(EM_VIDEOCORE5
);
360 IO
.enumFallback
<Hex16
>(Value
);
363 void ScalarEnumerationTraits
<ELFYAML::ELF_ELFCLASS
>::enumeration(
364 IO
&IO
, ELFYAML::ELF_ELFCLASS
&Value
) {
365 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
366 // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
373 void ScalarEnumerationTraits
<ELFYAML::ELF_ELFDATA
>::enumeration(
374 IO
&IO
, ELFYAML::ELF_ELFDATA
&Value
) {
375 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
376 // ELFDATANONE is an invalid data encoding, but we accept it because
377 // we want to be able to produce invalid binaries for the tests.
384 void ScalarEnumerationTraits
<ELFYAML::ELF_ELFOSABI
>::enumeration(
385 IO
&IO
, ELFYAML::ELF_ELFOSABI
&Value
) {
386 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
387 ECase(ELFOSABI_NONE
);
388 ECase(ELFOSABI_HPUX
);
389 ECase(ELFOSABI_NETBSD
);
391 ECase(ELFOSABI_LINUX
);
392 ECase(ELFOSABI_HURD
);
393 ECase(ELFOSABI_SOLARIS
);
395 ECase(ELFOSABI_IRIX
);
396 ECase(ELFOSABI_FREEBSD
);
397 ECase(ELFOSABI_TRU64
);
398 ECase(ELFOSABI_MODESTO
);
399 ECase(ELFOSABI_OPENBSD
);
400 ECase(ELFOSABI_OPENVMS
);
402 ECase(ELFOSABI_AROS
);
403 ECase(ELFOSABI_FENIXOS
);
404 ECase(ELFOSABI_CLOUDABI
);
405 ECase(ELFOSABI_AMDGPU_HSA
);
406 ECase(ELFOSABI_AMDGPU_PAL
);
407 ECase(ELFOSABI_AMDGPU_MESA3D
);
409 ECase(ELFOSABI_C6000_ELFABI
);
410 ECase(ELFOSABI_C6000_LINUX
);
411 ECase(ELFOSABI_STANDALONE
);
413 IO
.enumFallback
<Hex8
>(Value
);
416 void ScalarBitSetTraits
<ELFYAML::ELF_EF
>::bitset(IO
&IO
,
417 ELFYAML::ELF_EF
&Value
) {
418 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
419 assert(Object
&& "The IO context is not initialized");
420 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
421 #define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
422 switch (Object
->getMachine()) {
424 BCase(EF_ARM_SOFT_FLOAT
);
425 BCase(EF_ARM_VFP_FLOAT
);
426 BCaseMask(EF_ARM_EABI_UNKNOWN
, EF_ARM_EABIMASK
);
427 BCaseMask(EF_ARM_EABI_VER1
, EF_ARM_EABIMASK
);
428 BCaseMask(EF_ARM_EABI_VER2
, EF_ARM_EABIMASK
);
429 BCaseMask(EF_ARM_EABI_VER3
, EF_ARM_EABIMASK
);
430 BCaseMask(EF_ARM_EABI_VER4
, EF_ARM_EABIMASK
);
431 BCaseMask(EF_ARM_EABI_VER5
, EF_ARM_EABIMASK
);
432 BCaseMask(EF_ARM_BE8
, EF_ARM_BE8
);
435 BCase(EF_MIPS_NOREORDER
);
439 BCase(EF_MIPS_32BITMODE
);
441 BCase(EF_MIPS_NAN2008
);
442 BCase(EF_MIPS_MICROMIPS
);
443 BCase(EF_MIPS_ARCH_ASE_M16
);
444 BCase(EF_MIPS_ARCH_ASE_MDMX
);
445 BCaseMask(EF_MIPS_ABI_O32
, EF_MIPS_ABI
);
446 BCaseMask(EF_MIPS_ABI_O64
, EF_MIPS_ABI
);
447 BCaseMask(EF_MIPS_ABI_EABI32
, EF_MIPS_ABI
);
448 BCaseMask(EF_MIPS_ABI_EABI64
, EF_MIPS_ABI
);
449 BCaseMask(EF_MIPS_MACH_3900
, EF_MIPS_MACH
);
450 BCaseMask(EF_MIPS_MACH_4010
, EF_MIPS_MACH
);
451 BCaseMask(EF_MIPS_MACH_4100
, EF_MIPS_MACH
);
452 BCaseMask(EF_MIPS_MACH_4650
, EF_MIPS_MACH
);
453 BCaseMask(EF_MIPS_MACH_4120
, EF_MIPS_MACH
);
454 BCaseMask(EF_MIPS_MACH_4111
, EF_MIPS_MACH
);
455 BCaseMask(EF_MIPS_MACH_SB1
, EF_MIPS_MACH
);
456 BCaseMask(EF_MIPS_MACH_OCTEON
, EF_MIPS_MACH
);
457 BCaseMask(EF_MIPS_MACH_XLR
, EF_MIPS_MACH
);
458 BCaseMask(EF_MIPS_MACH_OCTEON2
, EF_MIPS_MACH
);
459 BCaseMask(EF_MIPS_MACH_OCTEON3
, EF_MIPS_MACH
);
460 BCaseMask(EF_MIPS_MACH_5400
, EF_MIPS_MACH
);
461 BCaseMask(EF_MIPS_MACH_5900
, EF_MIPS_MACH
);
462 BCaseMask(EF_MIPS_MACH_5500
, EF_MIPS_MACH
);
463 BCaseMask(EF_MIPS_MACH_9000
, EF_MIPS_MACH
);
464 BCaseMask(EF_MIPS_MACH_LS2E
, EF_MIPS_MACH
);
465 BCaseMask(EF_MIPS_MACH_LS2F
, EF_MIPS_MACH
);
466 BCaseMask(EF_MIPS_MACH_LS3A
, EF_MIPS_MACH
);
467 BCaseMask(EF_MIPS_ARCH_1
, EF_MIPS_ARCH
);
468 BCaseMask(EF_MIPS_ARCH_2
, EF_MIPS_ARCH
);
469 BCaseMask(EF_MIPS_ARCH_3
, EF_MIPS_ARCH
);
470 BCaseMask(EF_MIPS_ARCH_4
, EF_MIPS_ARCH
);
471 BCaseMask(EF_MIPS_ARCH_5
, EF_MIPS_ARCH
);
472 BCaseMask(EF_MIPS_ARCH_32
, EF_MIPS_ARCH
);
473 BCaseMask(EF_MIPS_ARCH_64
, EF_MIPS_ARCH
);
474 BCaseMask(EF_MIPS_ARCH_32R2
, EF_MIPS_ARCH
);
475 BCaseMask(EF_MIPS_ARCH_64R2
, EF_MIPS_ARCH
);
476 BCaseMask(EF_MIPS_ARCH_32R6
, EF_MIPS_ARCH
);
477 BCaseMask(EF_MIPS_ARCH_64R6
, EF_MIPS_ARCH
);
479 case ELF::EM_HEXAGON
:
480 BCaseMask(EF_HEXAGON_MACH_V2
, EF_HEXAGON_MACH
);
481 BCaseMask(EF_HEXAGON_MACH_V3
, EF_HEXAGON_MACH
);
482 BCaseMask(EF_HEXAGON_MACH_V4
, EF_HEXAGON_MACH
);
483 BCaseMask(EF_HEXAGON_MACH_V5
, EF_HEXAGON_MACH
);
484 BCaseMask(EF_HEXAGON_MACH_V55
, EF_HEXAGON_MACH
);
485 BCaseMask(EF_HEXAGON_MACH_V60
, EF_HEXAGON_MACH
);
486 BCaseMask(EF_HEXAGON_MACH_V62
, EF_HEXAGON_MACH
);
487 BCaseMask(EF_HEXAGON_MACH_V65
, EF_HEXAGON_MACH
);
488 BCaseMask(EF_HEXAGON_MACH_V66
, EF_HEXAGON_MACH
);
489 BCaseMask(EF_HEXAGON_MACH_V67
, EF_HEXAGON_MACH
);
490 BCaseMask(EF_HEXAGON_MACH_V67T
, EF_HEXAGON_MACH
);
491 BCaseMask(EF_HEXAGON_MACH_V68
, EF_HEXAGON_MACH
);
492 BCaseMask(EF_HEXAGON_MACH_V69
, EF_HEXAGON_MACH
);
493 BCaseMask(EF_HEXAGON_MACH_V71
, EF_HEXAGON_MACH
);
494 BCaseMask(EF_HEXAGON_MACH_V71T
, EF_HEXAGON_MACH
);
495 BCaseMask(EF_HEXAGON_MACH_V73
, EF_HEXAGON_MACH
);
496 BCaseMask(EF_HEXAGON_ISA_V2
, EF_HEXAGON_ISA
);
497 BCaseMask(EF_HEXAGON_ISA_V3
, EF_HEXAGON_ISA
);
498 BCaseMask(EF_HEXAGON_ISA_V4
, EF_HEXAGON_ISA
);
499 BCaseMask(EF_HEXAGON_ISA_V5
, EF_HEXAGON_ISA
);
500 BCaseMask(EF_HEXAGON_ISA_V55
, EF_HEXAGON_ISA
);
501 BCaseMask(EF_HEXAGON_ISA_V60
, EF_HEXAGON_ISA
);
502 BCaseMask(EF_HEXAGON_ISA_V62
, EF_HEXAGON_ISA
);
503 BCaseMask(EF_HEXAGON_ISA_V65
, EF_HEXAGON_ISA
);
504 BCaseMask(EF_HEXAGON_ISA_V66
, EF_HEXAGON_ISA
);
505 BCaseMask(EF_HEXAGON_ISA_V67
, EF_HEXAGON_ISA
);
506 BCaseMask(EF_HEXAGON_ISA_V68
, EF_HEXAGON_ISA
);
507 BCaseMask(EF_HEXAGON_ISA_V69
, EF_HEXAGON_ISA
);
508 BCaseMask(EF_HEXAGON_ISA_V71
, EF_HEXAGON_ISA
);
509 BCaseMask(EF_HEXAGON_ISA_V73
, EF_HEXAGON_ISA
);
512 BCaseMask(EF_AVR_ARCH_AVR1
, EF_AVR_ARCH_MASK
);
513 BCaseMask(EF_AVR_ARCH_AVR2
, EF_AVR_ARCH_MASK
);
514 BCaseMask(EF_AVR_ARCH_AVR25
, EF_AVR_ARCH_MASK
);
515 BCaseMask(EF_AVR_ARCH_AVR3
, EF_AVR_ARCH_MASK
);
516 BCaseMask(EF_AVR_ARCH_AVR31
, EF_AVR_ARCH_MASK
);
517 BCaseMask(EF_AVR_ARCH_AVR35
, EF_AVR_ARCH_MASK
);
518 BCaseMask(EF_AVR_ARCH_AVR4
, EF_AVR_ARCH_MASK
);
519 BCaseMask(EF_AVR_ARCH_AVR5
, EF_AVR_ARCH_MASK
);
520 BCaseMask(EF_AVR_ARCH_AVR51
, EF_AVR_ARCH_MASK
);
521 BCaseMask(EF_AVR_ARCH_AVR6
, EF_AVR_ARCH_MASK
);
522 BCaseMask(EF_AVR_ARCH_AVRTINY
, EF_AVR_ARCH_MASK
);
523 BCaseMask(EF_AVR_ARCH_XMEGA1
, EF_AVR_ARCH_MASK
);
524 BCaseMask(EF_AVR_ARCH_XMEGA2
, EF_AVR_ARCH_MASK
);
525 BCaseMask(EF_AVR_ARCH_XMEGA3
, EF_AVR_ARCH_MASK
);
526 BCaseMask(EF_AVR_ARCH_XMEGA4
, EF_AVR_ARCH_MASK
);
527 BCaseMask(EF_AVR_ARCH_XMEGA5
, EF_AVR_ARCH_MASK
);
528 BCaseMask(EF_AVR_ARCH_XMEGA6
, EF_AVR_ARCH_MASK
);
529 BCaseMask(EF_AVR_ARCH_XMEGA7
, EF_AVR_ARCH_MASK
);
530 BCase(EF_AVR_LINKRELAX_PREPARED
);
532 case ELF::EM_LOONGARCH
:
533 BCaseMask(EF_LOONGARCH_ABI_SOFT_FLOAT
, EF_LOONGARCH_ABI_MODIFIER_MASK
);
534 BCaseMask(EF_LOONGARCH_ABI_SINGLE_FLOAT
, EF_LOONGARCH_ABI_MODIFIER_MASK
);
535 BCaseMask(EF_LOONGARCH_ABI_DOUBLE_FLOAT
, EF_LOONGARCH_ABI_MODIFIER_MASK
);
536 BCaseMask(EF_LOONGARCH_OBJABI_V0
, EF_LOONGARCH_OBJABI_MASK
);
537 BCaseMask(EF_LOONGARCH_OBJABI_V1
, EF_LOONGARCH_OBJABI_MASK
);
541 BCaseMask(EF_RISCV_FLOAT_ABI_SOFT
, EF_RISCV_FLOAT_ABI
);
542 BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE
, EF_RISCV_FLOAT_ABI
);
543 BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE
, EF_RISCV_FLOAT_ABI
);
544 BCaseMask(EF_RISCV_FLOAT_ABI_QUAD
, EF_RISCV_FLOAT_ABI
);
549 BCase(EF_XTENSA_XT_INSN
);
550 BCaseMask(EF_XTENSA_MACH_NONE
, EF_XTENSA_MACH
);
551 BCase(EF_XTENSA_XT_LIT
);
554 BCaseMask(EF_AMDGPU_MACH_NONE
, EF_AMDGPU_MACH
);
555 BCaseMask(EF_AMDGPU_MACH_R600_R600
, EF_AMDGPU_MACH
);
556 BCaseMask(EF_AMDGPU_MACH_R600_R630
, EF_AMDGPU_MACH
);
557 BCaseMask(EF_AMDGPU_MACH_R600_RS880
, EF_AMDGPU_MACH
);
558 BCaseMask(EF_AMDGPU_MACH_R600_RV670
, EF_AMDGPU_MACH
);
559 BCaseMask(EF_AMDGPU_MACH_R600_RV710
, EF_AMDGPU_MACH
);
560 BCaseMask(EF_AMDGPU_MACH_R600_RV730
, EF_AMDGPU_MACH
);
561 BCaseMask(EF_AMDGPU_MACH_R600_RV770
, EF_AMDGPU_MACH
);
562 BCaseMask(EF_AMDGPU_MACH_R600_CEDAR
, EF_AMDGPU_MACH
);
563 BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS
, EF_AMDGPU_MACH
);
564 BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER
, EF_AMDGPU_MACH
);
565 BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD
, EF_AMDGPU_MACH
);
566 BCaseMask(EF_AMDGPU_MACH_R600_SUMO
, EF_AMDGPU_MACH
);
567 BCaseMask(EF_AMDGPU_MACH_R600_BARTS
, EF_AMDGPU_MACH
);
568 BCaseMask(EF_AMDGPU_MACH_R600_CAICOS
, EF_AMDGPU_MACH
);
569 BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN
, EF_AMDGPU_MACH
);
570 BCaseMask(EF_AMDGPU_MACH_R600_TURKS
, EF_AMDGPU_MACH
);
571 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600
, EF_AMDGPU_MACH
);
572 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601
, EF_AMDGPU_MACH
);
573 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX602
, EF_AMDGPU_MACH
);
574 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700
, EF_AMDGPU_MACH
);
575 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701
, EF_AMDGPU_MACH
);
576 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702
, EF_AMDGPU_MACH
);
577 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703
, EF_AMDGPU_MACH
);
578 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704
, EF_AMDGPU_MACH
);
579 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX705
, EF_AMDGPU_MACH
);
580 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801
, EF_AMDGPU_MACH
);
581 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802
, EF_AMDGPU_MACH
);
582 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803
, EF_AMDGPU_MACH
);
583 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX805
, EF_AMDGPU_MACH
);
584 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810
, EF_AMDGPU_MACH
);
585 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900
, EF_AMDGPU_MACH
);
586 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902
, EF_AMDGPU_MACH
);
587 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904
, EF_AMDGPU_MACH
);
588 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906
, EF_AMDGPU_MACH
);
589 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX908
, EF_AMDGPU_MACH
);
590 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909
, EF_AMDGPU_MACH
);
591 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90A
, EF_AMDGPU_MACH
);
592 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90C
, EF_AMDGPU_MACH
);
593 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX940
, EF_AMDGPU_MACH
);
594 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX941
, EF_AMDGPU_MACH
);
595 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX942
, EF_AMDGPU_MACH
);
596 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010
, EF_AMDGPU_MACH
);
597 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1011
, EF_AMDGPU_MACH
);
598 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1012
, EF_AMDGPU_MACH
);
599 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1013
, EF_AMDGPU_MACH
);
600 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1030
, EF_AMDGPU_MACH
);
601 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1031
, EF_AMDGPU_MACH
);
602 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1032
, EF_AMDGPU_MACH
);
603 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1033
, EF_AMDGPU_MACH
);
604 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1034
, EF_AMDGPU_MACH
);
605 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1035
, EF_AMDGPU_MACH
);
606 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1036
, EF_AMDGPU_MACH
);
607 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1100
, EF_AMDGPU_MACH
);
608 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1101
, EF_AMDGPU_MACH
);
609 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1102
, EF_AMDGPU_MACH
);
610 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1103
, EF_AMDGPU_MACH
);
611 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1150
, EF_AMDGPU_MACH
);
612 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1151
, EF_AMDGPU_MACH
);
613 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1200
, EF_AMDGPU_MACH
);
614 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1201
, EF_AMDGPU_MACH
);
615 switch (Object
->Header
.ABIVersion
) {
617 // ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags.
619 case ELF::ELFABIVERSION_AMDGPU_HSA_V3
:
620 BCase(EF_AMDGPU_FEATURE_XNACK_V3
);
621 BCase(EF_AMDGPU_FEATURE_SRAMECC_V3
);
623 case ELF::ELFABIVERSION_AMDGPU_HSA_V4
:
624 case ELF::ELFABIVERSION_AMDGPU_HSA_V5
:
625 BCaseMask(EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
,
626 EF_AMDGPU_FEATURE_XNACK_V4
);
627 BCaseMask(EF_AMDGPU_FEATURE_XNACK_ANY_V4
,
628 EF_AMDGPU_FEATURE_XNACK_V4
);
629 BCaseMask(EF_AMDGPU_FEATURE_XNACK_OFF_V4
,
630 EF_AMDGPU_FEATURE_XNACK_V4
);
631 BCaseMask(EF_AMDGPU_FEATURE_XNACK_ON_V4
,
632 EF_AMDGPU_FEATURE_XNACK_V4
);
633 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
,
634 EF_AMDGPU_FEATURE_SRAMECC_V4
);
635 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
,
636 EF_AMDGPU_FEATURE_SRAMECC_V4
);
637 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
,
638 EF_AMDGPU_FEATURE_SRAMECC_V4
);
639 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4
,
640 EF_AMDGPU_FEATURE_SRAMECC_V4
);
651 void ScalarEnumerationTraits
<ELFYAML::ELF_SHT
>::enumeration(
652 IO
&IO
, ELFYAML::ELF_SHT
&Value
) {
653 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
654 assert(Object
&& "The IO context is not initialized");
655 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
659 // FIXME: Issue a diagnostic with this information.
669 ECase(SHT_INIT_ARRAY
);
670 ECase(SHT_FINI_ARRAY
);
671 ECase(SHT_PREINIT_ARRAY
);
673 ECase(SHT_SYMTAB_SHNDX
);
675 ECase(SHT_ANDROID_REL
);
676 ECase(SHT_ANDROID_RELA
);
677 ECase(SHT_ANDROID_RELR
);
678 ECase(SHT_LLVM_ODRTAB
);
679 ECase(SHT_LLVM_LINKER_OPTIONS
);
680 ECase(SHT_LLVM_CALL_GRAPH_PROFILE
);
681 ECase(SHT_LLVM_ADDRSIG
);
682 ECase(SHT_LLVM_DEPENDENT_LIBRARIES
);
683 ECase(SHT_LLVM_SYMPART
);
684 ECase(SHT_LLVM_PART_EHDR
);
685 ECase(SHT_LLVM_PART_PHDR
);
686 ECase(SHT_LLVM_BB_ADDR_MAP_V0
);
687 ECase(SHT_LLVM_BB_ADDR_MAP
);
688 ECase(SHT_LLVM_OFFLOADING
);
690 ECase(SHT_GNU_ATTRIBUTES
);
692 ECase(SHT_GNU_verdef
);
693 ECase(SHT_GNU_verneed
);
694 ECase(SHT_GNU_versym
);
695 switch (Object
->getMachine()) {
697 ECase(SHT_ARM_EXIDX
);
698 ECase(SHT_ARM_PREEMPTMAP
);
699 ECase(SHT_ARM_ATTRIBUTES
);
700 ECase(SHT_ARM_DEBUGOVERLAY
);
701 ECase(SHT_ARM_OVERLAYSECTION
);
703 case ELF::EM_HEXAGON
:
704 ECase(SHT_HEX_ORDERED
);
707 ECase(SHT_X86_64_UNWIND
);
710 ECase(SHT_MIPS_REGINFO
);
711 ECase(SHT_MIPS_OPTIONS
);
712 ECase(SHT_MIPS_DWARF
);
713 ECase(SHT_MIPS_ABIFLAGS
);
716 ECase(SHT_RISCV_ATTRIBUTES
);
719 ECase(SHT_MSP430_ATTRIBUTES
);
721 case ELF::EM_AARCH64
:
722 ECase(SHT_AARCH64_AUTH_RELR
);
723 ECase(SHT_AARCH64_MEMTAG_GLOBALS_STATIC
);
724 ECase(SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC
);
731 IO
.enumFallback
<Hex32
>(Value
);
734 void ScalarBitSetTraits
<ELFYAML::ELF_PF
>::bitset(IO
&IO
,
735 ELFYAML::ELF_PF
&Value
) {
736 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
742 void ScalarBitSetTraits
<ELFYAML::ELF_SHF
>::bitset(IO
&IO
,
743 ELFYAML::ELF_SHF
&Value
) {
744 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
745 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
749 BCase(SHF_EXECINSTR
);
752 BCase(SHF_INFO_LINK
);
753 BCase(SHF_LINK_ORDER
);
754 BCase(SHF_OS_NONCONFORMING
);
757 BCase(SHF_COMPRESSED
);
758 switch (Object
->getOSAbi()) {
759 case ELF::ELFOSABI_SOLARIS
:
760 BCase(SHF_SUNW_NODISCARD
);
763 BCase(SHF_GNU_RETAIN
);
766 switch (Object
->getMachine()) {
768 BCase(SHF_ARM_PURECODE
);
770 case ELF::EM_HEXAGON
:
771 BCase(SHF_HEX_GPREL
);
774 BCase(SHF_MIPS_NODUPES
);
775 BCase(SHF_MIPS_NAMES
);
776 BCase(SHF_MIPS_LOCAL
);
777 BCase(SHF_MIPS_NOSTRIP
);
778 BCase(SHF_MIPS_GPREL
);
779 BCase(SHF_MIPS_MERGE
);
780 BCase(SHF_MIPS_ADDR
);
781 BCase(SHF_MIPS_STRING
);
784 BCase(SHF_X86_64_LARGE
);
793 void ScalarEnumerationTraits
<ELFYAML::ELF_SHN
>::enumeration(
794 IO
&IO
, ELFYAML::ELF_SHN
&Value
) {
795 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
796 assert(Object
&& "The IO context is not initialized");
797 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
799 ECase(SHN_LORESERVE
);
807 ECase(SHN_HIRESERVE
);
808 ECase(SHN_AMDGPU_LDS
);
810 if (!IO
.outputting() || Object
->getMachine() == ELF::EM_MIPS
) {
811 ECase(SHN_MIPS_ACOMMON
);
812 ECase(SHN_MIPS_TEXT
);
813 ECase(SHN_MIPS_DATA
);
814 ECase(SHN_MIPS_SCOMMON
);
815 ECase(SHN_MIPS_SUNDEFINED
);
818 ECase(SHN_HEXAGON_SCOMMON
);
819 ECase(SHN_HEXAGON_SCOMMON_1
);
820 ECase(SHN_HEXAGON_SCOMMON_2
);
821 ECase(SHN_HEXAGON_SCOMMON_4
);
822 ECase(SHN_HEXAGON_SCOMMON_8
);
824 IO
.enumFallback
<Hex16
>(Value
);
827 void ScalarEnumerationTraits
<ELFYAML::ELF_STB
>::enumeration(
828 IO
&IO
, ELFYAML::ELF_STB
&Value
) {
829 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
833 ECase(STB_GNU_UNIQUE
);
835 IO
.enumFallback
<Hex8
>(Value
);
838 void ScalarEnumerationTraits
<ELFYAML::ELF_STT
>::enumeration(
839 IO
&IO
, ELFYAML::ELF_STT
&Value
) {
840 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
848 ECase(STT_GNU_IFUNC
);
850 IO
.enumFallback
<Hex8
>(Value
);
854 void ScalarEnumerationTraits
<ELFYAML::ELF_RSS
>::enumeration(
855 IO
&IO
, ELFYAML::ELF_RSS
&Value
) {
856 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
864 void ScalarEnumerationTraits
<ELFYAML::ELF_REL
>::enumeration(
865 IO
&IO
, ELFYAML::ELF_REL
&Value
) {
866 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
867 assert(Object
&& "The IO context is not initialized");
868 #define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
869 switch (Object
->getMachine()) {
871 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
874 #include "llvm/BinaryFormat/ELFRelocs/Mips.def"
876 case ELF::EM_HEXAGON
:
877 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
881 #include "llvm/BinaryFormat/ELFRelocs/i386.def"
883 case ELF::EM_AARCH64
:
884 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
887 #include "llvm/BinaryFormat/ELFRelocs/ARM.def"
890 #include "llvm/BinaryFormat/ELFRelocs/ARC.def"
893 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
896 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
899 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
902 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
905 #include "llvm/BinaryFormat/ELFRelocs/VE.def"
908 #include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
911 #include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
914 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
917 #include "llvm/BinaryFormat/ELFRelocs/M68k.def"
919 case ELF::EM_LOONGARCH
:
920 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
923 #include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
930 IO
.enumFallback
<Hex32
>(Value
);
933 void ScalarEnumerationTraits
<ELFYAML::ELF_DYNTAG
>::enumeration(
934 IO
&IO
, ELFYAML::ELF_DYNTAG
&Value
) {
935 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
936 assert(Object
&& "The IO context is not initialized");
938 // Disable architecture specific tags by default. We might enable them below.
939 #define AARCH64_DYNAMIC_TAG(name, value)
940 #define MIPS_DYNAMIC_TAG(name, value)
941 #define HEXAGON_DYNAMIC_TAG(name, value)
942 #define PPC_DYNAMIC_TAG(name, value)
943 #define PPC64_DYNAMIC_TAG(name, value)
944 // Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
945 #define DYNAMIC_TAG_MARKER(name, value)
947 #define STRINGIFY(X) (#X)
948 #define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
949 switch (Object
->getMachine()) {
950 case ELF::EM_AARCH64
:
951 #undef AARCH64_DYNAMIC_TAG
952 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
953 #include "llvm/BinaryFormat/DynamicTags.def"
954 #undef AARCH64_DYNAMIC_TAG
955 #define AARCH64_DYNAMIC_TAG(name, value)
958 #undef MIPS_DYNAMIC_TAG
959 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
960 #include "llvm/BinaryFormat/DynamicTags.def"
961 #undef MIPS_DYNAMIC_TAG
962 #define MIPS_DYNAMIC_TAG(name, value)
964 case ELF::EM_HEXAGON
:
965 #undef HEXAGON_DYNAMIC_TAG
966 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
967 #include "llvm/BinaryFormat/DynamicTags.def"
968 #undef HEXAGON_DYNAMIC_TAG
969 #define HEXAGON_DYNAMIC_TAG(name, value)
972 #undef PPC_DYNAMIC_TAG
973 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
974 #include "llvm/BinaryFormat/DynamicTags.def"
975 #undef PPC_DYNAMIC_TAG
976 #define PPC_DYNAMIC_TAG(name, value)
979 #undef PPC64_DYNAMIC_TAG
980 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
981 #include "llvm/BinaryFormat/DynamicTags.def"
982 #undef PPC64_DYNAMIC_TAG
983 #define PPC64_DYNAMIC_TAG(name, value)
986 #undef RISCV_DYNAMIC_TAG
987 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
988 #include "llvm/BinaryFormat/DynamicTags.def"
989 #undef RISCV_DYNAMIC_TAG
990 #define RISCV_DYNAMIC_TAG(name, value)
993 #include "llvm/BinaryFormat/DynamicTags.def"
996 #undef AARCH64_DYNAMIC_TAG
997 #undef MIPS_DYNAMIC_TAG
998 #undef HEXAGON_DYNAMIC_TAG
999 #undef PPC_DYNAMIC_TAG
1000 #undef PPC64_DYNAMIC_TAG
1001 #undef DYNAMIC_TAG_MARKER
1005 IO
.enumFallback
<Hex64
>(Value
);
1008 void ScalarEnumerationTraits
<ELFYAML::MIPS_AFL_REG
>::enumeration(
1009 IO
&IO
, ELFYAML::MIPS_AFL_REG
&Value
) {
1010 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
1018 void ScalarEnumerationTraits
<ELFYAML::MIPS_ABI_FP
>::enumeration(
1019 IO
&IO
, ELFYAML::MIPS_ABI_FP
&Value
) {
1020 #define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
1032 void ScalarEnumerationTraits
<ELFYAML::MIPS_AFL_EXT
>::enumeration(
1033 IO
&IO
, ELFYAML::MIPS_AFL_EXT
&Value
) {
1034 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
1039 ECase(EXT_LOONGSON_3A
);
1052 ECase(EXT_LOONGSON_2E
);
1053 ECase(EXT_LOONGSON_2F
);
1058 void ScalarEnumerationTraits
<ELFYAML::MIPS_ISA
>::enumeration(
1059 IO
&IO
, ELFYAML::MIPS_ISA
&Value
) {
1060 IO
.enumCase(Value
, "MIPS1", 1);
1061 IO
.enumCase(Value
, "MIPS2", 2);
1062 IO
.enumCase(Value
, "MIPS3", 3);
1063 IO
.enumCase(Value
, "MIPS4", 4);
1064 IO
.enumCase(Value
, "MIPS5", 5);
1065 IO
.enumCase(Value
, "MIPS32", 32);
1066 IO
.enumCase(Value
, "MIPS64", 64);
1067 IO
.enumFallback
<Hex32
>(Value
);
1070 void ScalarBitSetTraits
<ELFYAML::MIPS_AFL_ASE
>::bitset(
1071 IO
&IO
, ELFYAML::MIPS_AFL_ASE
&Value
) {
1072 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
1091 void ScalarBitSetTraits
<ELFYAML::MIPS_AFL_FLAGS1
>::bitset(
1092 IO
&IO
, ELFYAML::MIPS_AFL_FLAGS1
&Value
) {
1093 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
1098 void MappingTraits
<ELFYAML::SectionHeader
>::mapping(
1099 IO
&IO
, ELFYAML::SectionHeader
&SHdr
) {
1100 IO
.mapRequired("Name", SHdr
.Name
);
1103 void MappingTraits
<ELFYAML::FileHeader
>::mapping(IO
&IO
,
1104 ELFYAML::FileHeader
&FileHdr
) {
1105 IO
.mapRequired("Class", FileHdr
.Class
);
1106 IO
.mapRequired("Data", FileHdr
.Data
);
1107 IO
.mapOptional("OSABI", FileHdr
.OSABI
, ELFYAML::ELF_ELFOSABI(0));
1108 IO
.mapOptional("ABIVersion", FileHdr
.ABIVersion
, Hex8(0));
1109 IO
.mapRequired("Type", FileHdr
.Type
);
1110 IO
.mapOptional("Machine", FileHdr
.Machine
);
1111 IO
.mapOptional("Flags", FileHdr
.Flags
, ELFYAML::ELF_EF(0));
1112 IO
.mapOptional("Entry", FileHdr
.Entry
, Hex64(0));
1113 IO
.mapOptional("SectionHeaderStringTable", FileHdr
.SectionHeaderStringTable
);
1115 // obj2yaml does not dump these fields.
1116 assert(!IO
.outputting() ||
1117 (!FileHdr
.EPhOff
&& !FileHdr
.EPhEntSize
&& !FileHdr
.EPhNum
));
1118 IO
.mapOptional("EPhOff", FileHdr
.EPhOff
);
1119 IO
.mapOptional("EPhEntSize", FileHdr
.EPhEntSize
);
1120 IO
.mapOptional("EPhNum", FileHdr
.EPhNum
);
1121 IO
.mapOptional("EShEntSize", FileHdr
.EShEntSize
);
1122 IO
.mapOptional("EShOff", FileHdr
.EShOff
);
1123 IO
.mapOptional("EShNum", FileHdr
.EShNum
);
1124 IO
.mapOptional("EShStrNdx", FileHdr
.EShStrNdx
);
1127 void MappingTraits
<ELFYAML::ProgramHeader
>::mapping(
1128 IO
&IO
, ELFYAML::ProgramHeader
&Phdr
) {
1129 IO
.mapRequired("Type", Phdr
.Type
);
1130 IO
.mapOptional("Flags", Phdr
.Flags
, ELFYAML::ELF_PF(0));
1131 IO
.mapOptional("FirstSec", Phdr
.FirstSec
);
1132 IO
.mapOptional("LastSec", Phdr
.LastSec
);
1133 IO
.mapOptional("VAddr", Phdr
.VAddr
, Hex64(0));
1134 IO
.mapOptional("PAddr", Phdr
.PAddr
, Phdr
.VAddr
);
1135 IO
.mapOptional("Align", Phdr
.Align
);
1136 IO
.mapOptional("FileSize", Phdr
.FileSize
);
1137 IO
.mapOptional("MemSize", Phdr
.MemSize
);
1138 IO
.mapOptional("Offset", Phdr
.Offset
);
1141 std::string MappingTraits
<ELFYAML::ProgramHeader
>::validate(
1142 IO
&IO
, ELFYAML::ProgramHeader
&FileHdr
) {
1143 if (!FileHdr
.FirstSec
&& FileHdr
.LastSec
)
1144 return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
1145 if (FileHdr
.FirstSec
&& !FileHdr
.LastSec
)
1146 return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
1150 LLVM_YAML_STRONG_TYPEDEF(StringRef
, StOtherPiece
)
1152 template <> struct ScalarTraits
<StOtherPiece
> {
1153 static void output(const StOtherPiece
&Val
, void *, raw_ostream
&Out
) {
1156 static StringRef
input(StringRef Scalar
, void *, StOtherPiece
&Val
) {
1160 static QuotingType
mustQuote(StringRef
) { return QuotingType::None
; }
1162 template <> struct SequenceElementTraits
<StOtherPiece
> {
1163 static const bool flow
= true;
1166 template <> struct ScalarTraits
<ELFYAML::YAMLFlowString
> {
1167 static void output(const ELFYAML::YAMLFlowString
&Val
, void *,
1171 static StringRef
input(StringRef Scalar
, void *,
1172 ELFYAML::YAMLFlowString
&Val
) {
1176 static QuotingType
mustQuote(StringRef S
) {
1177 return ScalarTraits
<StringRef
>::mustQuote(S
);
1180 template <> struct SequenceElementTraits
<ELFYAML::YAMLFlowString
> {
1181 static const bool flow
= true;
1186 struct NormalizedOther
{
1187 NormalizedOther(IO
&IO
) : YamlIO(IO
) {}
1188 NormalizedOther(IO
&IO
, std::optional
<uint8_t> Original
) : YamlIO(IO
) {
1189 assert(Original
&& "This constructor is only used for outputting YAML and "
1190 "assumes a non-empty Original");
1191 std::vector
<StOtherPiece
> Ret
;
1192 const auto *Object
= static_cast<ELFYAML::Object
*>(YamlIO
.getContext());
1193 for (std::pair
<StringRef
, uint8_t> &P
:
1194 getFlags(Object
->getMachine()).takeVector()) {
1195 uint8_t FlagValue
= P
.second
;
1196 if ((*Original
& FlagValue
) != FlagValue
)
1198 *Original
&= ~FlagValue
;
1199 Ret
.push_back({P
.first
});
1202 if (*Original
!= 0) {
1203 UnknownFlagsHolder
= std::to_string(*Original
);
1204 Ret
.push_back({UnknownFlagsHolder
});
1208 Other
= std::move(Ret
);
1211 uint8_t toValue(StringRef Name
) {
1212 const auto *Object
= static_cast<ELFYAML::Object
*>(YamlIO
.getContext());
1213 MapVector
<StringRef
, uint8_t> Flags
= getFlags(Object
->getMachine());
1215 auto It
= Flags
.find(Name
);
1216 if (It
!= Flags
.end())
1220 if (to_integer(Name
, Val
))
1223 YamlIO
.setError("an unknown value is used for symbol's 'Other' field: " +
1228 std::optional
<uint8_t> denormalize(IO
&) {
1230 return std::nullopt
;
1232 for (StOtherPiece
&Val
: *Other
)
1233 Ret
|= toValue(Val
);
1237 // st_other field is used to encode symbol visibility and platform-dependent
1238 // flags and values. This method returns a name to value map that is used for
1239 // parsing and encoding this field.
1240 MapVector
<StringRef
, uint8_t> getFlags(unsigned EMachine
) {
1241 MapVector
<StringRef
, uint8_t> Map
;
1242 // STV_* values are just enumeration values. We add them in a reversed order
1243 // because when we convert the st_other to named constants when printing
1244 // YAML we want to use a maximum number of bits on each step:
1245 // when we have st_other == 3, we want to print it as STV_PROTECTED (3), but
1246 // not as STV_HIDDEN (2) + STV_INTERNAL (1).
1247 Map
["STV_PROTECTED"] = ELF::STV_PROTECTED
;
1248 Map
["STV_HIDDEN"] = ELF::STV_HIDDEN
;
1249 Map
["STV_INTERNAL"] = ELF::STV_INTERNAL
;
1250 // STV_DEFAULT is used to represent the default visibility and has a value
1251 // 0. We want to be able to read it from YAML documents, but there is no
1252 // reason to print it.
1253 if (!YamlIO
.outputting())
1254 Map
["STV_DEFAULT"] = ELF::STV_DEFAULT
;
1256 // MIPS is not consistent. All of the STO_MIPS_* values are bit flags,
1257 // except STO_MIPS_MIPS16 which overlaps them. It should be checked and
1258 // consumed first when we print the output, because we do not want to print
1259 // any other flags that have the same bits instead.
1260 if (EMachine
== ELF::EM_MIPS
) {
1261 Map
["STO_MIPS_MIPS16"] = ELF::STO_MIPS_MIPS16
;
1262 Map
["STO_MIPS_MICROMIPS"] = ELF::STO_MIPS_MICROMIPS
;
1263 Map
["STO_MIPS_PIC"] = ELF::STO_MIPS_PIC
;
1264 Map
["STO_MIPS_PLT"] = ELF::STO_MIPS_PLT
;
1265 Map
["STO_MIPS_OPTIONAL"] = ELF::STO_MIPS_OPTIONAL
;
1268 if (EMachine
== ELF::EM_AARCH64
)
1269 Map
["STO_AARCH64_VARIANT_PCS"] = ELF::STO_AARCH64_VARIANT_PCS
;
1270 if (EMachine
== ELF::EM_RISCV
)
1271 Map
["STO_RISCV_VARIANT_CC"] = ELF::STO_RISCV_VARIANT_CC
;
1276 std::optional
<std::vector
<StOtherPiece
>> Other
;
1277 std::string UnknownFlagsHolder
;
1280 } // end anonymous namespace
1282 void ScalarTraits
<ELFYAML::YAMLIntUInt
>::output(const ELFYAML::YAMLIntUInt
&Val
,
1283 void *Ctx
, raw_ostream
&Out
) {
1287 StringRef ScalarTraits
<ELFYAML::YAMLIntUInt
>::input(StringRef Scalar
, void *Ctx
,
1288 ELFYAML::YAMLIntUInt
&Val
) {
1289 const bool Is64
= static_cast<ELFYAML::Object
*>(Ctx
)->Header
.Class
==
1290 ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64
);
1291 StringRef ErrMsg
= "invalid number";
1292 // We do not accept negative hex numbers because their meaning is ambiguous.
1293 // For example, would -0xfffffffff mean 1 or INT32_MIN?
1294 if (Scalar
.empty() || Scalar
.starts_with("-0x"))
1297 if (Scalar
.starts_with("-")) {
1298 const int64_t MinVal
= Is64
? INT64_MIN
: INT32_MIN
;
1300 if (getAsSignedInteger(Scalar
, /*Radix=*/0, Int
) || (Int
< MinVal
))
1306 const uint64_t MaxVal
= Is64
? UINT64_MAX
: UINT32_MAX
;
1307 unsigned long long UInt
;
1308 if (getAsUnsignedInteger(Scalar
, /*Radix=*/0, UInt
) || (UInt
> MaxVal
))
1314 void MappingTraits
<ELFYAML::Symbol
>::mapping(IO
&IO
, ELFYAML::Symbol
&Symbol
) {
1315 IO
.mapOptional("Name", Symbol
.Name
, StringRef());
1316 IO
.mapOptional("StName", Symbol
.StName
);
1317 IO
.mapOptional("Type", Symbol
.Type
, ELFYAML::ELF_STT(0));
1318 IO
.mapOptional("Section", Symbol
.Section
);
1319 IO
.mapOptional("Index", Symbol
.Index
);
1320 IO
.mapOptional("Binding", Symbol
.Binding
, ELFYAML::ELF_STB(0));
1321 IO
.mapOptional("Value", Symbol
.Value
);
1322 IO
.mapOptional("Size", Symbol
.Size
);
1324 // Symbol's Other field is a bit special. It is usually a field that
1325 // represents st_other and holds the symbol visibility. However, on some
1326 // platforms, it can contain bit fields and regular values, or even sometimes
1327 // a crazy mix of them (see comments for NormalizedOther). Because of this, we
1328 // need special handling.
1329 MappingNormalization
<NormalizedOther
, std::optional
<uint8_t>> Keys(
1331 IO
.mapOptional("Other", Keys
->Other
);
1334 std::string MappingTraits
<ELFYAML::Symbol
>::validate(IO
&IO
,
1335 ELFYAML::Symbol
&Symbol
) {
1336 if (Symbol
.Index
&& Symbol
.Section
)
1337 return "Index and Section cannot both be specified for Symbol";
1341 static void commonSectionMapping(IO
&IO
, ELFYAML::Section
&Section
) {
1342 IO
.mapOptional("Name", Section
.Name
, StringRef());
1343 IO
.mapRequired("Type", Section
.Type
);
1344 IO
.mapOptional("Flags", Section
.Flags
);
1345 IO
.mapOptional("Address", Section
.Address
);
1346 IO
.mapOptional("Link", Section
.Link
);
1347 IO
.mapOptional("AddressAlign", Section
.AddressAlign
, Hex64(0));
1348 IO
.mapOptional("EntSize", Section
.EntSize
);
1349 IO
.mapOptional("Offset", Section
.Offset
);
1351 IO
.mapOptional("Content", Section
.Content
);
1352 IO
.mapOptional("Size", Section
.Size
);
1354 // obj2yaml does not dump these fields. They are expected to be empty when we
1355 // are producing YAML, because yaml2obj sets appropriate values for them
1356 // automatically when they are not explicitly defined.
1357 assert(!IO
.outputting() ||
1358 (!Section
.ShOffset
&& !Section
.ShSize
&& !Section
.ShName
&&
1359 !Section
.ShFlags
&& !Section
.ShType
&& !Section
.ShAddrAlign
));
1360 IO
.mapOptional("ShAddrAlign", Section
.ShAddrAlign
);
1361 IO
.mapOptional("ShName", Section
.ShName
);
1362 IO
.mapOptional("ShOffset", Section
.ShOffset
);
1363 IO
.mapOptional("ShSize", Section
.ShSize
);
1364 IO
.mapOptional("ShFlags", Section
.ShFlags
);
1365 IO
.mapOptional("ShType", Section
.ShType
);
1368 static void sectionMapping(IO
&IO
, ELFYAML::DynamicSection
&Section
) {
1369 commonSectionMapping(IO
, Section
);
1370 IO
.mapOptional("Entries", Section
.Entries
);
1373 static void sectionMapping(IO
&IO
, ELFYAML::RawContentSection
&Section
) {
1374 commonSectionMapping(IO
, Section
);
1376 // We also support reading a content as array of bytes using the ContentArray
1377 // key. obj2yaml never prints this field.
1378 assert(!IO
.outputting() || !Section
.ContentBuf
);
1379 IO
.mapOptional("ContentArray", Section
.ContentBuf
);
1380 if (Section
.ContentBuf
) {
1381 if (Section
.Content
)
1382 IO
.setError("Content and ContentArray can't be used together");
1383 Section
.Content
= yaml::BinaryRef(*Section
.ContentBuf
);
1386 IO
.mapOptional("Info", Section
.Info
);
1389 static void sectionMapping(IO
&IO
, ELFYAML::BBAddrMapSection
&Section
) {
1390 commonSectionMapping(IO
, Section
);
1391 IO
.mapOptional("Content", Section
.Content
);
1392 IO
.mapOptional("Entries", Section
.Entries
);
1393 IO
.mapOptional("PGOAnalyses", Section
.PGOAnalyses
);
1396 static void sectionMapping(IO
&IO
, ELFYAML::StackSizesSection
&Section
) {
1397 commonSectionMapping(IO
, Section
);
1398 IO
.mapOptional("Entries", Section
.Entries
);
1401 static void sectionMapping(IO
&IO
, ELFYAML::HashSection
&Section
) {
1402 commonSectionMapping(IO
, Section
);
1403 IO
.mapOptional("Bucket", Section
.Bucket
);
1404 IO
.mapOptional("Chain", Section
.Chain
);
1406 // obj2yaml does not dump these fields. They can be used to override nchain
1407 // and nbucket values for creating broken sections.
1408 assert(!IO
.outputting() || (!Section
.NBucket
&& !Section
.NChain
));
1409 IO
.mapOptional("NChain", Section
.NChain
);
1410 IO
.mapOptional("NBucket", Section
.NBucket
);
1413 static void sectionMapping(IO
&IO
, ELFYAML::NoteSection
&Section
) {
1414 commonSectionMapping(IO
, Section
);
1415 IO
.mapOptional("Notes", Section
.Notes
);
1419 static void sectionMapping(IO
&IO
, ELFYAML::GnuHashSection
&Section
) {
1420 commonSectionMapping(IO
, Section
);
1421 IO
.mapOptional("Header", Section
.Header
);
1422 IO
.mapOptional("BloomFilter", Section
.BloomFilter
);
1423 IO
.mapOptional("HashBuckets", Section
.HashBuckets
);
1424 IO
.mapOptional("HashValues", Section
.HashValues
);
1426 static void sectionMapping(IO
&IO
, ELFYAML::NoBitsSection
&Section
) {
1427 commonSectionMapping(IO
, Section
);
1430 static void sectionMapping(IO
&IO
, ELFYAML::VerdefSection
&Section
) {
1431 commonSectionMapping(IO
, Section
);
1432 IO
.mapOptional("Info", Section
.Info
);
1433 IO
.mapOptional("Entries", Section
.Entries
);
1436 static void sectionMapping(IO
&IO
, ELFYAML::SymverSection
&Section
) {
1437 commonSectionMapping(IO
, Section
);
1438 IO
.mapOptional("Entries", Section
.Entries
);
1441 static void sectionMapping(IO
&IO
, ELFYAML::VerneedSection
&Section
) {
1442 commonSectionMapping(IO
, Section
);
1443 IO
.mapOptional("Info", Section
.Info
);
1444 IO
.mapOptional("Dependencies", Section
.VerneedV
);
1447 static void sectionMapping(IO
&IO
, ELFYAML::RelocationSection
&Section
) {
1448 commonSectionMapping(IO
, Section
);
1449 IO
.mapOptional("Info", Section
.RelocatableSec
, StringRef());
1450 IO
.mapOptional("Relocations", Section
.Relocations
);
1453 static void sectionMapping(IO
&IO
, ELFYAML::RelrSection
&Section
) {
1454 commonSectionMapping(IO
, Section
);
1455 IO
.mapOptional("Entries", Section
.Entries
);
1458 static void groupSectionMapping(IO
&IO
, ELFYAML::GroupSection
&Group
) {
1459 commonSectionMapping(IO
, Group
);
1460 IO
.mapOptional("Info", Group
.Signature
);
1461 IO
.mapOptional("Members", Group
.Members
);
1464 static void sectionMapping(IO
&IO
, ELFYAML::SymtabShndxSection
&Section
) {
1465 commonSectionMapping(IO
, Section
);
1466 IO
.mapOptional("Entries", Section
.Entries
);
1469 static void sectionMapping(IO
&IO
, ELFYAML::AddrsigSection
&Section
) {
1470 commonSectionMapping(IO
, Section
);
1471 IO
.mapOptional("Symbols", Section
.Symbols
);
1474 static void fillMapping(IO
&IO
, ELFYAML::Fill
&Fill
) {
1475 IO
.mapOptional("Name", Fill
.Name
, StringRef());
1476 IO
.mapOptional("Pattern", Fill
.Pattern
);
1477 IO
.mapOptional("Offset", Fill
.Offset
);
1478 IO
.mapRequired("Size", Fill
.Size
);
1481 static void sectionHeaderTableMapping(IO
&IO
,
1482 ELFYAML::SectionHeaderTable
&SHT
) {
1483 IO
.mapOptional("Offset", SHT
.Offset
);
1484 IO
.mapOptional("Sections", SHT
.Sections
);
1485 IO
.mapOptional("Excluded", SHT
.Excluded
);
1486 IO
.mapOptional("NoHeaders", SHT
.NoHeaders
);
1489 static void sectionMapping(IO
&IO
, ELFYAML::LinkerOptionsSection
&Section
) {
1490 commonSectionMapping(IO
, Section
);
1491 IO
.mapOptional("Options", Section
.Options
);
1494 static void sectionMapping(IO
&IO
,
1495 ELFYAML::DependentLibrariesSection
&Section
) {
1496 commonSectionMapping(IO
, Section
);
1497 IO
.mapOptional("Libraries", Section
.Libs
);
1500 static void sectionMapping(IO
&IO
, ELFYAML::CallGraphProfileSection
&Section
) {
1501 commonSectionMapping(IO
, Section
);
1502 IO
.mapOptional("Entries", Section
.Entries
);
1505 void MappingTraits
<ELFYAML::SectionOrType
>::mapping(
1506 IO
&IO
, ELFYAML::SectionOrType
§ionOrType
) {
1507 IO
.mapRequired("SectionOrType", sectionOrType
.sectionNameOrType
);
1510 static void sectionMapping(IO
&IO
, ELFYAML::ARMIndexTableSection
&Section
) {
1511 commonSectionMapping(IO
, Section
);
1512 IO
.mapOptional("Entries", Section
.Entries
);
1515 static void sectionMapping(IO
&IO
, ELFYAML::MipsABIFlags
&Section
) {
1516 commonSectionMapping(IO
, Section
);
1517 IO
.mapOptional("Version", Section
.Version
, Hex16(0));
1518 IO
.mapRequired("ISA", Section
.ISALevel
);
1519 IO
.mapOptional("ISARevision", Section
.ISARevision
, Hex8(0));
1520 IO
.mapOptional("ISAExtension", Section
.ISAExtension
,
1521 ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE
));
1522 IO
.mapOptional("ASEs", Section
.ASEs
, ELFYAML::MIPS_AFL_ASE(0));
1523 IO
.mapOptional("FpABI", Section
.FpABI
,
1524 ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY
));
1525 IO
.mapOptional("GPRSize", Section
.GPRSize
,
1526 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE
));
1527 IO
.mapOptional("CPR1Size", Section
.CPR1Size
,
1528 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE
));
1529 IO
.mapOptional("CPR2Size", Section
.CPR2Size
,
1530 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE
));
1531 IO
.mapOptional("Flags1", Section
.Flags1
, ELFYAML::MIPS_AFL_FLAGS1(0));
1532 IO
.mapOptional("Flags2", Section
.Flags2
, Hex32(0));
1535 static StringRef
getStringValue(IO
&IO
, const char *Key
) {
1537 IO
.mapRequired(Key
, Val
);
1541 static void setStringValue(IO
&IO
, const char *Key
, StringRef Val
) {
1542 IO
.mapRequired(Key
, Val
);
1545 static bool isInteger(StringRef Val
) {
1547 return !Val
.getAsInteger(0, Tmp
);
1550 void MappingTraits
<std::unique_ptr
<ELFYAML::Chunk
>>::mapping(
1551 IO
&IO
, std::unique_ptr
<ELFYAML::Chunk
> &Section
) {
1552 ELFYAML::ELF_SHT Type
;
1554 if (IO
.outputting()) {
1555 if (auto *S
= dyn_cast
<ELFYAML::Section
>(Section
.get()))
1557 else if (auto *SHT
= dyn_cast
<ELFYAML::SectionHeaderTable
>(Section
.get()))
1558 TypeStr
= SHT
->TypeStr
;
1560 // When the Type string does not have a "SHT_" prefix, we know it is not a
1561 // description of a regular ELF output section.
1562 TypeStr
= getStringValue(IO
, "Type");
1563 if (TypeStr
.starts_with("SHT_") || isInteger(TypeStr
))
1564 IO
.mapRequired("Type", Type
);
1567 if (TypeStr
== "Fill") {
1568 assert(!IO
.outputting()); // We don't dump fills currently.
1569 Section
.reset(new ELFYAML::Fill());
1570 fillMapping(IO
, *cast
<ELFYAML::Fill
>(Section
.get()));
1574 if (TypeStr
== ELFYAML::SectionHeaderTable::TypeStr
) {
1575 if (IO
.outputting())
1576 setStringValue(IO
, "Type", TypeStr
);
1578 Section
.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));
1580 sectionHeaderTableMapping(
1581 IO
, *cast
<ELFYAML::SectionHeaderTable
>(Section
.get()));
1585 const auto &Obj
= *static_cast<ELFYAML::Object
*>(IO
.getContext());
1586 if (Obj
.getMachine() == ELF::EM_MIPS
&& Type
== ELF::SHT_MIPS_ABIFLAGS
) {
1587 if (!IO
.outputting())
1588 Section
.reset(new ELFYAML::MipsABIFlags());
1589 sectionMapping(IO
, *cast
<ELFYAML::MipsABIFlags
>(Section
.get()));
1593 if (Obj
.getMachine() == ELF::EM_ARM
&& Type
== ELF::SHT_ARM_EXIDX
) {
1594 if (!IO
.outputting())
1595 Section
.reset(new ELFYAML::ARMIndexTableSection());
1596 sectionMapping(IO
, *cast
<ELFYAML::ARMIndexTableSection
>(Section
.get()));
1601 case ELF::SHT_DYNAMIC
:
1602 if (!IO
.outputting())
1603 Section
.reset(new ELFYAML::DynamicSection());
1604 sectionMapping(IO
, *cast
<ELFYAML::DynamicSection
>(Section
.get()));
1608 if (!IO
.outputting())
1609 Section
.reset(new ELFYAML::RelocationSection());
1610 sectionMapping(IO
, *cast
<ELFYAML::RelocationSection
>(Section
.get()));
1613 if (!IO
.outputting())
1614 Section
.reset(new ELFYAML::RelrSection());
1615 sectionMapping(IO
, *cast
<ELFYAML::RelrSection
>(Section
.get()));
1617 case ELF::SHT_GROUP
:
1618 if (!IO
.outputting())
1619 Section
.reset(new ELFYAML::GroupSection());
1620 groupSectionMapping(IO
, *cast
<ELFYAML::GroupSection
>(Section
.get()));
1622 case ELF::SHT_NOBITS
:
1623 if (!IO
.outputting())
1624 Section
.reset(new ELFYAML::NoBitsSection());
1625 sectionMapping(IO
, *cast
<ELFYAML::NoBitsSection
>(Section
.get()));
1628 if (!IO
.outputting())
1629 Section
.reset(new ELFYAML::HashSection());
1630 sectionMapping(IO
, *cast
<ELFYAML::HashSection
>(Section
.get()));
1633 if (!IO
.outputting())
1634 Section
.reset(new ELFYAML::NoteSection());
1635 sectionMapping(IO
, *cast
<ELFYAML::NoteSection
>(Section
.get()));
1637 case ELF::SHT_GNU_HASH
:
1638 if (!IO
.outputting())
1639 Section
.reset(new ELFYAML::GnuHashSection());
1640 sectionMapping(IO
, *cast
<ELFYAML::GnuHashSection
>(Section
.get()));
1642 case ELF::SHT_GNU_verdef
:
1643 if (!IO
.outputting())
1644 Section
.reset(new ELFYAML::VerdefSection());
1645 sectionMapping(IO
, *cast
<ELFYAML::VerdefSection
>(Section
.get()));
1647 case ELF::SHT_GNU_versym
:
1648 if (!IO
.outputting())
1649 Section
.reset(new ELFYAML::SymverSection());
1650 sectionMapping(IO
, *cast
<ELFYAML::SymverSection
>(Section
.get()));
1652 case ELF::SHT_GNU_verneed
:
1653 if (!IO
.outputting())
1654 Section
.reset(new ELFYAML::VerneedSection());
1655 sectionMapping(IO
, *cast
<ELFYAML::VerneedSection
>(Section
.get()));
1657 case ELF::SHT_SYMTAB_SHNDX
:
1658 if (!IO
.outputting())
1659 Section
.reset(new ELFYAML::SymtabShndxSection());
1660 sectionMapping(IO
, *cast
<ELFYAML::SymtabShndxSection
>(Section
.get()));
1662 case ELF::SHT_LLVM_ADDRSIG
:
1663 if (!IO
.outputting())
1664 Section
.reset(new ELFYAML::AddrsigSection());
1665 sectionMapping(IO
, *cast
<ELFYAML::AddrsigSection
>(Section
.get()));
1667 case ELF::SHT_LLVM_LINKER_OPTIONS
:
1668 if (!IO
.outputting())
1669 Section
.reset(new ELFYAML::LinkerOptionsSection());
1670 sectionMapping(IO
, *cast
<ELFYAML::LinkerOptionsSection
>(Section
.get()));
1672 case ELF::SHT_LLVM_DEPENDENT_LIBRARIES
:
1673 if (!IO
.outputting())
1674 Section
.reset(new ELFYAML::DependentLibrariesSection());
1676 *cast
<ELFYAML::DependentLibrariesSection
>(Section
.get()));
1678 case ELF::SHT_LLVM_CALL_GRAPH_PROFILE
:
1679 if (!IO
.outputting())
1680 Section
.reset(new ELFYAML::CallGraphProfileSection());
1681 sectionMapping(IO
, *cast
<ELFYAML::CallGraphProfileSection
>(Section
.get()));
1683 case ELF::SHT_LLVM_BB_ADDR_MAP_V0
:
1684 case ELF::SHT_LLVM_BB_ADDR_MAP
:
1685 if (!IO
.outputting())
1686 Section
.reset(new ELFYAML::BBAddrMapSection());
1687 sectionMapping(IO
, *cast
<ELFYAML::BBAddrMapSection
>(Section
.get()));
1690 if (!IO
.outputting()) {
1692 IO
.mapOptional("Name", Name
, StringRef());
1693 Name
= ELFYAML::dropUniqueSuffix(Name
);
1695 if (ELFYAML::StackSizesSection::nameMatches(Name
))
1696 Section
= std::make_unique
<ELFYAML::StackSizesSection
>();
1698 Section
= std::make_unique
<ELFYAML::RawContentSection
>();
1701 if (auto S
= dyn_cast
<ELFYAML::RawContentSection
>(Section
.get()))
1702 sectionMapping(IO
, *S
);
1704 sectionMapping(IO
, *cast
<ELFYAML::StackSizesSection
>(Section
.get()));
1708 std::string MappingTraits
<std::unique_ptr
<ELFYAML::Chunk
>>::validate(
1709 IO
&io
, std::unique_ptr
<ELFYAML::Chunk
> &C
) {
1710 if (const auto *F
= dyn_cast
<ELFYAML::Fill
>(C
.get())) {
1711 if (F
->Pattern
&& F
->Pattern
->binary_size() != 0 && !F
->Size
)
1712 return "\"Size\" can't be 0 when \"Pattern\" is not empty";
1716 if (const auto *SHT
= dyn_cast
<ELFYAML::SectionHeaderTable
>(C
.get())) {
1717 if (SHT
->NoHeaders
&& (SHT
->Sections
|| SHT
->Excluded
|| SHT
->Offset
))
1718 return "NoHeaders can't be used together with Offset/Sections/Excluded";
1722 const ELFYAML::Section
&Sec
= *cast
<ELFYAML::Section
>(C
.get());
1723 if (Sec
.Size
&& Sec
.Content
&&
1724 (uint64_t)(*Sec
.Size
) < Sec
.Content
->binary_size())
1725 return "Section size must be greater than or equal to the content size";
1727 auto BuildErrPrefix
= [](ArrayRef
<std::pair
<StringRef
, bool>> EntV
) {
1729 for (size_t I
= 0, E
= EntV
.size(); I
!= E
; ++I
) {
1730 StringRef Name
= EntV
[I
].first
;
1732 Msg
= "\"" + Name
.str() + "\"";
1735 if (I
!= EntV
.size() - 1)
1736 Msg
+= ", \"" + Name
.str() + "\"";
1738 Msg
+= " and \"" + Name
.str() + "\"";
1743 std::vector
<std::pair
<StringRef
, bool>> Entries
= Sec
.getEntries();
1744 const size_t NumUsedEntries
= llvm::count_if(
1745 Entries
, [](const std::pair
<StringRef
, bool> &P
) { return P
.second
; });
1747 if ((Sec
.Size
|| Sec
.Content
) && NumUsedEntries
> 0)
1748 return BuildErrPrefix(Entries
) +
1749 " cannot be used with \"Content\" or \"Size\"";
1751 if (NumUsedEntries
> 0 && Entries
.size() != NumUsedEntries
)
1752 return BuildErrPrefix(Entries
) + " must be used together";
1754 if (const auto *RawSection
= dyn_cast
<ELFYAML::RawContentSection
>(C
.get())) {
1755 if (RawSection
->Flags
&& RawSection
->ShFlags
)
1756 return "ShFlags and Flags cannot be used together";
1760 if (const auto *NB
= dyn_cast
<ELFYAML::NoBitsSection
>(C
.get())) {
1762 return "SHT_NOBITS section cannot have \"Content\"";
1766 if (const auto *MF
= dyn_cast
<ELFYAML::MipsABIFlags
>(C
.get())) {
1768 return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
1771 return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
1780 struct NormalizedMips64RelType
{
1781 NormalizedMips64RelType(IO
&)
1782 : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE
)),
1783 Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE
)),
1784 Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE
)),
1785 SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF
)) {}
1786 NormalizedMips64RelType(IO
&, ELFYAML::ELF_REL Original
)
1787 : Type(Original
& 0xFF), Type2(Original
>> 8 & 0xFF),
1788 Type3(Original
>> 16 & 0xFF), SpecSym(Original
>> 24 & 0xFF) {}
1790 ELFYAML::ELF_REL
denormalize(IO
&) {
1791 ELFYAML::ELF_REL Res
= Type
| Type2
<< 8 | Type3
<< 16 | SpecSym
<< 24;
1795 ELFYAML::ELF_REL Type
;
1796 ELFYAML::ELF_REL Type2
;
1797 ELFYAML::ELF_REL Type3
;
1798 ELFYAML::ELF_RSS SpecSym
;
1801 } // end anonymous namespace
1803 void MappingTraits
<ELFYAML::StackSizeEntry
>::mapping(
1804 IO
&IO
, ELFYAML::StackSizeEntry
&E
) {
1805 assert(IO
.getContext() && "The IO context is not initialized");
1806 IO
.mapOptional("Address", E
.Address
, Hex64(0));
1807 IO
.mapRequired("Size", E
.Size
);
1810 void MappingTraits
<ELFYAML::BBAddrMapEntry
>::mapping(
1811 IO
&IO
, ELFYAML::BBAddrMapEntry
&E
) {
1812 assert(IO
.getContext() && "The IO context is not initialized");
1813 IO
.mapRequired("Version", E
.Version
);
1814 IO
.mapOptional("Feature", E
.Feature
, Hex8(0));
1815 IO
.mapOptional("Address", E
.Address
, Hex64(0));
1816 IO
.mapOptional("NumBlocks", E
.NumBlocks
);
1817 IO
.mapOptional("BBEntries", E
.BBEntries
);
1820 void MappingTraits
<ELFYAML::BBAddrMapEntry::BBEntry
>::mapping(
1821 IO
&IO
, ELFYAML::BBAddrMapEntry::BBEntry
&E
) {
1822 assert(IO
.getContext() && "The IO context is not initialized");
1823 IO
.mapOptional("ID", E
.ID
);
1824 IO
.mapRequired("AddressOffset", E
.AddressOffset
);
1825 IO
.mapRequired("Size", E
.Size
);
1826 IO
.mapRequired("Metadata", E
.Metadata
);
1829 void MappingTraits
<ELFYAML::PGOAnalysisMapEntry
>::mapping(
1830 IO
&IO
, ELFYAML::PGOAnalysisMapEntry
&E
) {
1831 assert(IO
.getContext() && "The IO context is not initialized");
1832 IO
.mapOptional("FuncEntryCount", E
.FuncEntryCount
);
1833 IO
.mapOptional("PGOBBEntries", E
.PGOBBEntries
);
1836 void MappingTraits
<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry
>::mapping(
1837 IO
&IO
, ELFYAML::PGOAnalysisMapEntry::PGOBBEntry
&E
) {
1838 assert(IO
.getContext() && "The IO context is not initialized");
1839 IO
.mapOptional("BBFreq", E
.BBFreq
);
1840 IO
.mapOptional("Successors", E
.Successors
);
1843 void MappingTraits
<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry
>::
1845 ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry
&E
) {
1846 assert(IO
.getContext() && "The IO context is not initialized");
1847 IO
.mapRequired("ID", E
.ID
);
1848 IO
.mapRequired("BrProb", E
.BrProb
);
1851 void MappingTraits
<ELFYAML::GnuHashHeader
>::mapping(IO
&IO
,
1852 ELFYAML::GnuHashHeader
&E
) {
1853 assert(IO
.getContext() && "The IO context is not initialized");
1854 IO
.mapOptional("NBuckets", E
.NBuckets
);
1855 IO
.mapRequired("SymNdx", E
.SymNdx
);
1856 IO
.mapOptional("MaskWords", E
.MaskWords
);
1857 IO
.mapRequired("Shift2", E
.Shift2
);
1860 void MappingTraits
<ELFYAML::DynamicEntry
>::mapping(IO
&IO
,
1861 ELFYAML::DynamicEntry
&Rel
) {
1862 assert(IO
.getContext() && "The IO context is not initialized");
1864 IO
.mapRequired("Tag", Rel
.Tag
);
1865 IO
.mapRequired("Value", Rel
.Val
);
1868 void MappingTraits
<ELFYAML::NoteEntry
>::mapping(IO
&IO
, ELFYAML::NoteEntry
&N
) {
1869 assert(IO
.getContext() && "The IO context is not initialized");
1871 IO
.mapOptional("Name", N
.Name
);
1872 IO
.mapOptional("Desc", N
.Desc
);
1873 IO
.mapRequired("Type", N
.Type
);
1876 void MappingTraits
<ELFYAML::VerdefEntry
>::mapping(IO
&IO
,
1877 ELFYAML::VerdefEntry
&E
) {
1878 assert(IO
.getContext() && "The IO context is not initialized");
1880 IO
.mapOptional("Version", E
.Version
);
1881 IO
.mapOptional("Flags", E
.Flags
);
1882 IO
.mapOptional("VersionNdx", E
.VersionNdx
);
1883 IO
.mapOptional("Hash", E
.Hash
);
1884 IO
.mapRequired("Names", E
.VerNames
);
1887 void MappingTraits
<ELFYAML::VerneedEntry
>::mapping(IO
&IO
,
1888 ELFYAML::VerneedEntry
&E
) {
1889 assert(IO
.getContext() && "The IO context is not initialized");
1891 IO
.mapRequired("Version", E
.Version
);
1892 IO
.mapRequired("File", E
.File
);
1893 IO
.mapRequired("Entries", E
.AuxV
);
1896 void MappingTraits
<ELFYAML::VernauxEntry
>::mapping(IO
&IO
,
1897 ELFYAML::VernauxEntry
&E
) {
1898 assert(IO
.getContext() && "The IO context is not initialized");
1900 IO
.mapRequired("Name", E
.Name
);
1901 IO
.mapRequired("Hash", E
.Hash
);
1902 IO
.mapRequired("Flags", E
.Flags
);
1903 IO
.mapRequired("Other", E
.Other
);
1906 void MappingTraits
<ELFYAML::Relocation
>::mapping(IO
&IO
,
1907 ELFYAML::Relocation
&Rel
) {
1908 const auto *Object
= static_cast<ELFYAML::Object
*>(IO
.getContext());
1909 assert(Object
&& "The IO context is not initialized");
1911 IO
.mapOptional("Offset", Rel
.Offset
, (Hex64
)0);
1912 IO
.mapOptional("Symbol", Rel
.Symbol
);
1914 if (Object
->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS
) &&
1915 Object
->Header
.Class
== ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64
)) {
1916 MappingNormalization
<NormalizedMips64RelType
, ELFYAML::ELF_REL
> Key(
1918 IO
.mapRequired("Type", Key
->Type
);
1919 IO
.mapOptional("Type2", Key
->Type2
, ELFYAML::ELF_REL(ELF::R_MIPS_NONE
));
1920 IO
.mapOptional("Type3", Key
->Type3
, ELFYAML::ELF_REL(ELF::R_MIPS_NONE
));
1921 IO
.mapOptional("SpecSym", Key
->SpecSym
, ELFYAML::ELF_RSS(ELF::RSS_UNDEF
));
1923 IO
.mapRequired("Type", Rel
.Type
);
1925 IO
.mapOptional("Addend", Rel
.Addend
, (ELFYAML::YAMLIntUInt
)0);
1928 void MappingTraits
<ELFYAML::ARMIndexTableEntry
>::mapping(
1929 IO
&IO
, ELFYAML::ARMIndexTableEntry
&E
) {
1930 assert(IO
.getContext() && "The IO context is not initialized");
1931 IO
.mapRequired("Offset", E
.Offset
);
1933 StringRef CantUnwind
= "EXIDX_CANTUNWIND";
1934 if (IO
.outputting() && (uint32_t)E
.Value
== ARM::EHABI::EXIDX_CANTUNWIND
)
1935 IO
.mapRequired("Value", CantUnwind
);
1936 else if (!IO
.outputting() && getStringValue(IO
, "Value") == CantUnwind
)
1937 E
.Value
= ARM::EHABI::EXIDX_CANTUNWIND
;
1939 IO
.mapRequired("Value", E
.Value
);
1942 void MappingTraits
<ELFYAML::Object
>::mapping(IO
&IO
, ELFYAML::Object
&Object
) {
1943 assert(!IO
.getContext() && "The IO context is initialized already");
1944 IO
.setContext(&Object
);
1945 IO
.mapTag("!ELF", true);
1946 IO
.mapRequired("FileHeader", Object
.Header
);
1947 IO
.mapOptional("ProgramHeaders", Object
.ProgramHeaders
);
1948 IO
.mapOptional("Sections", Object
.Chunks
);
1949 IO
.mapOptional("Symbols", Object
.Symbols
);
1950 IO
.mapOptional("DynamicSymbols", Object
.DynamicSymbols
);
1951 IO
.mapOptional("DWARF", Object
.DWARF
);
1953 Object
.DWARF
->IsLittleEndian
=
1954 Object
.Header
.Data
== ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB
);
1955 Object
.DWARF
->Is64BitAddrSize
=
1956 Object
.Header
.Class
== ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64
);
1958 IO
.setContext(nullptr);
1961 void MappingTraits
<ELFYAML::LinkerOption
>::mapping(IO
&IO
,
1962 ELFYAML::LinkerOption
&Opt
) {
1963 assert(IO
.getContext() && "The IO context is not initialized");
1964 IO
.mapRequired("Name", Opt
.Key
);
1965 IO
.mapRequired("Value", Opt
.Value
);
1968 void MappingTraits
<ELFYAML::CallGraphEntryWeight
>::mapping(
1969 IO
&IO
, ELFYAML::CallGraphEntryWeight
&E
) {
1970 assert(IO
.getContext() && "The IO context is not initialized");
1971 IO
.mapRequired("Weight", E
.Weight
);
1974 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG
)
1975 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP
)
1976 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT
)
1977 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE
)
1978 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1
)
1980 } // end namespace yaml
1982 } // end namespace llvm