/build/source/llvm/include/llvm/ObjectYAML/ELFYAML.h

Bug Summary

File:	build/source/llvm/include/llvm/ObjectYAML/ELFYAML.h
Warning:	line 56, column 1 The left operand of '==' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ELFYAML.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16 -I lib/ObjectYAML -I /build/source/llvm/lib/ObjectYAML -I include -I /build/source/llvm/include -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1674602410 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-01-25-024556-16494-1 -x c++ /build/source/llvm/lib/ObjectYAML/ELFYAML.cpp

/build/source/llvm/lib/ObjectYAML/ELFYAML.cpp

→

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//===----------------------------------------------------------------------===//

13#include "llvm/ObjectYAML/ELFYAML.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/ADT/MapVector.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/BinaryFormat/ELF.h"
18#include "llvm/Support/ARMEHABI.h"
19#include "llvm/Support/Casting.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/MipsABIFlags.h"
22#include "llvm/Support/YAMLTraits.h"
23#include "llvm/Support/WithColor.h"
24#include <cassert>
25#include <cstdint>
26#include <optional>

28namespace llvm {

30ELFYAML::Chunk::~Chunk() = default;

32namespace ELFYAML {
33ELF_ELFOSABI Object::getOSAbi() const { return Header.OSABI; }

35unsigned Object::getMachine() const {
if (Header.Machine)
  return *Header.Machine;
return llvm::ELF::EM_NONE;
39}

41constexpr StringRef SectionHeaderTable::TypeStr;
42} // namespace ELFYAML

44namespace yaml {

46void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(
  IO &IO, ELFYAML::ELF_ET &Value) {
48#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(ET_NONE);
ECase(ET_REL);
ECase(ET_EXEC);
ECase(ET_DYN);
ECase(ET_CORE);
54#undef ECase
IO.enumFallback<Hex16>(Value);
56}

58void ScalarEnumerationTraits<ELFYAML::ELF_PT>::enumeration(
  IO &IO, ELFYAML::ELF_PT &Value) {
60#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(PT_NULL);
ECase(PT_LOAD);
ECase(PT_DYNAMIC);
ECase(PT_INTERP);
ECase(PT_NOTE);
ECase(PT_SHLIB);
ECase(PT_PHDR);
ECase(PT_TLS);
ECase(PT_GNU_EH_FRAME);
ECase(PT_GNU_STACK);
ECase(PT_GNU_RELRO);
ECase(PT_GNU_PROPERTY);
73#undef ECase
IO.enumFallback<Hex32>(Value);
75}

77void ScalarEnumerationTraits<ELFYAML::ELF_NT>::enumeration(
  IO &IO, ELFYAML::ELF_NT &Value) {
79#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// Generic note types.
ECase(NT_VERSION);
ECase(NT_ARCH);
ECase(NT_GNU_BUILD_ATTRIBUTE_OPEN);
ECase(NT_GNU_BUILD_ATTRIBUTE_FUNC);
// Core note types.
ECase(NT_PRSTATUS);
ECase(NT_FPREGSET);
ECase(NT_PRPSINFO);
ECase(NT_TASKSTRUCT);
ECase(NT_AUXV);
ECase(NT_PSTATUS);
ECase(NT_FPREGS);
ECase(NT_PSINFO);
ECase(NT_LWPSTATUS);
ECase(NT_LWPSINFO);
ECase(NT_WIN32PSTATUS);
ECase(NT_PPC_VMX);
ECase(NT_PPC_VSX);
ECase(NT_PPC_TAR);
ECase(NT_PPC_PPR);
ECase(NT_PPC_DSCR);
ECase(NT_PPC_EBB);
ECase(NT_PPC_PMU);
ECase(NT_PPC_TM_CGPR);
ECase(NT_PPC_TM_CFPR);
ECase(NT_PPC_TM_CVMX);
ECase(NT_PPC_TM_CVSX);
ECase(NT_PPC_TM_SPR);
ECase(NT_PPC_TM_CTAR);
ECase(NT_PPC_TM_CPPR);
ECase(NT_PPC_TM_CDSCR);
ECase(NT_386_TLS);
ECase(NT_386_IOPERM);
ECase(NT_X86_XSTATE);
ECase(NT_S390_HIGH_GPRS);
ECase(NT_S390_TIMER);
ECase(NT_S390_TODCMP);
ECase(NT_S390_TODPREG);
ECase(NT_S390_CTRS);
ECase(NT_S390_PREFIX);
ECase(NT_S390_LAST_BREAK);
ECase(NT_S390_SYSTEM_CALL);
ECase(NT_S390_TDB);
ECase(NT_S390_VXRS_LOW);
ECase(NT_S390_VXRS_HIGH);
ECase(NT_S390_GS_CB);
ECase(NT_S390_GS_BC);
ECase(NT_ARM_VFP);
ECase(NT_ARM_TLS);
ECase(NT_ARM_HW_BREAK);
ECase(NT_ARM_HW_WATCH);
ECase(NT_ARM_SVE);
ECase(NT_ARM_PAC_MASK);
ECase(NT_FILE);
ECase(NT_PRXFPREG);
ECase(NT_SIGINFO);
// LLVM-specific notes.
ECase(NT_LLVM_HWASAN_GLOBALS);
// GNU note types
ECase(NT_GNU_ABI_TAG);
ECase(NT_GNU_HWCAP);
ECase(NT_GNU_BUILD_ID);
ECase(NT_GNU_GOLD_VERSION);
ECase(NT_GNU_PROPERTY_TYPE_0);
// FreeBSD note types.
ECase(NT_FREEBSD_ABI_TAG);
ECase(NT_FREEBSD_NOINIT_TAG);
ECase(NT_FREEBSD_ARCH_TAG);
ECase(NT_FREEBSD_FEATURE_CTL);
// FreeBSD core note types.
ECase(NT_FREEBSD_THRMISC);
ECase(NT_FREEBSD_PROCSTAT_PROC);
ECase(NT_FREEBSD_PROCSTAT_FILES);
ECase(NT_FREEBSD_PROCSTAT_VMMAP);
ECase(NT_FREEBSD_PROCSTAT_GROUPS);
ECase(NT_FREEBSD_PROCSTAT_UMASK);
ECase(NT_FREEBSD_PROCSTAT_RLIMIT);
ECase(NT_FREEBSD_PROCSTAT_OSREL);
ECase(NT_FREEBSD_PROCSTAT_PSSTRINGS);
ECase(NT_FREEBSD_PROCSTAT_AUXV);
// NetBSD core note types.
ECase(NT_NETBSDCORE_PROCINFO);
ECase(NT_NETBSDCORE_AUXV);
ECase(NT_NETBSDCORE_LWPSTATUS);
// OpenBSD core note types.
ECase(NT_OPENBSD_PROCINFO);
ECase(NT_OPENBSD_AUXV);
ECase(NT_OPENBSD_REGS);
ECase(NT_OPENBSD_FPREGS);
ECase(NT_OPENBSD_XFPREGS);
ECase(NT_OPENBSD_WCOOKIE);
// AMD specific notes. (Code Object V2)
ECase(NT_AMD_HSA_CODE_OBJECT_VERSION);
ECase(NT_AMD_HSA_HSAIL);
ECase(NT_AMD_HSA_ISA_VERSION);
ECase(NT_AMD_HSA_METADATA);
ECase(NT_AMD_HSA_ISA_NAME);
ECase(NT_AMD_PAL_METADATA);
// AMDGPU specific notes. (Code Object V3)
ECase(NT_AMDGPU_METADATA);
// Android specific notes.
ECase(NT_ANDROID_TYPE_IDENT);
ECase(NT_ANDROID_TYPE_KUSER);
ECase(NT_ANDROID_TYPE_MEMTAG);
185#undef ECase
IO.enumFallback<Hex32>(Value);
187}

189void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
  IO &IO, ELFYAML::ELF_EM &Value) {
191#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(EM_NONE);
ECase(EM_M32);
ECase(EM_SPARC);
ECase(EM_386);
ECase(EM_68K);
ECase(EM_88K);
ECase(EM_IAMCU);
ECase(EM_860);
ECase(EM_MIPS);
ECase(EM_S370);
ECase(EM_MIPS_RS3_LE);
ECase(EM_PARISC);
ECase(EM_VPP500);
ECase(EM_SPARC32PLUS);
ECase(EM_960);
ECase(EM_PPC);
ECase(EM_PPC64);
ECase(EM_S390);
ECase(EM_SPU);
ECase(EM_V800);
ECase(EM_FR20);
ECase(EM_RH32);
ECase(EM_RCE);
ECase(EM_ARM);
ECase(EM_ALPHA);
ECase(EM_SH);
ECase(EM_SPARCV9);
ECase(EM_TRICORE);
ECase(EM_ARC);
ECase(EM_H8_300);
ECase(EM_H8_300H);
ECase(EM_H8S);
ECase(EM_H8_500);
ECase(EM_IA_64);
ECase(EM_MIPS_X);
ECase(EM_COLDFIRE);
ECase(EM_68HC12);
ECase(EM_MMA);
ECase(EM_PCP);
ECase(EM_NCPU);
ECase(EM_NDR1);
ECase(EM_STARCORE);
ECase(EM_ME16);
ECase(EM_ST100);
ECase(EM_TINYJ);
ECase(EM_X86_64);
ECase(EM_PDSP);
ECase(EM_PDP10);
ECase(EM_PDP11);
ECase(EM_FX66);
ECase(EM_ST9PLUS);
ECase(EM_ST7);
ECase(EM_68HC16);
ECase(EM_68HC11);
ECase(EM_68HC08);
ECase(EM_68HC05);
ECase(EM_SVX);
ECase(EM_ST19);
ECase(EM_VAX);
ECase(EM_CRIS);
ECase(EM_JAVELIN);
ECase(EM_FIREPATH);
ECase(EM_ZSP);
ECase(EM_MMIX);
ECase(EM_HUANY);
ECase(EM_PRISM);
ECase(EM_AVR);
ECase(EM_FR30);
ECase(EM_D10V);
ECase(EM_D30V);
ECase(EM_V850);
ECase(EM_M32R);
ECase(EM_MN10300);
ECase(EM_MN10200);
ECase(EM_PJ);
ECase(EM_OPENRISC);
ECase(EM_ARC_COMPACT);
ECase(EM_XTENSA);
ECase(EM_VIDEOCORE);
ECase(EM_TMM_GPP);
ECase(EM_NS32K);
ECase(EM_TPC);
ECase(EM_SNP1K);
ECase(EM_ST200);
ECase(EM_IP2K);
ECase(EM_MAX);
ECase(EM_CR);
ECase(EM_F2MC16);
ECase(EM_MSP430);
ECase(EM_BLACKFIN);
ECase(EM_SE_C33);
ECase(EM_SEP);
ECase(EM_ARCA);
ECase(EM_UNICORE);
ECase(EM_EXCESS);
ECase(EM_DXP);
ECase(EM_ALTERA_NIOS2);
ECase(EM_CRX);
ECase(EM_XGATE);
ECase(EM_C166);
ECase(EM_M16C);
ECase(EM_DSPIC30F);
ECase(EM_CE);
ECase(EM_M32C);
ECase(EM_TSK3000);
ECase(EM_RS08);
ECase(EM_SHARC);
ECase(EM_ECOG2);
ECase(EM_SCORE7);
ECase(EM_DSP24);
ECase(EM_VIDEOCORE3);
ECase(EM_LATTICEMICO32);
ECase(EM_SE_C17);
ECase(EM_TI_C6000);
ECase(EM_TI_C2000);
ECase(EM_TI_C5500);
ECase(EM_MMDSP_PLUS);
ECase(EM_CYPRESS_M8C);
ECase(EM_R32C);
ECase(EM_TRIMEDIA);
ECase(EM_HEXAGON);
ECase(EM_8051);
ECase(EM_STXP7X);
ECase(EM_NDS32);
ECase(EM_ECOG1);
ECase(EM_ECOG1X);
ECase(EM_MAXQ30);
ECase(EM_XIMO16);
ECase(EM_MANIK);
ECase(EM_CRAYNV2);
ECase(EM_RX);
ECase(EM_METAG);
ECase(EM_MCST_ELBRUS);
ECase(EM_ECOG16);
ECase(EM_CR16);
ECase(EM_ETPU);
ECase(EM_SLE9X);
ECase(EM_L10M);
ECase(EM_K10M);
ECase(EM_AARCH64);
ECase(EM_AVR32);
ECase(EM_STM8);
ECase(EM_TILE64);
ECase(EM_TILEPRO);
ECase(EM_MICROBLAZE);
ECase(EM_CUDA);
ECase(EM_TILEGX);
ECase(EM_CLOUDSHIELD);
ECase(EM_COREA_1ST);
ECase(EM_COREA_2ND);
ECase(EM_ARC_COMPACT2);
ECase(EM_OPEN8);
ECase(EM_RL78);
ECase(EM_VIDEOCORE5);
ECase(EM_78KOR);
ECase(EM_56800EX);
ECase(EM_AMDGPU);
ECase(EM_RISCV);
ECase(EM_LANAI);
ECase(EM_BPF);
ECase(EM_VE);
ECase(EM_CSKY);
ECase(EM_LOONGARCH);
355#undef ECase
IO.enumFallback<Hex16>(Value);
357}

359void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
  IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
361#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
// here.
ECase(ELFCLASS32);
ECase(ELFCLASS64);
366#undef ECase
367}

369void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
  IO &IO, ELFYAML::ELF_ELFDATA &Value) {
371#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// ELFDATANONE is an invalid data encoding, but we accept it because
// we want to be able to produce invalid binaries for the tests.
ECase(ELFDATANONE);
ECase(ELFDATA2LSB);
ECase(ELFDATA2MSB);
377#undef ECase
378}

380void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
  IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
382#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(ELFOSABI_NONE);
ECase(ELFOSABI_HPUX);
ECase(ELFOSABI_NETBSD);
ECase(ELFOSABI_GNU);
ECase(ELFOSABI_LINUX);
ECase(ELFOSABI_HURD);
ECase(ELFOSABI_SOLARIS);
ECase(ELFOSABI_AIX);
ECase(ELFOSABI_IRIX);
ECase(ELFOSABI_FREEBSD);
ECase(ELFOSABI_TRU64);
ECase(ELFOSABI_MODESTO);
ECase(ELFOSABI_OPENBSD);
ECase(ELFOSABI_OPENVMS);
ECase(ELFOSABI_NSK);
ECase(ELFOSABI_AROS);
ECase(ELFOSABI_FENIXOS);
ECase(ELFOSABI_CLOUDABI);
ECase(ELFOSABI_AMDGPU_HSA);
ECase(ELFOSABI_AMDGPU_PAL);
ECase(ELFOSABI_AMDGPU_MESA3D);
ECase(ELFOSABI_ARM);
ECase(ELFOSABI_C6000_ELFABI);
ECase(ELFOSABI_C6000_LINUX);
ECase(ELFOSABI_STANDALONE);
408#undef ECase
IO.enumFallback<Hex8>(Value);
410}

412void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
                                               ELFYAML::ELF_EF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 415, __extension__ __PRETTY_FUNCTION__
));
416#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
417#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
switch (Object->getMachine()) {
case ELF::EM_ARM:
  BCase(EF_ARM_SOFT_FLOAT);
  BCase(EF_ARM_VFP_FLOAT);
  BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);
  BCaseMask(EF_ARM_BE8, EF_ARM_BE8);
  break;
case ELF::EM_MIPS:
  BCase(EF_MIPS_NOREORDER);
  BCase(EF_MIPS_PIC);
  BCase(EF_MIPS_CPIC);
  BCase(EF_MIPS_ABI2);
  BCase(EF_MIPS_32BITMODE);
  BCase(EF_MIPS_FP64);
  BCase(EF_MIPS_NAN2008);
  BCase(EF_MIPS_MICROMIPS);
  BCase(EF_MIPS_ARCH_ASE_M16);
  BCase(EF_MIPS_ARCH_ASE_MDMX);
  BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);
  BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);
  BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);
  BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);
  BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);
  BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);
  BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);
  break;
case ELF::EM_HEXAGON:
  BCaseMask(EF_HEXAGON_MACH_V2, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V3, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V4, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V5, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V55, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V60, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V62, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V65, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V66, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V67, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V67T, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V68, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V69, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V71, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V71T, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_MACH_V73, EF_HEXAGON_MACH);
  BCaseMask(EF_HEXAGON_ISA_V2, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V3, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V4, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V5, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V55, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V60, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V62, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V65, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V66, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V67, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V68, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V69, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V71, EF_HEXAGON_ISA);
  BCaseMask(EF_HEXAGON_ISA_V73, EF_HEXAGON_ISA);
  break;
case ELF::EM_AVR:
  BCaseMask(EF_AVR_ARCH_AVR1, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR2, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR25, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR3, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR31, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR35, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR4, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR5, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR51, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVR6, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_AVRTINY, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA1, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA2, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA3, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA4, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA5, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA6, EF_AVR_ARCH_MASK);
  BCaseMask(EF_AVR_ARCH_XMEGA7, EF_AVR_ARCH_MASK);
  BCase(EF_AVR_LINKRELAX_PREPARED);
  break;
case ELF::EM_LOONGARCH:
  BCaseMask(EF_LOONGARCH_ABI_SOFT_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);
  BCaseMask(EF_LOONGARCH_ABI_SINGLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);
  BCaseMask(EF_LOONGARCH_ABI_DOUBLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);
  BCaseMask(EF_LOONGARCH_OBJABI_V0, EF_LOONGARCH_OBJABI_MASK);
  BCaseMask(EF_LOONGARCH_OBJABI_V1, EF_LOONGARCH_OBJABI_MASK);
  break;
case ELF::EM_RISCV:
  BCase(EF_RISCV_RVC);
  BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
  BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
  BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
  BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
  BCase(EF_RISCV_RVE);
  BCase(EF_RISCV_TSO);
  break;
case ELF::EM_XTENSA:
  BCase(EF_XTENSA_XT_INSN);
  BCaseMask(EF_XTENSA_MACH_NONE, EF_XTENSA_MACH);
  BCase(EF_XTENSA_XT_LIT);
  break;
case ELF::EM_AMDGPU:
  BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX602, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX705, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX805, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX908, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90A, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90C, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX940, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1011, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1012, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1013, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1030, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1031, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1032, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1033, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1034, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1035, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1036, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1100, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1101, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1102, EF_AMDGPU_MACH);
  BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1103, EF_AMDGPU_MACH);
  switch (Object->Header.ABIVersion) {
  default:
    // ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags.
    [[fallthrough]];
  case ELF::ELFABIVERSION_AMDGPU_HSA_V3:
    BCase(EF_AMDGPU_FEATURE_XNACK_V3);
    BCase(EF_AMDGPU_FEATURE_SRAMECC_V3);
    break;
  case ELF::ELFABIVERSION_AMDGPU_HSA_V4:
  case ELF::ELFABIVERSION_AMDGPU_HSA_V5:
    BCaseMask(EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4,
              EF_AMDGPU_FEATURE_XNACK_V4);
    BCaseMask(EF_AMDGPU_FEATURE_XNACK_ANY_V4,
              EF_AMDGPU_FEATURE_XNACK_V4);
    BCaseMask(EF_AMDGPU_FEATURE_XNACK_OFF_V4,
              EF_AMDGPU_FEATURE_XNACK_V4);
    BCaseMask(EF_AMDGPU_FEATURE_XNACK_ON_V4,
              EF_AMDGPU_FEATURE_XNACK_V4);
    BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4,
              EF_AMDGPU_FEATURE_SRAMECC_V4);
    BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4,
              EF_AMDGPU_FEATURE_SRAMECC_V4);
    BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4,
              EF_AMDGPU_FEATURE_SRAMECC_V4);
    BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4,
              EF_AMDGPU_FEATURE_SRAMECC_V4);
    break;
  }
  break;
default:
  break;
}
637#undef BCase
638#undef BCaseMask
639}

641void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
  IO &IO, ELFYAML::ELF_SHT &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 644, __extension__ __PRETTY_FUNCTION__
));
645#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHT_NULL);
ECase(SHT_PROGBITS);
ECase(SHT_SYMTAB);
// FIXME: Issue a diagnostic with this information.
ECase(SHT_STRTAB);
ECase(SHT_RELA);
ECase(SHT_HASH);
ECase(SHT_DYNAMIC);
ECase(SHT_NOTE);
ECase(SHT_NOBITS);
ECase(SHT_REL);
ECase(SHT_SHLIB);
ECase(SHT_DYNSYM);
ECase(SHT_INIT_ARRAY);
ECase(SHT_FINI_ARRAY);
ECase(SHT_PREINIT_ARRAY);
ECase(SHT_GROUP);
ECase(SHT_SYMTAB_SHNDX);
ECase(SHT_RELR);
ECase(SHT_ANDROID_REL);
ECase(SHT_ANDROID_RELA);
ECase(SHT_ANDROID_RELR);
ECase(SHT_LLVM_ODRTAB);
ECase(SHT_LLVM_LINKER_OPTIONS);
ECase(SHT_LLVM_CALL_GRAPH_PROFILE);
ECase(SHT_LLVM_ADDRSIG);
ECase(SHT_LLVM_DEPENDENT_LIBRARIES);
ECase(SHT_LLVM_SYMPART);
ECase(SHT_LLVM_PART_EHDR);
ECase(SHT_LLVM_PART_PHDR);
ECase(SHT_LLVM_BB_ADDR_MAP_V0);
ECase(SHT_LLVM_BB_ADDR_MAP);
ECase(SHT_LLVM_OFFLOADING);
ECase(SHT_GNU_ATTRIBUTES);
ECase(SHT_GNU_HASH);
ECase(SHT_GNU_verdef);
ECase(SHT_GNU_verneed);
ECase(SHT_GNU_versym);
switch (Object->getMachine()) {
case ELF::EM_ARM:
  ECase(SHT_ARM_EXIDX);
  ECase(SHT_ARM_PREEMPTMAP);
  ECase(SHT_ARM_ATTRIBUTES);
  ECase(SHT_ARM_DEBUGOVERLAY);
  ECase(SHT_ARM_OVERLAYSECTION);
  break;
case ELF::EM_HEXAGON:
  ECase(SHT_HEX_ORDERED);
  break;
case ELF::EM_X86_64:
  ECase(SHT_X86_64_UNWIND);
  break;
case ELF::EM_MIPS:
  ECase(SHT_MIPS_REGINFO);
  ECase(SHT_MIPS_OPTIONS);
  ECase(SHT_MIPS_DWARF);
  ECase(SHT_MIPS_ABIFLAGS);
  break;
case ELF::EM_RISCV:
  ECase(SHT_RISCV_ATTRIBUTES);
  break;
case ELF::EM_MSP430:
  ECase(SHT_MSP430_ATTRIBUTES);
  break;
default:
  // Nothing to do.
  break;
}
714#undef ECase
IO.enumFallback<Hex32>(Value);
716}

718void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,
                                               ELFYAML::ELF_PF &Value) {
720#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(PF_X);
BCase(PF_W);
BCase(PF_R);
724}

726void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
                                                ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
729#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(SHF_WRITE);
BCase(SHF_ALLOC);
BCase(SHF_EXCLUDE);
BCase(SHF_EXECINSTR);
BCase(SHF_MERGE);
BCase(SHF_STRINGS);
BCase(SHF_INFO_LINK);
BCase(SHF_LINK_ORDER);
BCase(SHF_OS_NONCONFORMING);
BCase(SHF_GROUP);
BCase(SHF_TLS);
BCase(SHF_COMPRESSED);
switch (Object->getOSAbi()) {
case ELF::ELFOSABI_SOLARIS:
  BCase(SHF_SUNW_NODISCARD);
  break;
default:
  BCase(SHF_GNU_RETAIN);
  break;
}
switch (Object->getMachine()) {
case ELF::EM_ARM:
  BCase(SHF_ARM_PURECODE);
  break;
case ELF::EM_HEXAGON:
  BCase(SHF_HEX_GPREL);
  break;
case ELF::EM_MIPS:
  BCase(SHF_MIPS_NODUPES);
  BCase(SHF_MIPS_NAMES);
  BCase(SHF_MIPS_LOCAL);
  BCase(SHF_MIPS_NOSTRIP);
  BCase(SHF_MIPS_GPREL);
  BCase(SHF_MIPS_MERGE);
  BCase(SHF_MIPS_ADDR);
  BCase(SHF_MIPS_STRING);
  break;
case ELF::EM_X86_64:
  BCase(SHF_X86_64_LARGE);
  break;
default:
  // Nothing to do.
  break;
}
774#undef BCase
775}

777void ScalarEnumerationTraits<ELFYAML::ELF_SHN>::enumeration(
  IO &IO, ELFYAML::ELF_SHN &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 780, __extension__ __PRETTY_FUNCTION__
));
781#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHN_UNDEF);
ECase(SHN_LORESERVE);
ECase(SHN_LOPROC);
ECase(SHN_HIPROC);
ECase(SHN_LOOS);
ECase(SHN_HIOS);
ECase(SHN_ABS);
ECase(SHN_COMMON);
ECase(SHN_XINDEX);
ECase(SHN_HIRESERVE);
ECase(SHN_AMDGPU_LDS);

if (!IO.outputting() || Object->getMachine() == ELF::EM_MIPS) {
  ECase(SHN_MIPS_ACOMMON);
  ECase(SHN_MIPS_TEXT);
  ECase(SHN_MIPS_DATA);
  ECase(SHN_MIPS_SCOMMON);
  ECase(SHN_MIPS_SUNDEFINED);
}

ECase(SHN_HEXAGON_SCOMMON);
ECase(SHN_HEXAGON_SCOMMON_1);
ECase(SHN_HEXAGON_SCOMMON_2);
ECase(SHN_HEXAGON_SCOMMON_4);
ECase(SHN_HEXAGON_SCOMMON_8);
807#undef ECase
IO.enumFallback<Hex16>(Value);
809}

811void ScalarEnumerationTraits<ELFYAML::ELF_STB>::enumeration(
  IO &IO, ELFYAML::ELF_STB &Value) {
813#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(STB_LOCAL);
ECase(STB_GLOBAL);
ECase(STB_WEAK);
ECase(STB_GNU_UNIQUE);
818#undef ECase
IO.enumFallback<Hex8>(Value);
820}

822void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
  IO &IO, ELFYAML::ELF_STT &Value) {
824#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(STT_NOTYPE);
ECase(STT_OBJECT);
ECase(STT_FUNC);
ECase(STT_SECTION);
ECase(STT_FILE);
ECase(STT_COMMON);
ECase(STT_TLS);
ECase(STT_GNU_IFUNC);
833#undef ECase
IO.enumFallback<Hex8>(Value);
835}


838void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
  IO &IO, ELFYAML::ELF_RSS &Value) {
840#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(RSS_UNDEF);
ECase(RSS_GP);
ECase(RSS_GP0);
ECase(RSS_LOC);
845#undef ECase
846}

848void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
  IO &IO, ELFYAML::ELF_REL &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 851, __extension__ __PRETTY_FUNCTION__
));
852#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
switch (Object->getMachine()) {
case ELF::EM_X86_64:
855#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
  break;
case ELF::EM_MIPS:
858#include "llvm/BinaryFormat/ELFRelocs/Mips.def"
  break;
case ELF::EM_HEXAGON:
861#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
  break;
case ELF::EM_386:
case ELF::EM_IAMCU:
865#include "llvm/BinaryFormat/ELFRelocs/i386.def"
  break;
case ELF::EM_AARCH64:
868#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
  break;
case ELF::EM_ARM:
871#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
  break;
case ELF::EM_ARC:
874#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
  break;
case ELF::EM_RISCV:
877#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
  break;
case ELF::EM_LANAI:
880#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
  break;
case ELF::EM_AMDGPU:
883#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
  break;
case ELF::EM_BPF:
886#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
  break;
case ELF::EM_VE:
889#include "llvm/BinaryFormat/ELFRelocs/VE.def"
  break;
case ELF::EM_CSKY:
892#include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
  break;
case ELF::EM_PPC:
895#include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
  break;
case ELF::EM_PPC64:
898#include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
  break;
case ELF::EM_68K:
901#include "llvm/BinaryFormat/ELFRelocs/M68k.def"
  break;
case ELF::EM_LOONGARCH:
904#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
  break;
case ELF::EM_XTENSA:
907#include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
  break;
default:
  // Nothing to do.
  break;
}
913#undef ELF_RELOC
IO.enumFallback<Hex32>(Value);
915}

917void ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG>::enumeration(
  IO &IO, ELFYAML::ELF_DYNTAG &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 920, __extension__ __PRETTY_FUNCTION__
));

922// Disable architecture specific tags by default. We might enable them below.
923#define AARCH64_DYNAMIC_TAG(name, value)
924#define MIPS_DYNAMIC_TAG(name, value)
925#define HEXAGON_DYNAMIC_TAG(name, value)
926#define PPC_DYNAMIC_TAG(name, value)
927#define PPC64_DYNAMIC_TAG(name, value)
928// Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
929#define DYNAMIC_TAG_MARKER(name, value)

931#define STRINGIFY(X) (#X)
932#define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
switch (Object->getMachine()) {
case ELF::EM_AARCH64:
935#undef AARCH64_DYNAMIC_TAG
936#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
937#include "llvm/BinaryFormat/DynamicTags.def"
938#undef AARCH64_DYNAMIC_TAG
939#define AARCH64_DYNAMIC_TAG(name, value)
  break;
case ELF::EM_MIPS:
942#undef MIPS_DYNAMIC_TAG
943#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
944#include "llvm/BinaryFormat/DynamicTags.def"
945#undef MIPS_DYNAMIC_TAG
946#define MIPS_DYNAMIC_TAG(name, value)
  break;
case ELF::EM_HEXAGON:
949#undef HEXAGON_DYNAMIC_TAG
950#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
951#include "llvm/BinaryFormat/DynamicTags.def"
952#undef HEXAGON_DYNAMIC_TAG
953#define HEXAGON_DYNAMIC_TAG(name, value)
  break;
case ELF::EM_PPC:
956#undef PPC_DYNAMIC_TAG
957#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
958#include "llvm/BinaryFormat/DynamicTags.def"
959#undef PPC_DYNAMIC_TAG
960#define PPC_DYNAMIC_TAG(name, value)
  break;
case ELF::EM_PPC64:
963#undef PPC64_DYNAMIC_TAG
964#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
965#include "llvm/BinaryFormat/DynamicTags.def"
966#undef PPC64_DYNAMIC_TAG
967#define PPC64_DYNAMIC_TAG(name, value)
  break;
case ELF::EM_RISCV:
970#undef RISCV_DYNAMIC_TAG
971#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
972#include "llvm/BinaryFormat/DynamicTags.def"
973#undef RISCV_DYNAMIC_TAG
974#define RISCV_DYNAMIC_TAG(name, value)
  break;
default:
977#include "llvm/BinaryFormat/DynamicTags.def"
  break;
}
980#undef AARCH64_DYNAMIC_TAG
981#undef MIPS_DYNAMIC_TAG
982#undef HEXAGON_DYNAMIC_TAG
983#undef PPC_DYNAMIC_TAG
984#undef PPC64_DYNAMIC_TAG
985#undef DYNAMIC_TAG_MARKER
986#undef STRINGIFY
987#undef DYNAMIC_TAG

IO.enumFallback<Hex64>(Value);
990}

992void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
  IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
994#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
ECase(REG_NONE);
ECase(REG_32);
ECase(REG_64);
ECase(REG_128);
999#undef ECase
1000}

1002void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
  IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
1004#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
ECase(FP_ANY);
ECase(FP_DOUBLE);
ECase(FP_SINGLE);
ECase(FP_SOFT);
ECase(FP_OLD_64);
ECase(FP_XX);
ECase(FP_64);
ECase(FP_64A);
1013#undef ECase
1014}

1016void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
  IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
1018#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
ECase(EXT_NONE);
ECase(EXT_XLR);
ECase(EXT_OCTEON2);
ECase(EXT_OCTEONP);
ECase(EXT_LOONGSON_3A);
ECase(EXT_OCTEON);
ECase(EXT_5900);
ECase(EXT_4650);
ECase(EXT_4010);
ECase(EXT_4100);
ECase(EXT_3900);
ECase(EXT_10000);
ECase(EXT_SB1);
ECase(EXT_4111);
ECase(EXT_4120);
ECase(EXT_5400);
ECase(EXT_5500);
ECase(EXT_LOONGSON_2E);
ECase(EXT_LOONGSON_2F);
ECase(EXT_OCTEON3);
1039#undef ECase
1040}

1042void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
  IO &IO, ELFYAML::MIPS_ISA &Value) {
IO.enumCase(Value, "MIPS1", 1);
IO.enumCase(Value, "MIPS2", 2);
IO.enumCase(Value, "MIPS3", 3);
IO.enumCase(Value, "MIPS4", 4);
IO.enumCase(Value, "MIPS5", 5);
IO.enumCase(Value, "MIPS32", 32);
IO.enumCase(Value, "MIPS64", 64);
IO.enumFallback<Hex32>(Value);
1052}

1054void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
  IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
1056#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
BCase(DSP);
BCase(DSPR2);
BCase(EVA);
BCase(MCU);
BCase(MDMX);
BCase(MIPS3D);
BCase(MT);
BCase(SMARTMIPS);
BCase(VIRT);
BCase(MSA);
BCase(MIPS16);
BCase(MICROMIPS);
BCase(XPA);
BCase(CRC);
BCase(GINV);
1072#undef BCase
1073}

1075void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
  IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
1077#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
BCase(ODDSPREG);
1079#undef BCase
1080}

1082void MappingTraits<ELFYAML::SectionHeader>::mapping(
  IO &IO, ELFYAML::SectionHeader &SHdr) {
IO.mapRequired("Name", SHdr.Name);
1085}

1087void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                               ELFYAML::FileHeader &FileHdr) {
IO.mapRequired("Class", FileHdr.Class);
IO.mapRequired("Data", FileHdr.Data);
IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
IO.mapRequired("Type", FileHdr.Type);
IO.mapOptional("Machine", FileHdr.Machine);
IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
IO.mapOptional("SectionHeaderStringTable", FileHdr.SectionHeaderStringTable);

// obj2yaml does not dump these fields.
assert(!IO.outputting() ||(static_cast <bool> (!IO.outputting() || (!FileHdr.EPhOff
 && !FileHdr.EPhEntSize && !FileHdr.EPhNum)) ?
 void (0) : __assert_fail ("!IO.outputting() || (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1101, __extension__ __PRETTY_FUNCTION__
))
       (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum))(static_cast <bool> (!IO.outputting() || (!FileHdr.EPhOff
 && !FileHdr.EPhEntSize && !FileHdr.EPhNum)) ?
 void (0) : __assert_fail ("!IO.outputting() || (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1101, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("EPhOff", FileHdr.EPhOff);
IO.mapOptional("EPhEntSize", FileHdr.EPhEntSize);
IO.mapOptional("EPhNum", FileHdr.EPhNum);
IO.mapOptional("EShEntSize", FileHdr.EShEntSize);
IO.mapOptional("EShOff", FileHdr.EShOff);
IO.mapOptional("EShNum", FileHdr.EShNum);
IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
1109}

1111void MappingTraits<ELFYAML::ProgramHeader>::mapping(
  IO &IO, ELFYAML::ProgramHeader &Phdr) {
IO.mapRequired("Type", Phdr.Type);
IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
IO.mapOptional("FirstSec", Phdr.FirstSec);
IO.mapOptional("LastSec", Phdr.LastSec);
IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
IO.mapOptional("Align", Phdr.Align);
IO.mapOptional("FileSize", Phdr.FileSize);
IO.mapOptional("MemSize", Phdr.MemSize);
IO.mapOptional("Offset", Phdr.Offset);
1123}

1125std::string MappingTraits<ELFYAML::ProgramHeader>::validate(
  IO &IO, ELFYAML::ProgramHeader &FileHdr) {
if (!FileHdr.FirstSec && FileHdr.LastSec)
  return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
if (FileHdr.FirstSec && !FileHdr.LastSec)
  return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
return "";
1132}

1134LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)struct StOtherPiece { StOtherPiece() = default; StOtherPiece(
const StringRef v) : value(v) {} StOtherPiece(const StOtherPiece
 &v) = default; StOtherPiece &operator=(const StOtherPiece
 &rhs) = default; StOtherPiece &operator=(const StringRef
 &rhs) { value = rhs; return *this; } operator const StringRef
 & () const { return value; } bool operator==(const StOtherPiece
 &rhs) const { return value == rhs.value; } bool operator
==(const StringRef &rhs) const { return value == rhs; } bool
 operator<(const StOtherPiece &rhs) const { return value
 < rhs.value; } StringRef value; using BaseType = StringRef
; };

1136template <> struct ScalarTraits<StOtherPiece> {
static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
  Out << Val;
}
static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
  Val = Scalar;
  return {};
}
static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1145};
1146template <> struct SequenceElementTraits<StOtherPiece> {
static const bool flow = true;
1148};

1150template <> struct ScalarTraits<ELFYAML::YAMLFlowString> {
static void output(const ELFYAML::YAMLFlowString &Val, void *,
                   raw_ostream &Out) {
  Out << Val;
}
static StringRef input(StringRef Scalar, void *,
                       ELFYAML::YAMLFlowString &Val) {
  Val = Scalar;
  return {};
}
static QuotingType mustQuote(StringRef S) {
  return ScalarTraits<StringRef>::mustQuote(S);
}
1163};
1164template <> struct SequenceElementTraits<ELFYAML::YAMLFlowString> {
static const bool flow = true;
1166};

1168namespace {

1170struct NormalizedOther {
NormalizedOther(IO &IO) : YamlIO(IO) {}
NormalizedOther(IO &IO, std::optional<uint8_t> Original) : YamlIO(IO) {
  assert(Original && "This constructor is only used for outputting YAML and "(static_cast <bool> (Original && "This constructor is only used for outputting YAML and "
 "assumes a non-empty Original") ? void (0) : __assert_fail (
"Original && \"This constructor is only used for outputting YAML and \" \"assumes a non-empty Original\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1174, __extension__ __PRETTY_FUNCTION__
))
                     "assumes a non-empty Original")(static_cast <bool> (Original && "This constructor is only used for outputting YAML and "
 "assumes a non-empty Original") ? void (0) : __assert_fail (
"Original && \"This constructor is only used for outputting YAML and \" \"assumes a non-empty Original\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1174, __extension__ __PRETTY_FUNCTION__
));
  std::vector<StOtherPiece> Ret;
  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
  for (std::pair<StringRef, uint8_t> &P :
       getFlags(Object->getMachine()).takeVector()) {
    uint8_t FlagValue = P.second;
    if ((*Original & FlagValue) != FlagValue)
      continue;
    *Original &= ~FlagValue;
    Ret.push_back({P.first});
  }

  if (*Original != 0) {
    UnknownFlagsHolder = std::to_string(*Original);
    Ret.push_back({UnknownFlagsHolder});
  }

  if (!Ret.empty())
    Other = std::move(Ret);
}

uint8_t toValue(StringRef Name) {
  const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
  MapVector<StringRef, uint8_t> Flags = getFlags(Object->getMachine());

  auto It = Flags.find(Name);
  if (It != Flags.end())
    return It->second;

  uint8_t Val;
  if (to_integer(Name, Val))
    return Val;

  YamlIO.setError("an unknown value is used for symbol's 'Other' field: " +
                  Name);
  return 0;
}

std::optional<uint8_t> denormalize(IO &) {
  if (!Other)
    return std::nullopt;
  uint8_t Ret = 0;
  for (StOtherPiece &Val : *Other)
    Ret |= toValue(Val);
  return Ret;
}

// st_other field is used to encode symbol visibility and platform-dependent
// flags and values. This method returns a name to value map that is used for
// parsing and encoding this field.
MapVector<StringRef, uint8_t> getFlags(unsigned EMachine) {
  MapVector<StringRef, uint8_t> Map;
  // STV_* values are just enumeration values. We add them in a reversed order
  // because when we convert the st_other to named constants when printing
  // YAML we want to use a maximum number of bits on each step:
  // when we have st_other == 3, we want to print it as STV_PROTECTED (3), but
  // not as STV_HIDDEN (2) + STV_INTERNAL (1).
  Map["STV_PROTECTED"] = ELF::STV_PROTECTED;
  Map["STV_HIDDEN"] = ELF::STV_HIDDEN;
  Map["STV_INTERNAL"] = ELF::STV_INTERNAL;
  // STV_DEFAULT is used to represent the default visibility and has a value
  // 0. We want to be able to read it from YAML documents, but there is no
  // reason to print it.
  if (!YamlIO.outputting())
    Map["STV_DEFAULT"] = ELF::STV_DEFAULT;

  // MIPS is not consistent. All of the STO_MIPS_* values are bit flags,
  // except STO_MIPS_MIPS16 which overlaps them. It should be checked and
  // consumed first when we print the output, because we do not want to print
  // any other flags that have the same bits instead.
  if (EMachine == ELF::EM_MIPS) {
    Map["STO_MIPS_MIPS16"] = ELF::STO_MIPS_MIPS16;
    Map["STO_MIPS_MICROMIPS"] = ELF::STO_MIPS_MICROMIPS;
    Map["STO_MIPS_PIC"] = ELF::STO_MIPS_PIC;
    Map["STO_MIPS_PLT"] = ELF::STO_MIPS_PLT;
    Map["STO_MIPS_OPTIONAL"] = ELF::STO_MIPS_OPTIONAL;
  }

  if (EMachine == ELF::EM_AARCH64)
    Map["STO_AARCH64_VARIANT_PCS"] = ELF::STO_AARCH64_VARIANT_PCS;
  if (EMachine == ELF::EM_RISCV)
    Map["STO_RISCV_VARIANT_CC"] = ELF::STO_RISCV_VARIANT_CC;
  return Map;
}

IO &YamlIO;
std::optional<std::vector<StOtherPiece>> Other;
std::string UnknownFlagsHolder;
1262};

1264} // end anonymous namespace

1266void ScalarTraits<ELFYAML::YAMLIntUInt>::output(const ELFYAML::YAMLIntUInt &Val,
                                              void *Ctx, raw_ostream &Out) {
Out << Val;
1269}

1271StringRef ScalarTraits<ELFYAML::YAMLIntUInt>::input(StringRef Scalar, void *Ctx,
                                                  ELFYAML::YAMLIntUInt &Val) {
const bool Is64 = static_cast<ELFYAML::Object *>(Ctx)->Header.Class ==
                  ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
StringRef ErrMsg = "invalid number";
// We do not accept negative hex numbers because their meaning is ambiguous.
// For example, would -0xfffffffff mean 1 or INT32_MIN?
if (Scalar.empty() || Scalar.startswith("-0x"))
  return ErrMsg;

if (Scalar.startswith("-")) {
  const int64_t MinVal = Is64 ? INT64_MIN(-9223372036854775807L -1) : INT32_MIN(-2147483647-1);
  long long Int;
  if (getAsSignedInteger(Scalar, /*Radix=*/0, Int) || (Int < MinVal))
    return ErrMsg;
  Val = Int;
  return "";
}

const uint64_t MaxVal = Is64 ? UINT64_MAX(18446744073709551615UL) : UINT32_MAX(4294967295U);
unsigned long long UInt;
if (getAsUnsignedInteger(Scalar, /*Radix=*/0, UInt) || (UInt > MaxVal))
  return ErrMsg;
Val = UInt;
return "";
1296}

1298void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
IO.mapOptional("Name", Symbol.Name, StringRef());
IO.mapOptional("StName", Symbol.StName);
IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
IO.mapOptional("Section", Symbol.Section);
IO.mapOptional("Index", Symbol.Index);
IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
IO.mapOptional("Value", Symbol.Value);
IO.mapOptional("Size", Symbol.Size);

// Symbol's Other field is a bit special. It is usually a field that
// represents st_other and holds the symbol visibility. However, on some
// platforms, it can contain bit fields and regular values, or even sometimes
// a crazy mix of them (see comments for NormalizedOther). Because of this, we
// need special handling.
MappingNormalization<NormalizedOther, std::optional<uint8_t>> Keys(
    IO, Symbol.Other);
IO.mapOptional("Other", Keys->Other);
1316}

1318std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
                                                   ELFYAML::Symbol &Symbol) {
if (Symbol.Index && Symbol.Section)
  return "Index and Section cannot both be specified for Symbol";
return "";
1323}

1325static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
IO.mapOptional("Name", Section.Name, StringRef());
IO.mapRequired("Type", Section.Type);
IO.mapOptional("Flags", Section.Flags);
IO.mapOptional("Address", Section.Address);
IO.mapOptional("Link", Section.Link);
IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
IO.mapOptional("EntSize", Section.EntSize);
IO.mapOptional("Offset", Section.Offset);

IO.mapOptional("Content", Section.Content);
IO.mapOptional("Size", Section.Size);

// obj2yaml does not dump these fields. They are expected to be empty when we
// are producing YAML, because yaml2obj sets appropriate values for them
// automatically when they are not explicitly defined.
assert(!IO.outputting() ||(static_cast <bool> (!IO.outputting() || (!Section.ShOffset
 && !Section.ShSize && !Section.ShName &&
 !Section.ShFlags && !Section.ShType && !Section
.ShAddrAlign)) ? void (0) : __assert_fail ("!IO.outputting() || (!Section.ShOffset && !Section.ShSize && !Section.ShName && !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1343, __extension__ __PRETTY_FUNCTION__
))
       (!Section.ShOffset && !Section.ShSize && !Section.ShName &&(static_cast <bool> (!IO.outputting() || (!Section.ShOffset
 && !Section.ShSize && !Section.ShName &&
 !Section.ShFlags && !Section.ShType && !Section
.ShAddrAlign)) ? void (0) : __assert_fail ("!IO.outputting() || (!Section.ShOffset && !Section.ShSize && !Section.ShName && !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1343, __extension__ __PRETTY_FUNCTION__
))
        !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign))(static_cast <bool> (!IO.outputting() || (!Section.ShOffset
 && !Section.ShSize && !Section.ShName &&
 !Section.ShFlags && !Section.ShType && !Section
.ShAddrAlign)) ? void (0) : __assert_fail ("!IO.outputting() || (!Section.ShOffset && !Section.ShSize && !Section.ShName && !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1343, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("ShAddrAlign", Section.ShAddrAlign);
IO.mapOptional("ShName", Section.ShName);
IO.mapOptional("ShOffset", Section.ShOffset);
IO.mapOptional("ShSize", Section.ShSize);
IO.mapOptional("ShFlags", Section.ShFlags);
IO.mapOptional("ShType", Section.ShType);
1350}

1352static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1355}

1357static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
commonSectionMapping(IO, Section);

// We also support reading a content as array of bytes using the ContentArray
// key. obj2yaml never prints this field.
assert(!IO.outputting() || !Section.ContentBuf)(static_cast <bool> (!IO.outputting() || !Section.ContentBuf
) ? void (0) : __assert_fail ("!IO.outputting() || !Section.ContentBuf"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1362, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("ContentArray", Section.ContentBuf);
if (Section.ContentBuf) {
  if (Section.Content)
    IO.setError("Content and ContentArray can't be used together");
  Section.Content = yaml::BinaryRef(*Section.ContentBuf);
}

IO.mapOptional("Info", Section.Info);
1371}

1373static void sectionMapping(IO &IO, ELFYAML::BBAddrMapSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Content", Section.Content);
IO.mapOptional("Entries", Section.Entries);
1377}

1379static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1382}

1384static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Bucket", Section.Bucket);
IO.mapOptional("Chain", Section.Chain);

// obj2yaml does not dump these fields. They can be used to override nchain
// and nbucket values for creating broken sections.
assert(!IO.outputting() || (!Section.NBucket && !Section.NChain))(static_cast <bool> (!IO.outputting() || (!Section.NBucket
 && !Section.NChain)) ? void (0) : __assert_fail ("!IO.outputting() || (!Section.NBucket && !Section.NChain)"
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1391, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("NChain", Section.NChain);
IO.mapOptional("NBucket", Section.NBucket);
1394}

1396static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Notes", Section.Notes);
1399}


1402static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Header", Section.Header);
IO.mapOptional("BloomFilter", Section.BloomFilter);
IO.mapOptional("HashBuckets", Section.HashBuckets);
IO.mapOptional("HashValues", Section.HashValues);
1408}
1409static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
commonSectionMapping(IO, Section);
1411}

1413static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.Info);
IO.mapOptional("Entries", Section.Entries);
1417}

1419static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1422}

1424static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.Info);
IO.mapOptional("Dependencies", Section.VerneedV);
1428}

1430static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.RelocatableSec, StringRef());
IO.mapOptional("Relocations", Section.Relocations);
1434}

1436static void sectionMapping(IO &IO, ELFYAML::RelrSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1439}

1441static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group) {
commonSectionMapping(IO, Group);
IO.mapOptional("Info", Group.Signature);
IO.mapOptional("Members", Group.Members);
1445}

1447static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1450}

1452static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Symbols", Section.Symbols);
1455}

1457static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
IO.mapOptional("Name", Fill.Name, StringRef());
IO.mapOptional("Pattern", Fill.Pattern);
IO.mapOptional("Offset", Fill.Offset);
IO.mapRequired("Size", Fill.Size);
1462}

1464static void sectionHeaderTableMapping(IO &IO,
                                    ELFYAML::SectionHeaderTable &SHT) {
IO.mapOptional("Offset", SHT.Offset);
IO.mapOptional("Sections", SHT.Sections);
IO.mapOptional("Excluded", SHT.Excluded);
IO.mapOptional("NoHeaders", SHT.NoHeaders);
1470}

1472static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Options", Section.Options);
1475}

1477static void sectionMapping(IO &IO,
                         ELFYAML::DependentLibrariesSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Libraries", Section.Libs);
1481}

1483static void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1486}

1488void MappingTraits<ELFYAML::SectionOrType>::mapping(
  IO &IO, ELFYAML::SectionOrType &sectionOrType) {
IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
1491}

1493static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
1496}

1498static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Version", Section.Version, Hex16(0));
IO.mapRequired("ISA", Section.ISALevel);
IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
IO.mapOptional("ISAExtension", Section.ISAExtension,
               ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
IO.mapOptional("FpABI", Section.FpABI,
               ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
IO.mapOptional("GPRSize", Section.GPRSize,
               ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR1Size", Section.CPR1Size,
               ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR2Size", Section.CPR2Size,
               ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
1516}

1518static StringRef getStringValue(IO &IO, const char *Key) {
StringRef Val;
IO.mapRequired(Key, Val);
return Val;
1522}

1524static void setStringValue(IO &IO, const char *Key, StringRef Val) {
IO.mapRequired(Key, Val);
1526}

1528static bool isInteger(StringRef Val) {
APInt Tmp;
return !Val.getAsInteger(0, Tmp);
1531}

1533void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
  IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
ELFYAML::ELF_SHT Type;
1
Calling defaulted default constructor for 'ELF_SHT'→
3
←
Returning from default constructor for 'ELF_SHT'→
StringRef TypeStr;
if (IO.outputting()) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
  if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))
    Type = S->Type;
  else if (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))
    TypeStr = SHT->TypeStr;
} else {
  // When the Type string does not have a "SHT_" prefix, we know it is not a
  // description of a regular ELF output section.
  TypeStr = getStringValue(IO, "Type");
  if (TypeStr.startswith("SHT_") || isInteger(TypeStr))
6
←
Assuming the condition is true→
    IO.mapRequired("Type", Type);
7
←
Calling 'IO::mapRequired'→
14
←
Returning from 'IO::mapRequired'→
}

if (TypeStr == "Fill") {
15
←
Assuming the condition is false→
16
←
Taking false branch→
  assert(!IO.outputting())(static_cast <bool> (!IO.outputting()) ? void (0) : __assert_fail
 ("!IO.outputting()", "llvm/lib/ObjectYAML/ELFYAML.cpp", 1551
, __extension__ __PRETTY_FUNCTION__)); // We don't dump fills currently.
  Section.reset(new ELFYAML::Fill());
  fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
  return;
}

if (TypeStr == ELFYAML::SectionHeaderTable::TypeStr) {
17
←
Assuming the condition is false→
18
←
Taking false branch→
  if (IO.outputting())
    setStringValue(IO, "Type", TypeStr);
  else
    Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));

  sectionHeaderTableMapping(
      IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));
  return;
}

const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
19
←
Assuming the condition is true→
20
←
Calling 'ELF_SHT::operator=='→
  if (!IO.outputting())
    Section.reset(new ELFYAML::MipsABIFlags());
  sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
  return;
}

if (Obj.getMachine() == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX) {
  if (!IO.outputting())
    Section.reset(new ELFYAML::ARMIndexTableSection());
  sectionMapping(IO, *cast<ELFYAML::ARMIndexTableSection>(Section.get()));
  return;
}

switch (Type) {
case ELF::SHT_DYNAMIC:
  if (!IO.outputting())
    Section.reset(new ELFYAML::DynamicSection());
  sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
  break;
case ELF::SHT_REL:
case ELF::SHT_RELA:
  if (!IO.outputting())
    Section.reset(new ELFYAML::RelocationSection());
  sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
  break;
case ELF::SHT_RELR:
  if (!IO.outputting())
    Section.reset(new ELFYAML::RelrSection());
  sectionMapping(IO, *cast<ELFYAML::RelrSection>(Section.get()));
  break;
case ELF::SHT_GROUP:
  if (!IO.outputting())
    Section.reset(new ELFYAML::GroupSection());
  groupSectionMapping(IO, *cast<ELFYAML::GroupSection>(Section.get()));
  break;
case ELF::SHT_NOBITS:
  if (!IO.outputting())
    Section.reset(new ELFYAML::NoBitsSection());
  sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
  break;
case ELF::SHT_HASH:
  if (!IO.outputting())
    Section.reset(new ELFYAML::HashSection());
  sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
  break;
case ELF::SHT_NOTE:
  if (!IO.outputting())
    Section.reset(new ELFYAML::NoteSection());
  sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
  break;
case ELF::SHT_GNU_HASH:
  if (!IO.outputting())
    Section.reset(new ELFYAML::GnuHashSection());
  sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
  break;
case ELF::SHT_GNU_verdef:
  if (!IO.outputting())
    Section.reset(new ELFYAML::VerdefSection());
  sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
  break;
case ELF::SHT_GNU_versym:
  if (!IO.outputting())
    Section.reset(new ELFYAML::SymverSection());
  sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
  break;
case ELF::SHT_GNU_verneed:
  if (!IO.outputting())
    Section.reset(new ELFYAML::VerneedSection());
  sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
  break;
case ELF::SHT_SYMTAB_SHNDX:
  if (!IO.outputting())
    Section.reset(new ELFYAML::SymtabShndxSection());
  sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
  break;
case ELF::SHT_LLVM_ADDRSIG:
  if (!IO.outputting())
    Section.reset(new ELFYAML::AddrsigSection());
  sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
  break;
case ELF::SHT_LLVM_LINKER_OPTIONS:
  if (!IO.outputting())
    Section.reset(new ELFYAML::LinkerOptionsSection());
  sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));
  break;
case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
  if (!IO.outputting())
    Section.reset(new ELFYAML::DependentLibrariesSection());
  sectionMapping(IO,
                 *cast<ELFYAML::DependentLibrariesSection>(Section.get()));
  break;
case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
  if (!IO.outputting())
    Section.reset(new ELFYAML::CallGraphProfileSection());
  sectionMapping(IO, *cast<ELFYAML::CallGraphProfileSection>(Section.get()));
  break;
case ELF::SHT_LLVM_BB_ADDR_MAP_V0:
case ELF::SHT_LLVM_BB_ADDR_MAP:
  if (!IO.outputting())
    Section.reset(new ELFYAML::BBAddrMapSection());
  sectionMapping(IO, *cast<ELFYAML::BBAddrMapSection>(Section.get()));
  break;
default:
  if (!IO.outputting()) {
    StringRef Name;
    IO.mapOptional("Name", Name, StringRef());
    Name = ELFYAML::dropUniqueSuffix(Name);

    if (ELFYAML::StackSizesSection::nameMatches(Name))
      Section = std::make_unique<ELFYAML::StackSizesSection>();
    else
      Section = std::make_unique<ELFYAML::RawContentSection>();
  }

  if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
    sectionMapping(IO, *S);
  else
    sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
}
1689}

1691std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
  IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
  if (F->Pattern && F->Pattern->binary_size() != 0 && !F->Size)
    return "\"Size\" can't be 0 when \"Pattern\" is not empty";
  return "";
}

if (const auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
  if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))
    return "NoHeaders can't be used together with Offset/Sections/Excluded";
  return "";
}

const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
if (Sec.Size && Sec.Content &&
    (uint64_t)(*Sec.Size) < Sec.Content->binary_size())
  return "Section size must be greater than or equal to the content size";

auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
  std::string Msg;
  for (size_t I = 0, E = EntV.size(); I != E; ++I) {
    StringRef Name = EntV[I].first;
    if (I == 0) {
      Msg = "\"" + Name.str() + "\"";
      continue;
    }
    if (I != EntV.size() - 1)
      Msg += ", \"" + Name.str() + "\"";
    else
      Msg += " and \"" + Name.str() + "\"";
  }
  return Msg;
};

std::vector<std::pair<StringRef, bool>> Entries = Sec.getEntries();
const size_t NumUsedEntries = llvm::count_if(
    Entries, [](const std::pair<StringRef, bool> &P) { return P.second; });

if ((Sec.Size || Sec.Content) && NumUsedEntries > 0)
  return BuildErrPrefix(Entries) +
         " cannot be used with \"Content\" or \"Size\"";

if (NumUsedEntries > 0 && Entries.size() != NumUsedEntries)
  return BuildErrPrefix(Entries) + " must be used together";

if (const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(C.get())) {
  if (RawSection->Flags && RawSection->ShFlags)
    return "ShFlags and Flags cannot be used together";
  return "";
}

if (const auto *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {
  if (NB->Content)
    return "SHT_NOBITS section cannot have \"Content\"";
  return "";
}

if (const auto *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {
  if (MF->Content)
    return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
           "sections";
  if (MF->Size)
    return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
  return "";
}

return "";
1759}

1761namespace {

1763struct NormalizedMips64RelType {
NormalizedMips64RelType(IO &)
    : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
      Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
      Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
      SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
    : Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
      Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}

ELFYAML::ELF_REL denormalize(IO &) {
  ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
  return Res;
}

ELFYAML::ELF_REL Type;
ELFYAML::ELF_REL Type2;
ELFYAML::ELF_REL Type3;
ELFYAML::ELF_RSS SpecSym;
1782};

1784} // end anonymous namespace

1786void MappingTraits<ELFYAML::StackSizeEntry>::mapping(
  IO &IO, ELFYAML::StackSizeEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1788, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("Address", E.Address, Hex64(0));
IO.mapRequired("Size", E.Size);
1791}

1793void MappingTraits<ELFYAML::BBAddrMapEntry>::mapping(
  IO &IO, ELFYAML::BBAddrMapEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1795, __extension__ __PRETTY_FUNCTION__
));
IO.mapRequired("Version", E.Version);
IO.mapOptional("Feature", E.Feature, Hex8(0));
IO.mapOptional("Address", E.Address, Hex64(0));
IO.mapOptional("NumBlocks", E.NumBlocks);
IO.mapOptional("BBEntries", E.BBEntries);
1801}

1803void MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry>::mapping(
  IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1805, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("ID", E.ID);
IO.mapRequired("AddressOffset", E.AddressOffset);
IO.mapRequired("Size", E.Size);
IO.mapRequired("Metadata", E.Metadata);
1810}

1812void MappingTraits<ELFYAML::GnuHashHeader>::mapping(IO &IO,
                                                  ELFYAML::GnuHashHeader &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1814, __extension__ __PRETTY_FUNCTION__
));
IO.mapOptional("NBuckets", E.NBuckets);
IO.mapRequired("SymNdx", E.SymNdx);
IO.mapOptional("MaskWords", E.MaskWords);
IO.mapRequired("Shift2", E.Shift2);
1819}

1821void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
                                                 ELFYAML::DynamicEntry &Rel) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1823, __extension__ __PRETTY_FUNCTION__
));

IO.mapRequired("Tag", Rel.Tag);
IO.mapRequired("Value", Rel.Val);
1827}

1829void MappingTraits<ELFYAML::NoteEntry>::mapping(IO &IO, ELFYAML::NoteEntry &N) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1830, __extension__ __PRETTY_FUNCTION__
));

IO.mapOptional("Name", N.Name);
IO.mapOptional("Desc", N.Desc);
IO.mapRequired("Type", N.Type);
1835}

1837void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,
                                                ELFYAML::VerdefEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1839, __extension__ __PRETTY_FUNCTION__
));

IO.mapOptional("Version", E.Version);
IO.mapOptional("Flags", E.Flags);
IO.mapOptional("VersionNdx", E.VersionNdx);
IO.mapOptional("Hash", E.Hash);
IO.mapRequired("Names", E.VerNames);
1846}

1848void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,
                                                 ELFYAML::VerneedEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1850, __extension__ __PRETTY_FUNCTION__
));

IO.mapRequired("Version", E.Version);
IO.mapRequired("File", E.File);
IO.mapRequired("Entries", E.AuxV);
1855}

1857void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,
                                                 ELFYAML::VernauxEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1859, __extension__ __PRETTY_FUNCTION__
));

IO.mapRequired("Name", E.Name);
IO.mapRequired("Hash", E.Hash);
IO.mapRequired("Flags", E.Flags);
IO.mapRequired("Other", E.Other);
1865}

1867void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
                                               ELFYAML::Relocation &Rel) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized")(static_cast <bool> (Object && "The IO context is not initialized"
) ? void (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1870, __extension__ __PRETTY_FUNCTION__
));

IO.mapOptional("Offset", Rel.Offset, (Hex64)0);
IO.mapOptional("Symbol", Rel.Symbol);

if (Object->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
    Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
  MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
      IO, Rel.Type);
  IO.mapRequired("Type", Key->Type);
  IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
  IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
  IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
} else
  IO.mapRequired("Type", Rel.Type);

IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);
1887}

1889void MappingTraits<ELFYAML::ARMIndexTableEntry>::mapping(
  IO &IO, ELFYAML::ARMIndexTableEntry &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1891, __extension__ __PRETTY_FUNCTION__
));
IO.mapRequired("Offset", E.Offset);

StringRef CantUnwind = "EXIDX_CANTUNWIND";
if (IO.outputting() && (uint32_t)E.Value == ARM::EHABI::EXIDX_CANTUNWIND)
  IO.mapRequired("Value", CantUnwind);
else if (!IO.outputting() && getStringValue(IO, "Value") == CantUnwind)
  E.Value = ARM::EHABI::EXIDX_CANTUNWIND;
else
  IO.mapRequired("Value", E.Value);
1901}

1903void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
assert(!IO.getContext() && "The IO context is initialized already")(static_cast <bool> (!IO.getContext() && "The IO context is initialized already"
) ? void (0) : __assert_fail ("!IO.getContext() && \"The IO context is initialized already\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1904, __extension__ __PRETTY_FUNCTION__
));
IO.setContext(&Object);
IO.mapTag("!ELF", true);
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
IO.mapOptional("Sections", Object.Chunks);
IO.mapOptional("Symbols", Object.Symbols);
IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
IO.mapOptional("DWARF", Object.DWARF);
if (Object.DWARF) {
  Object.DWARF->IsLittleEndian =
      Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
  Object.DWARF->Is64BitAddrSize =
      Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
}
IO.setContext(nullptr);
1920}

1922void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
                                                 ELFYAML::LinkerOption &Opt) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1924, __extension__ __PRETTY_FUNCTION__
));
IO.mapRequired("Name", Opt.Key);
IO.mapRequired("Value", Opt.Value);
1927}

1929void MappingTraits<ELFYAML::CallGraphEntryWeight>::mapping(
  IO &IO, ELFYAML::CallGraphEntryWeight &E) {
assert(IO.getContext() && "The IO context is not initialized")(static_cast <bool> (IO.getContext() && "The IO context is not initialized"
) ? void (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "llvm/lib/ObjectYAML/ELFYAML.cpp", 1931, __extension__ __PRETTY_FUNCTION__
));
IO.mapRequired("Weight", E.Weight);
1933}

1935LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)struct MIPS_AFL_REG { MIPS_AFL_REG() = default; MIPS_AFL_REG(
const uint8_t v) : value(v) {} MIPS_AFL_REG(const MIPS_AFL_REG
 &v) = default; MIPS_AFL_REG &operator=(const MIPS_AFL_REG
 &rhs) = default; MIPS_AFL_REG &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const MIPS_AFL_REG
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_REG &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
1936LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)struct MIPS_ABI_FP { MIPS_ABI_FP() = default; MIPS_ABI_FP(const
 uint8_t v) : value(v) {} MIPS_ABI_FP(const MIPS_ABI_FP &
v) = default; MIPS_ABI_FP &operator=(const MIPS_ABI_FP &
rhs) = default; MIPS_ABI_FP &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
 () const { return value; } bool operator==(const MIPS_ABI_FP
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_ABI_FP &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
1937LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)struct MIPS_AFL_EXT { MIPS_AFL_EXT() = default; MIPS_AFL_EXT(
const uint32_t v) : value(v) {} MIPS_AFL_EXT(const MIPS_AFL_EXT
 &v) = default; MIPS_AFL_EXT &operator=(const MIPS_AFL_EXT
 &rhs) = default; MIPS_AFL_EXT &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_EXT
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_EXT &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
1938LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)struct MIPS_AFL_ASE { MIPS_AFL_ASE() = default; MIPS_AFL_ASE(
const uint32_t v) : value(v) {} MIPS_AFL_ASE(const MIPS_AFL_ASE
 &v) = default; MIPS_AFL_ASE &operator=(const MIPS_AFL_ASE
 &rhs) = default; MIPS_AFL_ASE &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_ASE
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_ASE &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
1939LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)struct MIPS_AFL_FLAGS1 { MIPS_AFL_FLAGS1() = default; MIPS_AFL_FLAGS1
(const uint32_t v) : value(v) {} MIPS_AFL_FLAGS1(const MIPS_AFL_FLAGS1
 &v) = default; MIPS_AFL_FLAGS1 &operator=(const MIPS_AFL_FLAGS1
 &rhs) = default; MIPS_AFL_FLAGS1 &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_FLAGS1
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_FLAGS1 &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };

1941} // end namespace yaml

1943} // end namespace llvm

←

/build/source/llvm/include/llvm/ObjectYAML/ELFYAML.h

→

1//===- ELFYAML.h - ELF YAMLIO implementation --------------------*- C++ -*-===//
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/// \file
10/// This file declares classes for handling the YAML representation
11/// of ELF.
12///
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_OBJECTYAML_ELFYAML_H
16#define LLVM_OBJECTYAML_ELFYAML_H
17 
18#include "llvm/ADT/StringRef.h"
19#include "llvm/BinaryFormat/ELF.h"
20#include "llvm/Object/ELFTypes.h"
21#include "llvm/ObjectYAML/DWARFYAML.h"
22#include "llvm/ObjectYAML/YAML.h"
23#include "llvm/Support/YAMLTraits.h"
24#include <cstdint>
25#include <memory>
26#include <optional>
27#include <vector>
28 
29namespace llvm {
30namespace ELFYAML {
31 
32StringRef dropUniqueSuffix(StringRef S);
33std::string appendUniqueSuffix(StringRef Name, const Twine& Msg);
34 
35// These types are invariant across 32/64-bit ELF, so for simplicity just
36// directly give them their exact sizes. We don't need to worry about
37// endianness because these are just the types in the YAMLIO structures,
38// and are appropriately converted to the necessary endianness when
39// reading/generating binary object files.
40// The naming of these types is intended to be ELF_PREFIX, where PREFIX is
41// the common prefix of the respective constants. E.g. ELF_EM corresponds
42// to the `e_machine` constants, like `EM_X86_64`.
43// In the future, these would probably be better suited by C++11 enum
44// class's with appropriate fixed underlying type.
45LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)struct ELF_ET { ELF_ET() = default; ELF_ET(const uint16_t v) :
 value(v) {} ELF_ET(const ELF_ET &v) = default; ELF_ET &
operator=(const ELF_ET &rhs) = default; ELF_ET &operator
=(const uint16_t &rhs) { value = rhs; return *this; } operator
 const uint16_t & () const { return value; } bool operator
==(const ELF_ET &rhs) const { return value == rhs.value; }
 bool operator==(const uint16_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_ET &rhs) const { return
 value < rhs.value; } uint16_t value; using BaseType = uint16_t
; };
46LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)struct ELF_PT { ELF_PT() = default; ELF_PT(const uint32_t v) :
 value(v) {} ELF_PT(const ELF_PT &v) = default; ELF_PT &
operator=(const ELF_PT &rhs) = default; ELF_PT &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_PT &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_PT &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
47LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)struct ELF_EM { ELF_EM() = default; ELF_EM(const uint32_t v) :
 value(v) {} ELF_EM(const ELF_EM &v) = default; ELF_EM &
operator=(const ELF_EM &rhs) = default; ELF_EM &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_EM &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_EM &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
48LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)struct ELF_ELFCLASS { ELF_ELFCLASS() = default; ELF_ELFCLASS(
const uint8_t v) : value(v) {} ELF_ELFCLASS(const ELF_ELFCLASS
 &v) = default; ELF_ELFCLASS &operator=(const ELF_ELFCLASS
 &rhs) = default; ELF_ELFCLASS &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const ELF_ELFCLASS
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFCLASS &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
49LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)struct ELF_ELFDATA { ELF_ELFDATA() = default; ELF_ELFDATA(const
 uint8_t v) : value(v) {} ELF_ELFDATA(const ELF_ELFDATA &
v) = default; ELF_ELFDATA &operator=(const ELF_ELFDATA &
rhs) = default; ELF_ELFDATA &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
 () const { return value; } bool operator==(const ELF_ELFDATA
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFDATA &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
50LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)struct ELF_ELFOSABI { ELF_ELFOSABI() = default; ELF_ELFOSABI(
const uint8_t v) : value(v) {} ELF_ELFOSABI(const ELF_ELFOSABI
 &v) = default; ELF_ELFOSABI &operator=(const ELF_ELFOSABI
 &rhs) = default; ELF_ELFOSABI &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const ELF_ELFOSABI
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFOSABI &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
51// Just use 64, since it can hold 32-bit values too.
52LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)struct ELF_EF { ELF_EF() = default; ELF_EF(const uint64_t v) :
 value(v) {} ELF_EF(const ELF_EF &v) = default; ELF_EF &
operator=(const ELF_EF &rhs) = default; ELF_EF &operator
=(const uint64_t &rhs) { value = rhs; return *this; } operator
 const uint64_t & () const { return value; } bool operator
==(const ELF_EF &rhs) const { return value == rhs.value; }
 bool operator==(const uint64_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_EF &rhs) const { return
 value < rhs.value; } uint64_t value; using BaseType = uint64_t
; };
53// Just use 64, since it can hold 32-bit values too.
54LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_DYNTAG)struct ELF_DYNTAG { ELF_DYNTAG() = default; ELF_DYNTAG(const uint64_t
 v) : value(v) {} ELF_DYNTAG(const ELF_DYNTAG &v) = default
; ELF_DYNTAG &operator=(const ELF_DYNTAG &rhs) = default
; ELF_DYNTAG &operator=(const uint64_t &rhs) { value =
 rhs; return *this; } operator const uint64_t & () const {
 return value; } bool operator==(const ELF_DYNTAG &rhs) const
 { return value == rhs.value; } bool operator==(const uint64_t
 &rhs) const { return value == rhs; } bool operator<(const
 ELF_DYNTAG &rhs) const { return value < rhs.value; } uint64_t
 value; using BaseType = uint64_t; };
55LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)struct ELF_PF { ELF_PF() = default; ELF_PF(const uint32_t v) :
 value(v) {} ELF_PF(const ELF_PF &v) = default; ELF_PF &
operator=(const ELF_PF &rhs) = default; ELF_PF &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_PF &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_PF &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
56LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)struct ELF_SHT { ELF_SHT() = default; ELF_SHT(const uint32_t v
) : value(v) {} ELF_SHT(const ELF_SHT &v) = default; ELF_SHT
 &operator=(const ELF_SHT &rhs) = default; ELF_SHT &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const ELF_SHT &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHT &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
2
←
Returning without writing to 'this->value'→
21
←
The left operand of '==' is a garbage value
57LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_REL)struct ELF_REL { ELF_REL() = default; ELF_REL(const uint32_t v
) : value(v) {} ELF_REL(const ELF_REL &v) = default; ELF_REL
 &operator=(const ELF_REL &rhs) = default; ELF_REL &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const ELF_REL &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_REL &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
58LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)struct ELF_RSS { ELF_RSS() = default; ELF_RSS(const uint8_t v
) : value(v) {} ELF_RSS(const ELF_RSS &v) = default; ELF_RSS
 &operator=(const ELF_RSS &rhs) = default; ELF_RSS &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_RSS &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_RSS &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
59// Just use 64, since it can hold 32-bit values too.
60LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)struct ELF_SHF { ELF_SHF() = default; ELF_SHF(const uint64_t v
) : value(v) {} ELF_SHF(const ELF_SHF &v) = default; ELF_SHF
 &operator=(const ELF_SHF &rhs) = default; ELF_SHF &
operator=(const uint64_t &rhs) { value = rhs; return *this
; } operator const uint64_t & () const { return value; } bool
 operator==(const ELF_SHF &rhs) const { return value == rhs
.value; } bool operator==(const uint64_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHF &rhs) const
 { return value < rhs.value; } uint64_t value; using BaseType
 = uint64_t; };
61LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)struct ELF_SHN { ELF_SHN() = default; ELF_SHN(const uint16_t v
) : value(v) {} ELF_SHN(const ELF_SHN &v) = default; ELF_SHN
 &operator=(const ELF_SHN &rhs) = default; ELF_SHN &
operator=(const uint16_t &rhs) { value = rhs; return *this
; } operator const uint16_t & () const { return value; } bool
 operator==(const ELF_SHN &rhs) const { return value == rhs
.value; } bool operator==(const uint16_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHN &rhs) const
 { return value < rhs.value; } uint16_t value; using BaseType
 = uint16_t; };
62LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)struct ELF_STB { ELF_STB() = default; ELF_STB(const uint8_t v
) : value(v) {} ELF_STB(const ELF_STB &v) = default; ELF_STB
 &operator=(const ELF_STB &rhs) = default; ELF_STB &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_STB &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_STB &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
63LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)struct ELF_STT { ELF_STT() = default; ELF_STT(const uint8_t v
) : value(v) {} ELF_STT(const ELF_STT &v) = default; ELF_STT
 &operator=(const ELF_STT &rhs) = default; ELF_STT &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_STT &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_STT &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
64LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_NT)struct ELF_NT { ELF_NT() = default; ELF_NT(const uint32_t v) :
 value(v) {} ELF_NT(const ELF_NT &v) = default; ELF_NT &
operator=(const ELF_NT &rhs) = default; ELF_NT &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_NT &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_NT &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
65 
66LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)struct MIPS_AFL_REG { MIPS_AFL_REG() = default; MIPS_AFL_REG(
const uint8_t v) : value(v) {} MIPS_AFL_REG(const MIPS_AFL_REG
 &v) = default; MIPS_AFL_REG &operator=(const MIPS_AFL_REG
 &rhs) = default; MIPS_AFL_REG &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const MIPS_AFL_REG
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_REG &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
67LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)struct MIPS_ABI_FP { MIPS_ABI_FP() = default; MIPS_ABI_FP(const
 uint8_t v) : value(v) {} MIPS_ABI_FP(const MIPS_ABI_FP &
v) = default; MIPS_ABI_FP &operator=(const MIPS_ABI_FP &
rhs) = default; MIPS_ABI_FP &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
 () const { return value; } bool operator==(const MIPS_ABI_FP
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_ABI_FP &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
68LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)struct MIPS_AFL_EXT { MIPS_AFL_EXT() = default; MIPS_AFL_EXT(
const uint32_t v) : value(v) {} MIPS_AFL_EXT(const MIPS_AFL_EXT
 &v) = default; MIPS_AFL_EXT &operator=(const MIPS_AFL_EXT
 &rhs) = default; MIPS_AFL_EXT &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_EXT
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_EXT &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
69LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)struct MIPS_AFL_ASE { MIPS_AFL_ASE() = default; MIPS_AFL_ASE(
const uint32_t v) : value(v) {} MIPS_AFL_ASE(const MIPS_AFL_ASE
 &v) = default; MIPS_AFL_ASE &operator=(const MIPS_AFL_ASE
 &rhs) = default; MIPS_AFL_ASE &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_ASE
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_ASE &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
70LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)struct MIPS_AFL_FLAGS1 { MIPS_AFL_FLAGS1() = default; MIPS_AFL_FLAGS1
(const uint32_t v) : value(v) {} MIPS_AFL_FLAGS1(const MIPS_AFL_FLAGS1
 &v) = default; MIPS_AFL_FLAGS1 &operator=(const MIPS_AFL_FLAGS1
 &rhs) = default; MIPS_AFL_FLAGS1 &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_FLAGS1
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_FLAGS1 &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
71LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)struct MIPS_ISA { MIPS_ISA() = default; MIPS_ISA(const uint32_t
 v) : value(v) {} MIPS_ISA(const MIPS_ISA &v) = default; MIPS_ISA
 &operator=(const MIPS_ISA &rhs) = default; MIPS_ISA &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const MIPS_ISA &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const MIPS_ISA &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
72 
73LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)struct YAMLFlowString { YAMLFlowString() = default; YAMLFlowString
(const StringRef v) : value(v) {} YAMLFlowString(const YAMLFlowString
 &v) = default; YAMLFlowString &operator=(const YAMLFlowString
 &rhs) = default; YAMLFlowString &operator=(const StringRef
 &rhs) { value = rhs; return *this; } operator const StringRef
 & () const { return value; } bool operator==(const YAMLFlowString
 &rhs) const { return value == rhs.value; } bool operator
==(const StringRef &rhs) const { return value == rhs; } bool
 operator<(const YAMLFlowString &rhs) const { return value
 < rhs.value; } StringRef value; using BaseType = StringRef
; };
74LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)struct YAMLIntUInt { YAMLIntUInt() = default; YAMLIntUInt(const
 int64_t v) : value(v) {} YAMLIntUInt(const YAMLIntUInt &
v) = default; YAMLIntUInt &operator=(const YAMLIntUInt &
rhs) = default; YAMLIntUInt &operator=(const int64_t &
rhs) { value = rhs; return *this; } operator const int64_t &
 () const { return value; } bool operator==(const YAMLIntUInt
 &rhs) const { return value == rhs.value; } bool operator
==(const int64_t &rhs) const { return value == rhs; } bool
 operator<(const YAMLIntUInt &rhs) const { return value
 < rhs.value; } int64_t value; using BaseType = int64_t; }
;
75 
76template <class ELFT>
77unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
78                             StringRef SecName) {
79  if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
80    return sizeof(object::Elf_Mips_ABIFlags<ELFT>);
81 
82  switch (SecType) {
83  case ELF::SHT_SYMTAB:
84  case ELF::SHT_DYNSYM:
85    return sizeof(typename ELFT::Sym);
86  case ELF::SHT_GROUP:
87    return sizeof(typename ELFT::Word);
88  case ELF::SHT_REL:
89    return sizeof(typename ELFT::Rel);
90  case ELF::SHT_RELA:
91    return sizeof(typename ELFT::Rela);
92  case ELF::SHT_RELR:
93    return sizeof(typename ELFT::Relr);
94  case ELF::SHT_DYNAMIC:
95    return sizeof(typename ELFT::Dyn);
96  case ELF::SHT_HASH:
97    return sizeof(typename ELFT::Word);
98  case ELF::SHT_SYMTAB_SHNDX:
99    return sizeof(typename ELFT::Word);
100  case ELF::SHT_GNU_versym:
101    return sizeof(typename ELFT::Half);
102  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
103    return sizeof(object::Elf_CGProfile_Impl<ELFT>);
104  default:
105    if (SecName == ".debug_str")
106      return 1;
107    return 0;
108  }
109}
110 
111// For now, hardcode 64 bits everywhere that 32 or 64 would be needed
112// since 64-bit can hold 32-bit values too.
113struct FileHeader {
114  ELF_ELFCLASS Class;
115  ELF_ELFDATA Data;
116  ELF_ELFOSABI OSABI;
117  llvm::yaml::Hex8 ABIVersion;
118  ELF_ET Type;
119  std::optional<ELF_EM> Machine;
120  ELF_EF Flags;
121  llvm::yaml::Hex64 Entry;
122  std::optional<StringRef> SectionHeaderStringTable;
123 
124  std::optional<llvm::yaml::Hex64> EPhOff;
125  std::optional<llvm::yaml::Hex16> EPhEntSize;
126  std::optional<llvm::yaml::Hex16> EPhNum;
127  std::optional<llvm::yaml::Hex16> EShEntSize;
128  std::optional<llvm::yaml::Hex64> EShOff;
129  std::optional<llvm::yaml::Hex16> EShNum;
130  std::optional<llvm::yaml::Hex16> EShStrNdx;
131};
132 
133struct SectionHeader {
134  StringRef Name;
135};
136 
137struct Symbol {
138  StringRef Name;
139  ELF_STT Type;
140  std::optional<StringRef> Section;
141  std::optional<ELF_SHN> Index;
142  ELF_STB Binding;
143  std::optional<llvm::yaml::Hex64> Value;
144  std::optional<llvm::yaml::Hex64> Size;
145  std::optional<uint8_t> Other;
146 
147  std::optional<uint32_t> StName;
148};
149 
150struct SectionOrType {
151  StringRef sectionNameOrType;
152};
153 
154struct DynamicEntry {
155  ELF_DYNTAG Tag;
156  llvm::yaml::Hex64 Val;
157};
158 
159struct BBAddrMapEntry {
160  struct BBEntry {
161    uint32_t ID;
162    llvm::yaml::Hex64 AddressOffset;
163    llvm::yaml::Hex64 Size;
164    llvm::yaml::Hex64 Metadata;
165  };
166  uint8_t Version;
167  llvm::yaml::Hex8 Feature;
168  llvm::yaml::Hex64 Address;
169  std::optional<uint64_t> NumBlocks;
170  std::optional<std::vector<BBEntry>> BBEntries;
171};
172 
173struct StackSizeEntry {
174  llvm::yaml::Hex64 Address;
175  llvm::yaml::Hex64 Size;
176};
177 
178struct NoteEntry {
179  StringRef Name;
180  yaml::BinaryRef Desc;
181  ELF_NT Type;
182};
183 
184struct Chunk {
185  enum class ChunkKind {
186    Dynamic,
187    Group,
188    RawContent,
189    Relocation,
190    Relr,
191    NoBits,
192    Note,
193    Hash,
194    GnuHash,
195    Verdef,
196    Verneed,
197    StackSizes,
198    SymtabShndxSection,
199    Symver,
200    ARMIndexTable,
201    MipsABIFlags,
202    Addrsig,
203    LinkerOptions,
204    DependentLibraries,
205    CallGraphProfile,
206    BBAddrMap,
207 
208    // Special chunks.
209    SpecialChunksStart,
210    Fill = SpecialChunksStart,
211    SectionHeaderTable,
212  };
213 
214  ChunkKind Kind;
215  StringRef Name;
216  std::optional<llvm::yaml::Hex64> Offset;
217 
218  // Usually chunks are not created implicitly, but rather loaded from YAML.
219  // This flag is used to signal whether this is the case or not.
220  bool IsImplicit;
221 
222  Chunk(ChunkKind K, bool Implicit) : Kind(K), IsImplicit(Implicit) {}
223  virtual ~Chunk();
224};
225 
226struct Section : public Chunk {
227  ELF_SHT Type;
228  std::optional<ELF_SHF> Flags;
229  std::optional<llvm::yaml::Hex64> Address;
230  std::optional<StringRef> Link;
231  llvm::yaml::Hex64 AddressAlign;
232  std::optional<llvm::yaml::Hex64> EntSize;
233 
234  std::optional<yaml::BinaryRef> Content;
235  std::optional<llvm::yaml::Hex64> Size;
236 
237  // Holds the original section index.
238  unsigned OriginalSecNdx;
239 
240  Section(ChunkKind Kind, bool IsImplicit = false) : Chunk(Kind, IsImplicit) {}
241 
242  static bool classof(const Chunk *S) {
243    return S->Kind < ChunkKind::SpecialChunksStart;
244  }
245 
246  // Some derived sections might have their own special entries. This method
247  // returns a vector of <entry name, is used> pairs. It is used for section
248  // validation.
249  virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
250    return {};
251  };
252 
253  // The following members are used to override section fields which is
254  // useful for creating invalid objects.
255 
256  // This can be used to override the sh_addralign field.
257  std::optional<llvm::yaml::Hex64> ShAddrAlign;
258 
259  // This can be used to override the offset stored in the sh_name field.
260  // It does not affect the name stored in the string table.
261  std::optional<llvm::yaml::Hex64> ShName;
262 
263  // This can be used to override the sh_offset field. It does not place the
264  // section data at the offset specified.
265  std::optional<llvm::yaml::Hex64> ShOffset;
266 
267  // This can be used to override the sh_size field. It does not affect the
268  // content written.
269  std::optional<llvm::yaml::Hex64> ShSize;
270 
271  // This can be used to override the sh_flags field.
272  std::optional<llvm::yaml::Hex64> ShFlags;
273 
274  // This can be used to override the sh_type field. It is useful when we
275  // want to use specific YAML keys for a section of a particular type to
276  // describe the content, but still want to have a different final type
277  // for the section.
278  std::optional<ELF_SHT> ShType;
279};
280 
281// Fill is a block of data which is placed outside of sections. It is
282// not present in the sections header table, but it might affect the output file
283// size and program headers produced.
284struct Fill : Chunk {
285  std::optional<yaml::BinaryRef> Pattern;
286  llvm::yaml::Hex64 Size;
287 
288  Fill() : Chunk(ChunkKind::Fill, /*Implicit=*/false) {}
289 
290  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
291};
292 
293struct SectionHeaderTable : Chunk {
294  SectionHeaderTable(bool IsImplicit)
295      : Chunk(ChunkKind::SectionHeaderTable, IsImplicit) {}
296 
297  static bool classof(const Chunk *S) {
298    return S->Kind == ChunkKind::SectionHeaderTable;
299  }
300 
301  std::optional<std::vector<SectionHeader>> Sections;
302  std::optional<std::vector<SectionHeader>> Excluded;
303  std::optional<bool> NoHeaders;
304 
305  size_t getNumHeaders(size_t SectionsNum) const {
306    if (IsImplicit || isDefault())
307      return SectionsNum;
308    if (NoHeaders)
309      return (*NoHeaders) ? 0 : SectionsNum;
310    return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
311  }
312 
313  bool isDefault() const { return !Sections && !Excluded && !NoHeaders; }
314 
315  static constexpr StringRef TypeStr = "SectionHeaderTable";
316};
317 
318struct BBAddrMapSection : Section {
319  std::optional<std::vector<BBAddrMapEntry>> Entries;
320 
321  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
322 
323  std::vector<std::pair<StringRef, bool>> getEntries() const override {
324    return {{"Entries", Entries.has_value()}};
325  };
326 
327  static bool classof(const Chunk *S) {
328    return S->Kind == ChunkKind::BBAddrMap;
329  }
330};
331 
332struct StackSizesSection : Section {
333  std::optional<std::vector<StackSizeEntry>> Entries;
334 
335  StackSizesSection() : Section(ChunkKind::StackSizes) {}
336 
337  std::vector<std::pair<StringRef, bool>> getEntries() const override {
338    return {{"Entries", Entries.has_value()}};
339  };
340 
341  static bool classof(const Chunk *S) {
342    return S->Kind == ChunkKind::StackSizes;
343  }
344 
345  static bool nameMatches(StringRef Name) {
346    return Name == ".stack_sizes";
347  }
348};
349 
350struct DynamicSection : Section {
351  std::optional<std::vector<DynamicEntry>> Entries;
352 
353  DynamicSection() : Section(ChunkKind::Dynamic) {}
354 
355  std::vector<std::pair<StringRef, bool>> getEntries() const override {
356    return {{"Entries", Entries.has_value()}};
357  };
358 
359  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
360};
361 
362struct RawContentSection : Section {
363  std::optional<llvm::yaml::Hex64> Info;
364 
365  RawContentSection() : Section(ChunkKind::RawContent) {}
366 
367  static bool classof(const Chunk *S) {
368    return S->Kind == ChunkKind::RawContent;
369  }
370 
371  // Is used when a content is read as an array of bytes.
372  std::optional<std::vector<uint8_t>> ContentBuf;
373};
374 
375struct NoBitsSection : Section {
376  NoBitsSection() : Section(ChunkKind::NoBits) {}
377 
378  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
379};
380 
381struct NoteSection : Section {
382  std::optional<std::vector<ELFYAML::NoteEntry>> Notes;
383 
384  NoteSection() : Section(ChunkKind::Note) {}
385 
386  std::vector<std::pair<StringRef, bool>> getEntries() const override {
387    return {{"Notes", Notes.has_value()}};
388  };
389 
390  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
391};
392 
393struct HashSection : Section {
394  std::optional<std::vector<uint32_t>> Bucket;
395  std::optional<std::vector<uint32_t>> Chain;
396 
397  std::vector<std::pair<StringRef, bool>> getEntries() const override {
398    return {{"Bucket", Bucket.has_value()}, {"Chain", Chain.has_value()}};
399  };
400 
401  // The following members are used to override section fields.
402  // This is useful for creating invalid objects.
403  std::optional<llvm::yaml::Hex64> NBucket;
404  std::optional<llvm::yaml::Hex64> NChain;
405 
406  HashSection() : Section(ChunkKind::Hash) {}
407 
408  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
409};
410 
411struct GnuHashHeader {
412  // The number of hash buckets.
413  // Not used when dumping the object, but can be used to override
414  // the real number of buckets when emiting an object from a YAML document.
415  std::optional<llvm::yaml::Hex32> NBuckets;
416 
417  // Index of the first symbol in the dynamic symbol table
418  // included in the hash table.
419  llvm::yaml::Hex32 SymNdx;
420 
421  // The number of words in the Bloom filter.
422  // Not used when dumping the object, but can be used to override the real
423  // number of words in the Bloom filter when emiting an object from a YAML
424  // document.
425  std::optional<llvm::yaml::Hex32> MaskWords;
426 
427  // A shift constant used by the Bloom filter.
428  llvm::yaml::Hex32 Shift2;
429};
430 
431struct GnuHashSection : Section {
432  std::optional<GnuHashHeader> Header;
433  std::optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
434  std::optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
435  std::optional<std::vector<llvm::yaml::Hex32>> HashValues;
436 
437  GnuHashSection() : Section(ChunkKind::GnuHash) {}
438 
439  std::vector<std::pair<StringRef, bool>> getEntries() const override {
440    return {{"Header", Header.has_value()},
441            {"BloomFilter", BloomFilter.has_value()},
442            {"HashBuckets", HashBuckets.has_value()},
443            {"HashValues", HashValues.has_value()}};
444  };
445 
446  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
447};
448 
449struct VernauxEntry {
450  uint32_t Hash;
451  uint16_t Flags;
452  uint16_t Other;
453  StringRef Name;
454};
455 
456struct VerneedEntry {
457  uint16_t Version;
458  StringRef File;
459  std::vector<VernauxEntry> AuxV;
460};
461 
462struct VerneedSection : Section {
463  std::optional<std::vector<VerneedEntry>> VerneedV;
464  std::optional<llvm::yaml::Hex64> Info;
465 
466  VerneedSection() : Section(ChunkKind::Verneed) {}
467 
468  std::vector<std::pair<StringRef, bool>> getEntries() const override {
469    return {{"Dependencies", VerneedV.has_value()}};
470  };
471 
472  static bool classof(const Chunk *S) {
473    return S->Kind == ChunkKind::Verneed;
474  }
475};
476 
477struct AddrsigSection : Section {
478  std::optional<std::vector<YAMLFlowString>> Symbols;
479 
480  AddrsigSection() : Section(ChunkKind::Addrsig) {}
481 
482  std::vector<std::pair<StringRef, bool>> getEntries() const override {
483    return {{"Symbols", Symbols.has_value()}};
484  };
485 
486  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
487};
488 
489struct LinkerOption {
490  StringRef Key;
491  StringRef Value;
492};
493 
494struct LinkerOptionsSection : Section {
495  std::optional<std::vector<LinkerOption>> Options;
496 
497  LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
498 
499  std::vector<std::pair<StringRef, bool>> getEntries() const override {
500    return {{"Options", Options.has_value()}};
501  };
502 
503  static bool classof(const Chunk *S) {
504    return S->Kind == ChunkKind::LinkerOptions;
505  }
506};
507 
508struct DependentLibrariesSection : Section {
509  std::optional<std::vector<YAMLFlowString>> Libs;
510 
511  DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
512 
513  std::vector<std::pair<StringRef, bool>> getEntries() const override {
514    return {{"Libraries", Libs.has_value()}};
515  };
516 
517  static bool classof(const Chunk *S) {
518    return S->Kind == ChunkKind::DependentLibraries;
519  }
520};
521 
522// Represents the call graph profile section entry.
523struct CallGraphEntryWeight {
524  // The weight of the edge.
525  uint64_t Weight;
526};
527 
528struct CallGraphProfileSection : Section {
529  std::optional<std::vector<CallGraphEntryWeight>> Entries;
530 
531  CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
532 
533  std::vector<std::pair<StringRef, bool>> getEntries() const override {
534    return {{"Entries", Entries.has_value()}};
535  };
536 
537  static bool classof(const Chunk *S) {
538    return S->Kind == ChunkKind::CallGraphProfile;
539  }
540};
541 
542struct SymverSection : Section {
543  std::optional<std::vector<uint16_t>> Entries;
544 
545  SymverSection() : Section(ChunkKind::Symver) {}
546 
547  std::vector<std::pair<StringRef, bool>> getEntries() const override {
548    return {{"Entries", Entries.has_value()}};
549  };
550 
551  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
552};
553 
554struct VerdefEntry {
555  std::optional<uint16_t> Version;
556  std::optional<uint16_t> Flags;
557  std::optional<uint16_t> VersionNdx;
558  std::optional<uint32_t> Hash;
559  std::vector<StringRef> VerNames;
560};
561 
562struct VerdefSection : Section {
563  std::optional<std::vector<VerdefEntry>> Entries;
564  std::optional<llvm::yaml::Hex64> Info;
565 
566  VerdefSection() : Section(ChunkKind::Verdef) {}
567 
568  std::vector<std::pair<StringRef, bool>> getEntries() const override {
569    return {{"Entries", Entries.has_value()}};
570  };
571 
572  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
573};
574 
575struct GroupSection : Section {
576  // Members of a group contain a flag and a list of section indices
577  // that are part of the group.
578  std::optional<std::vector<SectionOrType>> Members;
579  std::optional<StringRef> Signature; /* Info */
580 
581  GroupSection() : Section(ChunkKind::Group) {}
582 
583  std::vector<std::pair<StringRef, bool>> getEntries() const override {
584    return {{"Members", Members.has_value()}};
585  };
586 
587  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
588};
589 
590struct Relocation {
591  llvm::yaml::Hex64 Offset;
592  YAMLIntUInt Addend;
593  ELF_REL Type;
594  std::optional<StringRef> Symbol;
595};
596 
597struct RelocationSection : Section {
598  std::optional<std::vector<Relocation>> Relocations;
599  StringRef RelocatableSec; /* Info */
600 
601  RelocationSection() : Section(ChunkKind::Relocation) {}
602 
603  std::vector<std::pair<StringRef, bool>> getEntries() const override {
604    return {{"Relocations", Relocations.has_value()}};
605  };
606 
607  static bool classof(const Chunk *S) {
608    return S->Kind == ChunkKind::Relocation;
609  }
610};
611 
612struct RelrSection : Section {
613  std::optional<std::vector<llvm::yaml::Hex64>> Entries;
614 
615  RelrSection() : Section(ChunkKind::Relr) {}
616 
617  std::vector<std::pair<StringRef, bool>> getEntries() const override {
618    return {{"Entries", Entries.has_value()}};
619  };
620 
621  static bool classof(const Chunk *S) {
622    return S->Kind == ChunkKind::Relr;
623  }
624};
625 
626struct SymtabShndxSection : Section {
627  std::optional<std::vector<uint32_t>> Entries;
628 
629  SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
630 
631  std::vector<std::pair<StringRef, bool>> getEntries() const override {
632    return {{"Entries", Entries.has_value()}};
633  };
634 
635  static bool classof(const Chunk *S) {
636    return S->Kind == ChunkKind::SymtabShndxSection;
637  }
638};
639 
640struct ARMIndexTableEntry {
641  llvm::yaml::Hex32 Offset;
642  llvm::yaml::Hex32 Value;
643};
644 
645struct ARMIndexTableSection : Section {
646  std::optional<std::vector<ARMIndexTableEntry>> Entries;
647 
648  ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
649 
650  std::vector<std::pair<StringRef, bool>> getEntries() const override {
651    return {{"Entries", Entries.has_value()}};
652  };
653 
654  static bool classof(const Chunk *S) {
655    return S->Kind == ChunkKind::ARMIndexTable;
656  }
657};
658 
659// Represents .MIPS.abiflags section
660struct MipsABIFlags : Section {
661  llvm::yaml::Hex16 Version;
662  MIPS_ISA ISALevel;
663  llvm::yaml::Hex8 ISARevision;
664  MIPS_AFL_REG GPRSize;
665  MIPS_AFL_REG CPR1Size;
666  MIPS_AFL_REG CPR2Size;
667  MIPS_ABI_FP FpABI;
668  MIPS_AFL_EXT ISAExtension;
669  MIPS_AFL_ASE ASEs;
670  MIPS_AFL_FLAGS1 Flags1;
671  llvm::yaml::Hex32 Flags2;
672 
673  MipsABIFlags() : Section(ChunkKind::MipsABIFlags) {}
674 
675  static bool classof(const Chunk *S) {
676    return S->Kind == ChunkKind::MipsABIFlags;
677  }
678};
679 
680struct ProgramHeader {
681  ELF_PT Type;
682  ELF_PF Flags;
683  llvm::yaml::Hex64 VAddr;
684  llvm::yaml::Hex64 PAddr;
685  std::optional<llvm::yaml::Hex64> Align;
686  std::optional<llvm::yaml::Hex64> FileSize;
687  std::optional<llvm::yaml::Hex64> MemSize;
688  std::optional<llvm::yaml::Hex64> Offset;
689  std::optional<StringRef> FirstSec;
690  std::optional<StringRef> LastSec;
691 
692  // This vector contains all chunks from [FirstSec, LastSec].
693  std::vector<Chunk *> Chunks;
694};
695 
696struct Object {
697  FileHeader Header;
698  std::vector<ProgramHeader> ProgramHeaders;
699 
700  // An object might contain output section descriptions as well as
701  // custom data that does not belong to any section.
702  std::vector<std::unique_ptr<Chunk>> Chunks;
703 
704  // Although in reality the symbols reside in a section, it is a lot
705  // cleaner and nicer if we read them from the YAML as a separate
706  // top-level key, which automatically ensures that invariants like there
707  // being a single SHT_SYMTAB section are upheld.
708  std::optional<std::vector<Symbol>> Symbols;
709  std::optional<std::vector<Symbol>> DynamicSymbols;
710  std::optional<DWARFYAML::Data> DWARF;
711 
712  std::vector<Section *> getSections() {
713    std::vector<Section *> Ret;
714    for (const std::unique_ptr<Chunk> &Sec : Chunks)
715      if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
716        Ret.push_back(S);
717    return Ret;
718  }
719 
720  const SectionHeaderTable &getSectionHeaderTable() const {
721    for (const std::unique_ptr<Chunk> &C : Chunks)
722      if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
723        return *S;
724    llvm_unreachable("the section header table chunk must always be present")::llvm::llvm_unreachable_internal("the section header table chunk must always be present"
, "llvm/include/llvm/ObjectYAML/ELFYAML.h", 724);
725  }
726 
727  ELF_ELFOSABI getOSAbi() const;
728  unsigned getMachine() const;
729};
730 
731bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
732                             const NoBitsSection &S);
733 
734} // end namespace ELFYAML
735} // end namespace llvm
736 
737LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::StackSizeEntry> && !std::is_same_v
<llvm::ELFYAML::StackSizeEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::StackSizeEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::StackSizeEntry> { static const bool flow = false; }; } }
738LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::BBAddrMapEntry> && !std::is_same_v
<llvm::ELFYAML::BBAddrMapEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::BBAddrMapEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::BBAddrMapEntry> { static const bool flow = false; }; } }
739LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::BBAddrMapEntry::BBEntry> && !std
::is_same_v<llvm::ELFYAML::BBAddrMapEntry::BBEntry, std::string
> && !std::is_same_v<llvm::ELFYAML::BBAddrMapEntry
::BBEntry, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::BBAddrMapEntry::BBEntry> { static const bool flow = false
; }; } }
740LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::DynamicEntry> && !std::is_same_v
<llvm::ELFYAML::DynamicEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::DynamicEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::DynamicEntry> { static const bool flow = false; }; } }
741LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::LinkerOption> && !std::is_same_v
<llvm::ELFYAML::LinkerOption, std::string> && !
std::is_same_v<llvm::ELFYAML::LinkerOption, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::LinkerOption> { static const bool flow = false; }; } }
742LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntryWeight)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::CallGraphEntryWeight> && !std::
is_same_v<llvm::ELFYAML::CallGraphEntryWeight, std::string
> && !std::is_same_v<llvm::ELFYAML::CallGraphEntryWeight
, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::CallGraphEntryWeight> { static const bool flow = false; }
; } }
743LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::NoteEntry> && !std::is_same_v<
llvm::ELFYAML::NoteEntry, std::string> && !std::is_same_v
<llvm::ELFYAML::NoteEntry, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::NoteEntry> { static const bool flow = false; }; } }
744LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::ProgramHeader> && !std::is_same_v
<llvm::ELFYAML::ProgramHeader, std::string> && !
std::is_same_v<llvm::ELFYAML::ProgramHeader, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::ProgramHeader> { static const bool flow = false; }; } }
745LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::SectionHeader> && !std::is_same_v
<llvm::ELFYAML::SectionHeader, std::string> && !
std::is_same_v<llvm::ELFYAML::SectionHeader, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionHeader> { static const bool flow = false; }; } }
746LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<std::unique_ptr<llvm::ELFYAML::Chunk> > &&
 !std::is_same_v<std::unique_ptr<llvm::ELFYAML::Chunk>
, std::string> && !std::is_same_v<std::unique_ptr
<llvm::ELFYAML::Chunk>, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<std::unique_ptr
<llvm::ELFYAML::Chunk> > { static const bool flow = false
; }; } }
747LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::Symbol> && !std::is_same_v<llvm
::ELFYAML::Symbol, std::string> && !std::is_same_v
<llvm::ELFYAML::Symbol, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Symbol> { static const bool flow = false; }; } }
748LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VerdefEntry> && !std::is_same_v
<llvm::ELFYAML::VerdefEntry, std::string> && !std
::is_same_v<llvm::ELFYAML::VerdefEntry, llvm::StringRef>
, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerdefEntry> { static const bool flow = false; }; } }
749LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VernauxEntry> && !std::is_same_v
<llvm::ELFYAML::VernauxEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::VernauxEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VernauxEntry> { static const bool flow = false; }; } }
750LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VerneedEntry> && !std::is_same_v
<llvm::ELFYAML::VerneedEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::VerneedEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerneedEntry> { static const bool flow = false; }; } }
751LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::Relocation> && !std::is_same_v<
llvm::ELFYAML::Relocation, std::string> && !std::is_same_v
<llvm::ELFYAML::Relocation, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Relocation> { static const bool flow = false; }; } }
752LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::SectionOrType> && !std::is_same_v
<llvm::ELFYAML::SectionOrType, std::string> && !
std::is_same_v<llvm::ELFYAML::SectionOrType, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionOrType> { static const bool flow = false; }; } }
753LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::ARMIndexTableEntry> && !std::is_same_v
<llvm::ELFYAML::ARMIndexTableEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::ARMIndexTableEntry, llvm::
StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::ARMIndexTableEntry> { static const bool flow = false; };
 } }
754 
755namespace llvm {
756namespace yaml {
757 
758template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
759  static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
760                     raw_ostream &Out);
761  static StringRef input(StringRef Scalar, void *Ctx,
762                         ELFYAML::YAMLIntUInt &Val);
763  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
764};
765 
766template <>
767struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
768  static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
769};
770 
771template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
772  static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
773};
774 
775template <> struct ScalarEnumerationTraits<ELFYAML::ELF_NT> {
776  static void enumeration(IO &IO, ELFYAML::ELF_NT &Value);
777};
778 
779template <>
780struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
781  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
782};
783 
784template <>
785struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
786  static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
787};
788 
789template <>
790struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
791  static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
792};
793 
794template <>
795struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
796  static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
797};
798 
799template <>
800struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
801  static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
802};
803 
804template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
805  static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
806};
807 
808template <>
809struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
810  static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
811};
812 
813template <>
814struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
815  static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
816};
817 
818template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
819  static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
820};
821 
822template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
823  static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
824};
825 
826template <>
827struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
828  static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
829};
830 
831template <>
832struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
833  static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
834};
835 
836template <>
837struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
838  static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
839};
840 
841template <>
842struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
843  static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
844};
845 
846template <>
847struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
848  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
849};
850 
851template <>
852struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
853  static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
854};
855 
856template <>
857struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
858  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
859};
860 
861template <>
862struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
863  static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
864};
865 
866template <>
867struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
868  static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
869};
870 
871template <>
872struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
873  static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
874};
875 
876template <>
877struct MappingTraits<ELFYAML::FileHeader> {
878  static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
879};
880 
881template <> struct MappingTraits<ELFYAML::SectionHeader> {
882  static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
883};
884 
885template <> struct MappingTraits<ELFYAML::ProgramHeader> {
886  static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
887  static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
888};
889 
890template <>
891struct MappingTraits<ELFYAML::Symbol> {
892  static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
893  static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
894};
895 
896template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
897  static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
898};
899 
900template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
901  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
902};
903 
904template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
905  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &Rel);
906};
907 
908template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
909  static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
910};
911 
912template <> struct MappingTraits<ELFYAML::DynamicEntry> {
913  static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
914};
915 
916template <> struct MappingTraits<ELFYAML::NoteEntry> {
917  static void mapping(IO &IO, ELFYAML::NoteEntry &N);
918};
919 
920template <> struct MappingTraits<ELFYAML::VerdefEntry> {
921  static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
922};
923 
924template <> struct MappingTraits<ELFYAML::VerneedEntry> {
925  static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
926};
927 
928template <> struct MappingTraits<ELFYAML::VernauxEntry> {
929  static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
930};
931 
932template <> struct MappingTraits<ELFYAML::LinkerOption> {
933  static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
934};
935 
936template <> struct MappingTraits<ELFYAML::CallGraphEntryWeight> {
937  static void mapping(IO &IO, ELFYAML::CallGraphEntryWeight &E);
938};
939 
940template <> struct MappingTraits<ELFYAML::Relocation> {
941  static void mapping(IO &IO, ELFYAML::Relocation &Rel);
942};
943 
944template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
945  static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
946};
947 
948template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
949  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
950  static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
951};
952 
953template <>
954struct MappingTraits<ELFYAML::Object> {
955  static void mapping(IO &IO, ELFYAML::Object &Object);
956};
957 
958template <> struct MappingTraits<ELFYAML::SectionOrType> {
959  static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
960};
961 
962} // end namespace yaml
963} // end namespace llvm
964 
965#endif // LLVM_OBJECTYAML_ELFYAML_H

←

/build/source/llvm/include/llvm/Support/YAMLTraits.h

1//===- llvm/Support/YAMLTraits.h --------------------------------*- C++ -*-===//
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#ifndef LLVM_SUPPORT_YAMLTRAITS_H
10#define LLVM_SUPPORT_YAMLTRAITS_H
11 
12#include "llvm/ADT/ArrayRef.h"
13#include "llvm/ADT/BitVector.h"
14#include "llvm/ADT/SmallVector.h"
15#include "llvm/ADT/StringExtras.h"
16#include "llvm/ADT/StringMap.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/ADT/Twine.h"
19#include "llvm/Support/AlignOf.h"
20#include "llvm/Support/Allocator.h"
21#include "llvm/Support/Endian.h"
22#include "llvm/Support/SMLoc.h"
23#include "llvm/Support/SourceMgr.h"
24#include "llvm/Support/YAMLParser.h"
25#include "llvm/Support/raw_ostream.h"
26#include <cassert>
27#include <map>
28#include <memory>
29#include <new>
30#include <optional>
31#include <string>
32#include <system_error>
33#include <type_traits>
34#include <vector>
35 
36namespace llvm {
37 
38class VersionTuple;
39 
40namespace yaml {
41 
42enum class NodeKind : uint8_t {
43  Scalar,
44  Map,
45  Sequence,
46};
47 
48struct EmptyContext {};
49 
50/// This class should be specialized by any type that needs to be converted
51/// to/from a YAML mapping.  For example:
52///
53///     struct MappingTraits<MyStruct> {
54///       static void mapping(IO &io, MyStruct &s) {
55///         io.mapRequired("name", s.name);
56///         io.mapRequired("size", s.size);
57///         io.mapOptional("age",  s.age);
58///       }
59///     };
60template<class T>
61struct MappingTraits {
62  // Must provide:
63  // static void mapping(IO &io, T &fields);
64  // Optionally may provide:
65  // static std::string validate(IO &io, T &fields);
66  // static void enumInput(IO &io, T &value);
67  //
68  // The optional flow flag will cause generated YAML to use a flow mapping
69  // (e.g. { a: 0, b: 1 }):
70  // static const bool flow = true;
71};
72 
73/// This class is similar to MappingTraits<T> but allows you to pass in
74/// additional context for each map operation.  For example:
75///
76///     struct MappingContextTraits<MyStruct, MyContext> {
77///       static void mapping(IO &io, MyStruct &s, MyContext &c) {
78///         io.mapRequired("name", s.name);
79///         io.mapRequired("size", s.size);
80///         io.mapOptional("age",  s.age);
81///         ++c.TimesMapped;
82///       }
83///     };
84template <class T, class Context> struct MappingContextTraits {
85  // Must provide:
86  // static void mapping(IO &io, T &fields, Context &Ctx);
87  // Optionally may provide:
88  // static std::string validate(IO &io, T &fields, Context &Ctx);
89  //
90  // The optional flow flag will cause generated YAML to use a flow mapping
91  // (e.g. { a: 0, b: 1 }):
92  // static const bool flow = true;
93};
94 
95/// This class should be specialized by any integral type that converts
96/// to/from a YAML scalar where there is a one-to-one mapping between
97/// in-memory values and a string in YAML.  For example:
98///
99///     struct ScalarEnumerationTraits<Colors> {
100///         static void enumeration(IO &io, Colors &value) {
101///           io.enumCase(value, "red",   cRed);
102///           io.enumCase(value, "blue",  cBlue);
103///           io.enumCase(value, "green", cGreen);
104///         }
105///       };
106template <typename T, typename Enable = void> struct ScalarEnumerationTraits {
107  // Must provide:
108  // static void enumeration(IO &io, T &value);
109};
110 
111/// This class should be specialized by any integer type that is a union
112/// of bit values and the YAML representation is a flow sequence of
113/// strings.  For example:
114///
115///      struct ScalarBitSetTraits<MyFlags> {
116///        static void bitset(IO &io, MyFlags &value) {
117///          io.bitSetCase(value, "big",   flagBig);
118///          io.bitSetCase(value, "flat",  flagFlat);
119///          io.bitSetCase(value, "round", flagRound);
120///        }
121///      };
122template <typename T, typename Enable = void> struct ScalarBitSetTraits {
123  // Must provide:
124  // static void bitset(IO &io, T &value);
125};
126 
127/// Describe which type of quotes should be used when quoting is necessary.
128/// Some non-printable characters need to be double-quoted, while some others
129/// are fine with simple-quoting, and some don't need any quoting.
130enum class QuotingType { None, Single, Double };
131 
132/// This class should be specialized by type that requires custom conversion
133/// to/from a yaml scalar.  For example:
134///
135///    template<>
136///    struct ScalarTraits<MyType> {
137///      static void output(const MyType &val, void*, llvm::raw_ostream &out) {
138///        // stream out custom formatting
139///        out << llvm::format("%x", val);
140///      }
141///      static StringRef input(StringRef scalar, void*, MyType &value) {
142///        // parse scalar and set `value`
143///        // return empty string on success, or error string
144///        return StringRef();
145///      }
146///      static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
147///    };
148template <typename T, typename Enable = void> struct ScalarTraits {
149  // Must provide:
150  //
151  // Function to write the value as a string:
152  // static void output(const T &value, void *ctxt, llvm::raw_ostream &out);
153  //
154  // Function to convert a string to a value.  Returns the empty
155  // StringRef on success or an error string if string is malformed:
156  // static StringRef input(StringRef scalar, void *ctxt, T &value);
157  //
158  // Function to determine if the value should be quoted.
159  // static QuotingType mustQuote(StringRef);
160};
161 
162/// This class should be specialized by type that requires custom conversion
163/// to/from a YAML literal block scalar. For example:
164///
165///    template <>
166///    struct BlockScalarTraits<MyType> {
167///      static void output(const MyType &Value, void*, llvm::raw_ostream &Out)
168///      {
169///        // stream out custom formatting
170///        Out << Value;
171///      }
172///      static StringRef input(StringRef Scalar, void*, MyType &Value) {
173///        // parse scalar and set `value`
174///        // return empty string on success, or error string
175///        return StringRef();
176///      }
177///    };
178template <typename T>
179struct BlockScalarTraits {
180  // Must provide:
181  //
182  // Function to write the value as a string:
183  // static void output(const T &Value, void *ctx, llvm::raw_ostream &Out);
184  //
185  // Function to convert a string to a value.  Returns the empty
186  // StringRef on success or an error string if string is malformed:
187  // static StringRef input(StringRef Scalar, void *ctxt, T &Value);
188  //
189  // Optional:
190  // static StringRef inputTag(T &Val, std::string Tag)
191  // static void outputTag(const T &Val, raw_ostream &Out)
192};
193 
194/// This class should be specialized by type that requires custom conversion
195/// to/from a YAML scalar with optional tags. For example:
196///
197///    template <>
198///    struct TaggedScalarTraits<MyType> {
199///      static void output(const MyType &Value, void*, llvm::raw_ostream
200///      &ScalarOut, llvm::raw_ostream &TagOut)
201///      {
202///        // stream out custom formatting including optional Tag
203///        Out << Value;
204///      }
205///      static StringRef input(StringRef Scalar, StringRef Tag, void*, MyType
206///      &Value) {
207///        // parse scalar and set `value`
208///        // return empty string on success, or error string
209///        return StringRef();
210///      }
211///      static QuotingType mustQuote(const MyType &Value, StringRef) {
212///        return QuotingType::Single;
213///      }
214///    };
215template <typename T> struct TaggedScalarTraits {
216  // Must provide:
217  //
218  // Function to write the value and tag as strings:
219  // static void output(const T &Value, void *ctx, llvm::raw_ostream &ScalarOut,
220  // llvm::raw_ostream &TagOut);
221  //
222  // Function to convert a string to a value.  Returns the empty
223  // StringRef on success or an error string if string is malformed:
224  // static StringRef input(StringRef Scalar, StringRef Tag, void *ctxt, T
225  // &Value);
226  //
227  // Function to determine if the value should be quoted.
228  // static QuotingType mustQuote(const T &Value, StringRef Scalar);
229};
230 
231/// This class should be specialized by any type that needs to be converted
232/// to/from a YAML sequence.  For example:
233///
234///    template<>
235///    struct SequenceTraits<MyContainer> {
236///      static size_t size(IO &io, MyContainer &seq) {
237///        return seq.size();
238///      }
239///      static MyType& element(IO &, MyContainer &seq, size_t index) {
240///        if ( index >= seq.size() )
241///          seq.resize(index+1);
242///        return seq[index];
243///      }
244///    };
245template<typename T, typename EnableIf = void>
246struct SequenceTraits {
247  // Must provide:
248  // static size_t size(IO &io, T &seq);
249  // static T::value_type& element(IO &io, T &seq, size_t index);
250  //
251  // The following is option and will cause generated YAML to use
252  // a flow sequence (e.g. [a,b,c]).
253  // static const bool flow = true;
254};
255 
256/// This class should be specialized by any type for which vectors of that
257/// type need to be converted to/from a YAML sequence.
258template<typename T, typename EnableIf = void>
259struct SequenceElementTraits {
260  // Must provide:
261  // static const bool flow;
262};
263 
264/// This class should be specialized by any type that needs to be converted
265/// to/from a list of YAML documents.
266template<typename T>
267struct DocumentListTraits {
268  // Must provide:
269  // static size_t size(IO &io, T &seq);
270  // static T::value_type& element(IO &io, T &seq, size_t index);
271};
272 
273/// This class should be specialized by any type that needs to be converted
274/// to/from a YAML mapping in the case where the names of the keys are not known
275/// in advance, e.g. a string map.
276template <typename T>
277struct CustomMappingTraits {
278  // static void inputOne(IO &io, StringRef key, T &elem);
279  // static void output(IO &io, T &elem);
280};
281 
282/// This class should be specialized by any type that can be represented as
283/// a scalar, map, or sequence, decided dynamically. For example:
284///
285///    typedef std::unique_ptr<MyBase> MyPoly;
286///
287///    template<>
288///    struct PolymorphicTraits<MyPoly> {
289///      static NodeKind getKind(const MyPoly &poly) {
290///        return poly->getKind();
291///      }
292///      static MyScalar& getAsScalar(MyPoly &poly) {
293///        if (!poly || !isa<MyScalar>(poly))
294///          poly.reset(new MyScalar());
295///        return *cast<MyScalar>(poly.get());
296///      }
297///      // ...
298///    };
299template <typename T> struct PolymorphicTraits {
300  // Must provide:
301  // static NodeKind getKind(const T &poly);
302  // static scalar_type &getAsScalar(T &poly);
303  // static map_type &getAsMap(T &poly);
304  // static sequence_type &getAsSequence(T &poly);
305};
306 
307// Only used for better diagnostics of missing traits
308template <typename T>
309struct MissingTrait;
310 
311// Test if ScalarEnumerationTraits<T> is defined on type T.
312template <class T>
313struct has_ScalarEnumerationTraits
314{
315  using Signature_enumeration = void (*)(class IO&, T&);
316 
317  template <typename U>
318  static char test(SameType<Signature_enumeration, &U::enumeration>*);
319 
320  template <typename U>
321  static double test(...);
322 
323  static bool const value =
324    (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
325};
326 
327// Test if ScalarBitSetTraits<T> is defined on type T.
328template <class T>
329struct has_ScalarBitSetTraits
330{
331  using Signature_bitset = void (*)(class IO&, T&);
332 
333  template <typename U>
334  static char test(SameType<Signature_bitset, &U::bitset>*);
335 
336  template <typename U>
337  static double test(...);
338 
339  static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
340};
341 
342// Test if ScalarTraits<T> is defined on type T.
343template <class T>
344struct has_ScalarTraits
345{
346  using Signature_input = StringRef (*)(StringRef, void*, T&);
347  using Signature_output = void (*)(const T&, void*, raw_ostream&);
348  using Signature_mustQuote = QuotingType (*)(StringRef);
349 
350  template <typename U>
351  static char test(SameType<Signature_input, &U::input> *,
352                   SameType<Signature_output, &U::output> *,
353                   SameType<Signature_mustQuote, &U::mustQuote> *);
354 
355  template <typename U>
356  static double test(...);
357 
358  static bool const value =
359      (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
360};
361 
362// Test if BlockScalarTraits<T> is defined on type T.
363template <class T>
364struct has_BlockScalarTraits
365{
366  using Signature_input = StringRef (*)(StringRef, void *, T &);
367  using Signature_output = void (*)(const T &, void *, raw_ostream &);
368 
369  template <typename U>
370  static char test(SameType<Signature_input, &U::input> *,
371                   SameType<Signature_output, &U::output> *);
372 
373  template <typename U>
374  static double test(...);
375 
376  static bool const value =
377      (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
378};
379 
380// Test if TaggedScalarTraits<T> is defined on type T.
381template <class T> struct has_TaggedScalarTraits {
382  using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
383  using Signature_output = void (*)(const T &, void *, raw_ostream &,
384                                    raw_ostream &);
385  using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
386 
387  template <typename U>
388  static char test(SameType<Signature_input, &U::input> *,
389                   SameType<Signature_output, &U::output> *,
390                   SameType<Signature_mustQuote, &U::mustQuote> *);
391 
392  template <typename U> static double test(...);
393 
394  static bool const value =
395      (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
396};
397 
398// Test if MappingContextTraits<T> is defined on type T.
399template <class T, class Context> struct has_MappingTraits {
400  using Signature_mapping = void (*)(class IO &, T &, Context &);
401 
402  template <typename U>
403  static char test(SameType<Signature_mapping, &U::mapping>*);
404 
405  template <typename U>
406  static double test(...);
407 
408  static bool const value =
409      (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
410};
411 
412// Test if MappingTraits<T> is defined on type T.
413template <class T> struct has_MappingTraits<T, EmptyContext> {
414  using Signature_mapping = void (*)(class IO &, T &);
415 
416  template <typename U>
417  static char test(SameType<Signature_mapping, &U::mapping> *);
418 
419  template <typename U> static double test(...);
420 
421  static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
422};
423 
424// Test if MappingContextTraits<T>::validate() is defined on type T.
425template <class T, class Context> struct has_MappingValidateTraits {
426  using Signature_validate = std::string (*)(class IO &, T &, Context &);
427 
428  template <typename U>
429  static char test(SameType<Signature_validate, &U::validate>*);
430 
431  template <typename U>
432  static double test(...);
433 
434  static bool const value =
435      (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
436};
437 
438// Test if MappingTraits<T>::validate() is defined on type T.
439template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
440  using Signature_validate = std::string (*)(class IO &, T &);
441 
442  template <typename U>
443  static char test(SameType<Signature_validate, &U::validate> *);
444 
445  template <typename U> static double test(...);
446 
447  static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
448};
449 
450// Test if MappingContextTraits<T>::enumInput() is defined on type T.
451template <class T, class Context> struct has_MappingEnumInputTraits {
452  using Signature_validate = void (*)(class IO &, T &);
453 
454  template <typename U>
455  static char test(SameType<Signature_validate, &U::enumInput> *);
456 
457  template <typename U> static double test(...);
458 
459  static bool const value =
460      (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
461};
462 
463// Test if MappingTraits<T>::enumInput() is defined on type T.
464template <class T> struct has_MappingEnumInputTraits<T, EmptyContext> {
465  using Signature_validate = void (*)(class IO &, T &);
466 
467  template <typename U>
468  static char test(SameType<Signature_validate, &U::enumInput> *);
469 
470  template <typename U> static double test(...);
471 
472  static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
473};
474 
475// Test if SequenceTraits<T> is defined on type T.
476template <class T>
477struct has_SequenceMethodTraits
478{
479  using Signature_size = size_t (*)(class IO&, T&);
480 
481  template <typename U>
482  static char test(SameType<Signature_size, &U::size>*);
483 
484  template <typename U>
485  static double test(...);
486 
487  static bool const value =  (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
488};
489 
490// Test if CustomMappingTraits<T> is defined on type T.
491template <class T>
492struct has_CustomMappingTraits
493{
494  using Signature_input = void (*)(IO &io, StringRef key, T &v);
495 
496  template <typename U>
497  static char test(SameType<Signature_input, &U::inputOne>*);
498 
499  template <typename U>
500  static double test(...);
501 
502  static bool const value =
503      (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
504};
505 
506// has_FlowTraits<int> will cause an error with some compilers because
507// it subclasses int.  Using this wrapper only instantiates the
508// real has_FlowTraits only if the template type is a class.
509template <typename T, bool Enabled = std::is_class<T>::value>
510class has_FlowTraits
511{
512public:
513   static const bool value = false;
514};
515 
516// Some older gcc compilers don't support straight forward tests
517// for members, so test for ambiguity cause by the base and derived
518// classes both defining the member.
519template <class T>
520struct has_FlowTraits<T, true>
521{
522  struct Fallback { bool flow; };
523  struct Derived : T, Fallback { };
524 
525  template<typename C>
526  static char (&f(SameType<bool Fallback::*, &C::flow>*))[1];
527 
528  template<typename C>
529  static char (&f(...))[2];
530 
531  static bool const value = sizeof(f<Derived>(nullptr)) == 2;
532};
533 
534// Test if SequenceTraits<T> is defined on type T
535template<typename T>
536struct has_SequenceTraits : public std::integral_constant<bool,
537                                      has_SequenceMethodTraits<T>::value > { };
538 
539// Test if DocumentListTraits<T> is defined on type T
540template <class T>
541struct has_DocumentListTraits
542{
543  using Signature_size = size_t (*)(class IO &, T &);
544 
545  template <typename U>
546  static char test(SameType<Signature_size, &U::size>*);
547 
548  template <typename U>
549  static double test(...);
550 
551  static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
552};
553 
554template <class T> struct has_PolymorphicTraits {
555  using Signature_getKind = NodeKind (*)(const T &);
556 
557  template <typename U>
558  static char test(SameType<Signature_getKind, &U::getKind> *);
559 
560  template <typename U> static double test(...);
561 
562  static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
563};
564 
565inline bool isNumeric(StringRef S) {
566  const auto skipDigits = [](StringRef Input) {
567    return Input.ltrim("0123456789");
568  };
569 
570  // Make S.front() and S.drop_front().front() (if S.front() is [+-]) calls
571  // safe.
572  if (S.empty() || S.equals("+") || S.equals("-"))
573    return false;
574 
575  if (S.equals(".nan") || S.equals(".NaN") || S.equals(".NAN"))
576    return true;
577 
578  // Infinity and decimal numbers can be prefixed with sign.
579  StringRef Tail = (S.front() == '-' || S.front() == '+') ? S.drop_front() : S;
580 
581  // Check for infinity first, because checking for hex and oct numbers is more
582  // expensive.
583  if (Tail.equals(".inf") || Tail.equals(".Inf") || Tail.equals(".INF"))
584    return true;
585 
586  // Section 10.3.2 Tag Resolution
587  // YAML 1.2 Specification prohibits Base 8 and Base 16 numbers prefixed with
588  // [-+], so S should be used instead of Tail.
589  if (S.startswith("0o"))
590    return S.size() > 2 &&
591           S.drop_front(2).find_first_not_of("01234567") == StringRef::npos;
592 
593  if (S.startswith("0x"))
594    return S.size() > 2 && S.drop_front(2).find_first_not_of(
595                               "0123456789abcdefABCDEF") == StringRef::npos;
596 
597  // Parse float: [-+]? (\. [0-9]+ | [0-9]+ (\. [0-9]* )?) ([eE] [-+]? [0-9]+)?
598  S = Tail;
599 
600  // Handle cases when the number starts with '.' and hence needs at least one
601  // digit after dot (as opposed by number which has digits before the dot), but
602  // doesn't have one.
603  if (S.startswith(".") &&
604      (S.equals(".") ||
605       (S.size() > 1 && std::strchr("0123456789", S[1]) == nullptr)))
606    return false;
607 
608  if (S.startswith("E") || S.startswith("e"))
609    return false;
610 
611  enum ParseState {
612    Default,
613    FoundDot,
614    FoundExponent,
615  };
616  ParseState State = Default;
617 
618  S = skipDigits(S);
619 
620  // Accept decimal integer.
621  if (S.empty())
622    return true;
623 
624  if (S.front() == '.') {
625    State = FoundDot;
626    S = S.drop_front();
627  } else if (S.front() == 'e' || S.front() == 'E') {
628    State = FoundExponent;
629    S = S.drop_front();
630  } else {
631    return false;
632  }
633 
634  if (State == FoundDot) {
635    S = skipDigits(S);
636    if (S.empty())
637      return true;
638 
639    if (S.front() == 'e' || S.front() == 'E') {
640      State = FoundExponent;
641      S = S.drop_front();
642    } else {
643      return false;
644    }
645  }
646 
647  assert(State == FoundExponent && "Should have found exponent at this point.")(static_cast <bool> (State == FoundExponent && "Should have found exponent at this point."
) ? void (0) : __assert_fail ("State == FoundExponent && \"Should have found exponent at this point.\""
, "llvm/include/llvm/Support/YAMLTraits.h", 647, __extension__
 __PRETTY_FUNCTION__));
648  if (S.empty())
649    return false;
650 
651  if (S.front() == '+' || S.front() == '-') {
652    S = S.drop_front();
653    if (S.empty())
654      return false;
655  }
656 
657  return skipDigits(S).empty();
658}
659 
660inline bool isNull(StringRef S) {
661  return S.equals("null") || S.equals("Null") || S.equals("NULL") ||
662         S.equals("~");
663}
664 
665inline bool isBool(StringRef S) {
666  // FIXME: using parseBool is causing multiple tests to fail.
667  return S.equals("true") || S.equals("True") || S.equals("TRUE") ||
668         S.equals("false") || S.equals("False") || S.equals("FALSE");
669}
670 
671// 5.1. Character Set
672// The allowed character range explicitly excludes the C0 control block #x0-#x1F
673// (except for TAB #x9, LF #xA, and CR #xD which are allowed), DEL #x7F, the C1
674// control block #x80-#x9F (except for NEL #x85 which is allowed), the surrogate
675// block #xD800-#xDFFF, #xFFFE, and #xFFFF.
676inline QuotingType needsQuotes(StringRef S) {
677  if (S.empty())
678    return QuotingType::Single;
679 
680  QuotingType MaxQuotingNeeded = QuotingType::None;
681  if (isSpace(static_cast<unsigned char>(S.front())) ||
682      isSpace(static_cast<unsigned char>(S.back())))
683    MaxQuotingNeeded = QuotingType::Single;
684  if (isNull(S))
685    MaxQuotingNeeded = QuotingType::Single;
686  if (isBool(S))
687    MaxQuotingNeeded = QuotingType::Single;
688  if (isNumeric(S))
689    MaxQuotingNeeded = QuotingType::Single;
690 
691  // 7.3.3 Plain Style
692  // Plain scalars must not begin with most indicators, as this would cause
693  // ambiguity with other YAML constructs.
694  if (std::strchr(R"(-?:\,[]{}#&*!|>'"%@`)", S[0]) != nullptr)
695    MaxQuotingNeeded = QuotingType::Single;
696 
697  for (unsigned char C : S) {
698    // Alphanum is safe.
699    if (isAlnum(C))
700      continue;
701 
702    switch (C) {
703    // Safe scalar characters.
704    case '_':
705    case '-':
706    case '^':
707    case '.':
708    case ',':
709    case ' ':
710    // TAB (0x9) is allowed in unquoted strings.
711    case 0x9:
712      continue;
713    // LF(0xA) and CR(0xD) may delimit values and so require at least single
714    // quotes. LLVM YAML parser cannot handle single quoted multiline so use
715    // double quoting to produce valid YAML.
716    case 0xA:
717    case 0xD:
718      return QuotingType::Double;
719    // DEL (0x7F) are excluded from the allowed character range.
720    case 0x7F:
721      return QuotingType::Double;
722    // Forward slash is allowed to be unquoted, but we quote it anyway.  We have
723    // many tests that use FileCheck against YAML output, and this output often
724    // contains paths.  If we quote backslashes but not forward slashes then
725    // paths will come out either quoted or unquoted depending on which platform
726    // the test is run on, making FileCheck comparisons difficult.
727    case '/':
728    default: {
729      // C0 control block (0x0 - 0x1F) is excluded from the allowed character
730      // range.
731      if (C <= 0x1F)
732        return QuotingType::Double;
733 
734      // Always double quote UTF-8.
735      if ((C & 0x80) != 0)
736        return QuotingType::Double;
737 
738      // The character is not safe, at least simple quoting needed.
739      MaxQuotingNeeded = QuotingType::Single;
740    }
741    }
742  }
743 
744  return MaxQuotingNeeded;
745}
746 
747template <typename T, typename Context>
748struct missingTraits
749    : public std::integral_constant<bool,
750                                    !has_ScalarEnumerationTraits<T>::value &&
751                                        !has_ScalarBitSetTraits<T>::value &&
752                                        !has_ScalarTraits<T>::value &&
753                                        !has_BlockScalarTraits<T>::value &&
754                                        !has_TaggedScalarTraits<T>::value &&
755                                        !has_MappingTraits<T, Context>::value &&
756                                        !has_SequenceTraits<T>::value &&
757                                        !has_CustomMappingTraits<T>::value &&
758                                        !has_DocumentListTraits<T>::value &&
759                                        !has_PolymorphicTraits<T>::value> {};
760 
761template <typename T, typename Context>
762struct validatedMappingTraits
763    : public std::integral_constant<
764          bool, has_MappingTraits<T, Context>::value &&
765                    has_MappingValidateTraits<T, Context>::value> {};
766 
767template <typename T, typename Context>
768struct unvalidatedMappingTraits
769    : public std::integral_constant<
770          bool, has_MappingTraits<T, Context>::value &&
771                    !has_MappingValidateTraits<T, Context>::value> {};
772 
773// Base class for Input and Output.
774class IO {
775public:
776  IO(void *Ctxt = nullptr);
777  virtual ~IO();
778 
779  virtual bool outputting() const = 0;
780 
781  virtual unsigned beginSequence() = 0;
782  virtual bool preflightElement(unsigned, void *&) = 0;
783  virtual void postflightElement(void*) = 0;
784  virtual void endSequence() = 0;
785  virtual bool canElideEmptySequence() = 0;
786 
787  virtual unsigned beginFlowSequence() = 0;
788  virtual bool preflightFlowElement(unsigned, void *&) = 0;
789  virtual void postflightFlowElement(void*) = 0;
790  virtual void endFlowSequence() = 0;
791 
792  virtual bool mapTag(StringRef Tag, bool Default=false) = 0;
793  virtual void beginMapping() = 0;
794  virtual void endMapping() = 0;
795  virtual bool preflightKey(const char*, bool, bool, bool &, void *&) = 0;
796  virtual void postflightKey(void*) = 0;
797  virtual std::vector<StringRef> keys() = 0;
798 
799  virtual void beginFlowMapping() = 0;
800  virtual void endFlowMapping() = 0;
801 
802  virtual void beginEnumScalar() = 0;
803  virtual bool matchEnumScalar(const char*, bool) = 0;
804  virtual bool matchEnumFallback() = 0;
805  virtual void endEnumScalar() = 0;
806 
807  virtual bool beginBitSetScalar(bool &) = 0;
808  virtual bool bitSetMatch(const char*, bool) = 0;
809  virtual void endBitSetScalar() = 0;
810 
811  virtual void scalarString(StringRef &, QuotingType) = 0;
812  virtual void blockScalarString(StringRef &) = 0;
813  virtual void scalarTag(std::string &) = 0;
814 
815  virtual NodeKind getNodeKind() = 0;
816 
817  virtual void setError(const Twine &) = 0;
818  virtual void setAllowUnknownKeys(bool Allow);
819 
820  template <typename T>
821  void enumCase(T &Val, const char* Str, const T ConstVal) {
822    if ( matchEnumScalar(Str, outputting() && Val == ConstVal) ) {
823      Val = ConstVal;
824    }
825  }
826 
827  // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
828  template <typename T>
829  void enumCase(T &Val, const char* Str, const uint32_t ConstVal) {
830    if ( matchEnumScalar(Str, outputting() && Val == static_cast<T>(ConstVal)) ) {
831      Val = ConstVal;
832    }
833  }
834 
835  template <typename FBT, typename T>
836  void enumFallback(T &Val) {
837    if (matchEnumFallback()) {
838      EmptyContext Context;
839      // FIXME: Force integral conversion to allow strong typedefs to convert.
840      FBT Res = static_cast<typename FBT::BaseType>(Val);
841      yamlize(*this, Res, true, Context);
842      Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res));
843    }
844  }
845 
846  template <typename T>
847  void bitSetCase(T &Val, const char* Str, const T ConstVal) {
848    if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
849      Val = static_cast<T>(Val | ConstVal);
850    }
851  }
852 
853  // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
854  template <typename T>
855  void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) {
856    if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
857      Val = static_cast<T>(Val | ConstVal);
858    }
859  }
860 
861  template <typename T>
862  void maskedBitSetCase(T &Val, const char *Str, T ConstVal, T Mask) {
863    if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
864      Val = Val | ConstVal;
865  }
866 
867  template <typename T>
868  void maskedBitSetCase(T &Val, const char *Str, uint32_t ConstVal,
869                        uint32_t Mask) {
870    if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
871      Val = Val | ConstVal;
872  }
873 
874  void *getContext() const;
875  void setContext(void *);
876 
877  template <typename T> void mapRequired(const char *Key, T &Val) {
878    EmptyContext Ctx;
879    this->processKey(Key, Val, true, Ctx);
8
←
Calling 'IO::processKey'→
12
←
Returning from 'IO::processKey'→
880  }
13
←
Returning without writing to 'Val.value'→
881 
882  template <typename T, typename Context>
883  void mapRequired(const char *Key, T &Val, Context &Ctx) {
884    this->processKey(Key, Val, true, Ctx);
885  }
886 
887  template <typename T> void mapOptional(const char *Key, T &Val) {
888    EmptyContext Ctx;
889    mapOptionalWithContext(Key, Val, Ctx);
890  }
891 
892  template <typename T, typename DefaultT>
893  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
894    EmptyContext Ctx;
895    mapOptionalWithContext(Key, Val, Default, Ctx);
896  }
897 
898  template <typename T, typename Context>
899  std::enable_if_t<has_SequenceTraits<T>::value, void>
900  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
901    // omit key/value instead of outputting empty sequence
902    if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
903      return;
904    this->processKey(Key, Val, false, Ctx);
905  }
906 
907  template <typename T, typename Context>
908  void mapOptionalWithContext(const char *Key, std::optional<T> &Val,
909                              Context &Ctx) {
910    this->processKeyWithDefault(Key, Val, std::optional<T>(),
911                                /*Required=*/false, Ctx);
912  }
913 
914  template <typename T, typename Context>
915  std::enable_if_t<!has_SequenceTraits<T>::value, void>
916  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
917    this->processKey(Key, Val, false, Ctx);
918  }
919 
920  template <typename T, typename Context, typename DefaultT>
921  void mapOptionalWithContext(const char *Key, T &Val, const DefaultT &Default,
922                              Context &Ctx) {
923    static_assert(std::is_convertible<DefaultT, T>::value,
924                  "Default type must be implicitly convertible to value type!");
925    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
926                                false, Ctx);
927  }
928 
929private:
930  template <typename T, typename Context>
931  void processKeyWithDefault(const char *Key, std::optional<T> &Val,
932                             const std::optional<T> &DefaultValue,
933                             bool Required, Context &Ctx);
934 
935  template <typename T, typename Context>
936  void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
937                             bool Required, Context &Ctx) {
938    void *SaveInfo;
939    bool UseDefault;
940    const bool sameAsDefault = outputting() && Val == DefaultValue;
941    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
942                                                                  SaveInfo) ) {
943      yamlize(*this, Val, Required, Ctx);
944      this->postflightKey(SaveInfo);
945    }
946    else {
947      if ( UseDefault )
948        Val = DefaultValue;
949    }
950  }
951 
952  template <typename T, typename Context>
953  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
954    void *SaveInfo;
955    bool UseDefault;
956    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
957      yamlize(*this, Val, Required, Ctx);
958      this->postflightKey(SaveInfo);
959    }
960  }
11
←
Returning without writing to 'Val.value'→
961 
962private:
963  void *Ctxt;
964};
965 
966namespace detail {
967 
968template <typename T, typename Context>
969void doMapping(IO &io, T &Val, Context &Ctx) {
970  MappingContextTraits<T, Context>::mapping(io, Val, Ctx);
971}
972 
973template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
974  MappingTraits<T>::mapping(io, Val);
975}
976 
977} // end namespace detail
978 
979template <typename T>
980std::enable_if_t<has_ScalarEnumerationTraits<T>::value, void>
981yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
982  io.beginEnumScalar();
983  ScalarEnumerationTraits<T>::enumeration(io, Val);
984  io.endEnumScalar();
985}
986 
987template <typename T>
988std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
989yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
990  bool DoClear;
991  if ( io.beginBitSetScalar(DoClear) ) {
992    if ( DoClear )
993      Val = T();
994    ScalarBitSetTraits<T>::bitset(io, Val);
995    io.endBitSetScalar();
996  }
997}
998 
999template <typename T>
1000std::enable_if_t<has_ScalarTraits<T>::value, void> yamlize(IO &io, T &Val, bool,
1001                                                           EmptyContext &Ctx) {
1002  if ( io.outputting() ) {
1003    SmallString<128> Storage;
1004    raw_svector_ostream Buffer(Storage);
1005    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
1006    StringRef Str = Buffer.str();
1007    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
1008  }
1009  else {
1010    StringRef Str;
1011    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
1012    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1013    if ( !Result.empty() ) {
1014      io.setError(Twine(Result));
1015    }
1016  }
1017}
1018 
1019template <typename T>
1020std::enable_if_t<has_BlockScalarTraits<T>::value, void>
1021yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1022  if (YamlIO.outputting()) {
1023    std::string Storage;
1024    raw_string_ostream Buffer(Storage);
1025    BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1026    StringRef Str = Buffer.str();
1027    YamlIO.blockScalarString(Str);
1028  } else {
1029    StringRef Str;
1030    YamlIO.blockScalarString(Str);
1031    StringRef Result =
1032        BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1033    if (!Result.empty())
1034      YamlIO.setError(Twine(Result));
1035  }
1036}
1037 
1038template <typename T>
1039std::enable_if_t<has_TaggedScalarTraits<T>::value, void>
1040yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1041  if (io.outputting()) {
1042    std::string ScalarStorage, TagStorage;
1043    raw_string_ostream ScalarBuffer(ScalarStorage), TagBuffer(TagStorage);
1044    TaggedScalarTraits<T>::output(Val, io.getContext(), ScalarBuffer,
1045                                  TagBuffer);
1046    io.scalarTag(TagBuffer.str());
1047    StringRef ScalarStr = ScalarBuffer.str();
1048    io.scalarString(ScalarStr,
1049                    TaggedScalarTraits<T>::mustQuote(Val, ScalarStr));
1050  } else {
1051    std::string Tag;
1052    io.scalarTag(Tag);
1053    StringRef Str;
1054    io.scalarString(Str, QuotingType::None);
1055    StringRef Result =
1056        TaggedScalarTraits<T>::input(Str, Tag, io.getContext(), Val);
1057    if (!Result.empty()) {
1058      io.setError(Twine(Result));
1059    }
1060  }
1061}
1062 
1063template <typename T, typename Context>
1064std::enable_if_t<validatedMappingTraits<T, Context>::value, void>
1065yamlize(IO &io, T &Val, bool, Context &Ctx) {
1066  if (has_FlowTraits<MappingTraits<T>>::value)
1067    io.beginFlowMapping();
1068  else
1069    io.beginMapping();
1070  if (io.outputting()) {
1071    std::string Err = MappingTraits<T>::validate(io, Val);
1072    if (!Err.empty()) {
1073      errs() << Err << "\n";
1074      assert(Err.empty() && "invalid struct trying to be written as yaml")(static_cast <bool> (Err.empty() && "invalid struct trying to be written as yaml"
) ? void (0) : __assert_fail ("Err.empty() && \"invalid struct trying to be written as yaml\""
, "llvm/include/llvm/Support/YAMLTraits.h", 1074, __extension__
 __PRETTY_FUNCTION__));
1075    }
1076  }
1077  detail::doMapping(io, Val, Ctx);
1078  if (!io.outputting()) {
1079    std::string Err = MappingTraits<T>::validate(io, Val);
1080    if (!Err.empty())
1081      io.setError(Err);
1082  }
1083  if (has_FlowTraits<MappingTraits<T>>::value)
1084    io.endFlowMapping();
1085  else
1086    io.endMapping();
1087}
1088 
1089template <typename T, typename Context>
1090std::enable_if_t<!has_MappingEnumInputTraits<T, Context>::value, bool>
1091yamlizeMappingEnumInput(IO &io, T &Val) {
1092  return false;
1093}
1094 
1095template <typename T, typename Context>
1096std::enable_if_t<has_MappingEnumInputTraits<T, Context>::value, bool>
1097yamlizeMappingEnumInput(IO &io, T &Val) {
1098  if (io.outputting())
1099    return false;
1100 
1101  io.beginEnumScalar();
1102  MappingTraits<T>::enumInput(io, Val);
1103  bool Matched = !io.matchEnumFallback();
1104  io.endEnumScalar();
1105  return Matched;
1106}
1107 
1108template <typename T, typename Context>
1109std::enable_if_t<unvalidatedMappingTraits<T, Context>::value, void>
1110yamlize(IO &io, T &Val, bool, Context &Ctx) {
1111  if (yamlizeMappingEnumInput<T, Context>(io, Val))
1112    return;
1113  if (has_FlowTraits<MappingTraits<T>>::value) {
1114    io.beginFlowMapping();
1115    detail::doMapping(io, Val, Ctx);
1116    io.endFlowMapping();
1117  } else {
1118    io.beginMapping();
1119    detail::doMapping(io, Val, Ctx);
1120    io.endMapping();
1121  }
1122}
1123 
1124template <typename T>
1125std::enable_if_t<has_CustomMappingTraits<T>::value, void>
1126yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1127  if ( io.outputting() ) {
1128    io.beginMapping();
1129    CustomMappingTraits<T>::output(io, Val);
1130    io.endMapping();
1131  } else {
1132    io.beginMapping();
1133    for (StringRef key : io.keys())
1134      CustomMappingTraits<T>::inputOne(io, key, Val);
1135    io.endMapping();
1136  }
1137}
1138 
1139template <typename T>
1140std::enable_if_t<has_PolymorphicTraits<T>::value, void>
1141yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1142  switch (io.outputting() ? PolymorphicTraits<T>::getKind(Val)
1143                          : io.getNodeKind()) {
1144  case NodeKind::Scalar:
1145    return yamlize(io, PolymorphicTraits<T>::getAsScalar(Val), true, Ctx);
1146  case NodeKind::Map:
1147    return yamlize(io, PolymorphicTraits<T>::getAsMap(Val), true, Ctx);
1148  case NodeKind::Sequence:
1149    return yamlize(io, PolymorphicTraits<T>::getAsSequence(Val), true, Ctx);
1150  }
1151}
1152 
1153template <typename T>
1154std::enable_if_t<missingTraits<T, EmptyContext>::value, void>
1155yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1156  char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1157}
1158 
1159template <typename T, typename Context>
1160std::enable_if_t<has_SequenceTraits<T>::value, void>
1161yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1162  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1163    unsigned incnt = io.beginFlowSequence();
1164    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1165    for(unsigned i=0; i < count; ++i) {
1166      void *SaveInfo;
1167      if ( io.preflightFlowElement(i, SaveInfo) ) {
1168        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1169        io.postflightFlowElement(SaveInfo);
1170      }
1171    }
1172    io.endFlowSequence();
1173  }
1174  else {
1175    unsigned incnt = io.beginSequence();
1176    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1177    for(unsigned i=0; i < count; ++i) {
1178      void *SaveInfo;
1179      if ( io.preflightElement(i, SaveInfo) ) {
1180        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1181        io.postflightElement(SaveInfo);
1182      }
1183    }
1184    io.endSequence();
1185  }
1186}
1187 
1188template<>
1189struct ScalarTraits<bool> {
1190  static void output(const bool &, void* , raw_ostream &);
1191  static StringRef input(StringRef, void *, bool &);
1192  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1193};
1194 
1195template<>
1196struct ScalarTraits<StringRef> {
1197  static void output(const StringRef &, void *, raw_ostream &);
1198  static StringRef input(StringRef, void *, StringRef &);
1199  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1200};
1201 
1202template<>
1203struct ScalarTraits<std::string> {
1204  static void output(const std::string &, void *, raw_ostream &);
1205  static StringRef input(StringRef, void *, std::string &);
1206  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1207};
1208 
1209template<>
1210struct ScalarTraits<uint8_t> {
1211  static void output(const uint8_t &, void *, raw_ostream &);
1212  static StringRef input(StringRef, void *, uint8_t &);
1213  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1214};
1215 
1216template<>
1217struct ScalarTraits<uint16_t> {
1218  static void output(const uint16_t &, void *, raw_ostream &);
1219  static StringRef input(StringRef, void *, uint16_t &);
1220  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1221};
1222 
1223template<>
1224struct ScalarTraits<uint32_t> {
1225  static void output(const uint32_t &, void *, raw_ostream &);
1226  static StringRef input(StringRef, void *, uint32_t &);
1227  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1228};
1229 
1230template<>
1231struct ScalarTraits<uint64_t> {
1232  static void output(const uint64_t &, void *, raw_ostream &);
1233  static StringRef input(StringRef, void *, uint64_t &);
1234  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1235};
1236 
1237template<>
1238struct ScalarTraits<int8_t> {
1239  static void output(const int8_t &, void *, raw_ostream &);
1240  static StringRef input(StringRef, void *, int8_t &);
1241  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1242};
1243 
1244template<>
1245struct ScalarTraits<int16_t> {
1246  static void output(const int16_t &, void *, raw_ostream &);
1247  static StringRef input(StringRef, void *, int16_t &);
1248  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1249};
1250 
1251template<>
1252struct ScalarTraits<int32_t> {
1253  static void output(const int32_t &, void *, raw_ostream &);
1254  static StringRef input(StringRef, void *, int32_t &);
1255  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1256};
1257 
1258template<>
1259struct ScalarTraits<int64_t> {
1260  static void output(const int64_t &, void *, raw_ostream &);
1261  static StringRef input(StringRef, void *, int64_t &);
1262  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1263};
1264 
1265template<>
1266struct ScalarTraits<float> {
1267  static void output(const float &, void *, raw_ostream &);
1268  static StringRef input(StringRef, void *, float &);
1269  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1270};
1271 
1272template<>
1273struct ScalarTraits<double> {
1274  static void output(const double &, void *, raw_ostream &);
1275  static StringRef input(StringRef, void *, double &);
1276  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1277};
1278 
1279// For endian types, we use existing scalar Traits class for the underlying
1280// type.  This way endian aware types are supported whenever the traits are
1281// defined for the underlying type.
1282template <typename value_type, support::endianness endian, size_t alignment>
1283struct ScalarTraits<support::detail::packed_endian_specific_integral<
1284                        value_type, endian, alignment>,
1285                    std::enable_if_t<has_ScalarTraits<value_type>::value>> {
1286  using endian_type =
1287      support::detail::packed_endian_specific_integral<value_type, endian,
1288                                                       alignment>;
1289 
1290  static void output(const endian_type &E, void *Ctx, raw_ostream &Stream) {
1291    ScalarTraits<value_type>::output(static_cast<value_type>(E), Ctx, Stream);
1292  }
1293 
1294  static StringRef input(StringRef Str, void *Ctx, endian_type &E) {
1295    value_type V;
1296    auto R = ScalarTraits<value_type>::input(Str, Ctx, V);
1297    E = static_cast<endian_type>(V);
1298    return R;
1299  }
1300 
1301  static QuotingType mustQuote(StringRef Str) {
1302    return ScalarTraits<value_type>::mustQuote(Str);
1303  }
1304};
1305 
1306template <typename value_type, support::endianness endian, size_t alignment>
1307struct ScalarEnumerationTraits<
1308    support::detail::packed_endian_specific_integral<value_type, endian,
1309                                                     alignment>,
1310    std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> {
1311  using endian_type =
1312      support::detail::packed_endian_specific_integral<value_type, endian,
1313                                                       alignment>;
1314 
1315  static void enumeration(IO &io, endian_type &E) {
1316    value_type V = E;
1317    ScalarEnumerationTraits<value_type>::enumeration(io, V);
1318    E = V;
1319  }
1320};
1321 
1322template <typename value_type, support::endianness endian, size_t alignment>
1323struct ScalarBitSetTraits<
1324    support::detail::packed_endian_specific_integral<value_type, endian,
1325                                                     alignment>,
1326    std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> {
1327  using endian_type =
1328      support::detail::packed_endian_specific_integral<value_type, endian,
1329                                                       alignment>;
1330  static void bitset(IO &io, endian_type &E) {
1331    value_type V = E;
1332    ScalarBitSetTraits<value_type>::bitset(io, V);
1333    E = V;
1334  }
1335};
1336 
1337// Utility for use within MappingTraits<>::mapping() method
1338// to [de]normalize an object for use with YAML conversion.
1339template <typename TNorm, typename TFinal>
1340struct MappingNormalization {
1341  MappingNormalization(IO &i_o, TFinal &Obj)
1342      : io(i_o), BufPtr(nullptr), Result(Obj) {
1343    if ( io.outputting() ) {
1344      BufPtr = new (&Buffer) TNorm(io, Obj);
1345    }
1346    else {
1347      BufPtr = new (&Buffer) TNorm(io);
1348    }
1349  }
1350 
1351  ~MappingNormalization() {
1352    if ( ! io.outputting() ) {
1353      Result = BufPtr->denormalize(io);
1354    }
1355    BufPtr->~TNorm();
1356  }
1357 
1358  TNorm* operator->() { return BufPtr; }
1359 
1360private:
1361  using Storage = AlignedCharArrayUnion<TNorm>;
1362 
1363  Storage       Buffer;
1364  IO           &io;
1365  TNorm        *BufPtr;
1366  TFinal       &Result;
1367};
1368 
1369// Utility for use within MappingTraits<>::mapping() method
1370// to [de]normalize an object for use with YAML conversion.
1371template <typename TNorm, typename TFinal>
1372struct MappingNormalizationHeap {
1373  MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
1374    : io(i_o), Result(Obj) {
1375    if ( io.outputting() ) {
1376      BufPtr = new (&Buffer) TNorm(io, Obj);
1377    }
1378    else if (allocator) {
1379      BufPtr = allocator->Allocate<TNorm>();
1380      new (BufPtr) TNorm(io);
1381    } else {
1382      BufPtr = new TNorm(io);
1383    }
1384  }
1385 
1386  ~MappingNormalizationHeap() {
1387    if ( io.outputting() ) {
1388      BufPtr->~TNorm();
1389    }
1390    else {
1391      Result = BufPtr->denormalize(io);
1392    }
1393  }
1394 
1395  TNorm* operator->() { return BufPtr; }
1396 
1397private:
1398  using Storage = AlignedCharArrayUnion<TNorm>;
1399 
1400  Storage       Buffer;
1401  IO           &io;
1402  TNorm        *BufPtr = nullptr;
1403  TFinal       &Result;
1404};
1405 
1406///
1407/// The Input class is used to parse a yaml document into in-memory structs
1408/// and vectors.
1409///
1410/// It works by using YAMLParser to do a syntax parse of the entire yaml
1411/// document, then the Input class builds a graph of HNodes which wraps
1412/// each yaml Node.  The extra layer is buffering.  The low level yaml
1413/// parser only lets you look at each node once.  The buffering layer lets
1414/// you search and interate multiple times.  This is necessary because
1415/// the mapRequired() method calls may not be in the same order
1416/// as the keys in the document.
1417///
1418class Input : public IO {
1419public:
1420  // Construct a yaml Input object from a StringRef and optional
1421  // user-data. The DiagHandler can be specified to provide
1422  // alternative error reporting.
1423  Input(StringRef InputContent,
1424        void *Ctxt = nullptr,
1425        SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1426        void *DiagHandlerCtxt = nullptr);
1427  Input(MemoryBufferRef Input,
1428        void *Ctxt = nullptr,
1429        SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1430        void *DiagHandlerCtxt = nullptr);
1431  ~Input() override;
1432 
1433  // Check if there was an syntax or semantic error during parsing.
1434  std::error_code error();
1435 
1436private:
1437  bool outputting() const override;
1438  bool mapTag(StringRef, bool) override;
1439  void beginMapping() override;
1440  void endMapping() override;
1441  bool preflightKey(const char *, bool, bool, bool &, void *&) override;
1442  void postflightKey(void *) override;
1443  std::vector<StringRef> keys() override;
1444  void beginFlowMapping() override;
1445  void endFlowMapping() override;
1446  unsigned beginSequence() override;
1447  void endSequence() override;
1448  bool preflightElement(unsigned index, void *&) override;
1449  void postflightElement(void *) override;
1450  unsigned beginFlowSequence() override;
1451  bool preflightFlowElement(unsigned , void *&) override;
1452  void postflightFlowElement(void *) override;
1453  void endFlowSequence() override;
1454  void beginEnumScalar() override;
1455  bool matchEnumScalar(const char*, bool) override;
1456  bool matchEnumFallback() override;
1457  void endEnumScalar() override;
1458  bool beginBitSetScalar(bool &) override;
1459  bool bitSetMatch(const char *, bool ) override;
1460  void endBitSetScalar() override;
1461  void scalarString(StringRef &, QuotingType) override;
1462  void blockScalarString(StringRef &) override;
1463  void scalarTag(std::string &) override;
1464  NodeKind getNodeKind() override;
1465  void setError(const Twine &message) override;
1466  bool canElideEmptySequence() override;
1467 
1468  class HNode {
1469    virtual void anchor();
1470 
1471  public:
1472    HNode(Node *n) : _node(n) { }
1473    virtual ~HNode() = default;
1474 
1475    static bool classof(const HNode *) { return true; }
1476 
1477    Node *_node;
1478  };
1479 
1480  class EmptyHNode : public HNode {
1481    void anchor() override;
1482 
1483  public:
1484    EmptyHNode(Node *n) : HNode(n) { }
1485 
1486    static bool classof(const HNode *n) { return NullNode::classof(n->_node); }
1487 
1488    static bool classof(const EmptyHNode *) { return true; }
1489  };
1490 
1491  class ScalarHNode : public HNode {
1492    void anchor() override;
1493 
1494  public:
1495    ScalarHNode(Node *n, StringRef s) : HNode(n), _value(s) { }
1496 
1497    StringRef value() const { return _value; }
1498 
1499    static bool classof(const HNode *n) {
1500      return ScalarNode::classof(n->_node) ||
1501             BlockScalarNode::classof(n->_node);
1502    }
1503 
1504    static bool classof(const ScalarHNode *) { return true; }
1505 
1506  protected:
1507    StringRef _value;
1508  };
1509 
1510  class MapHNode : public HNode {
1511    void anchor() override;
1512 
1513  public:
1514    MapHNode(Node *n) : HNode(n) { }
1515 
1516    static bool classof(const HNode *n) {
1517      return MappingNode::classof(n->_node);
1518    }
1519 
1520    static bool classof(const MapHNode *) { return true; }
1521 
1522    using NameToNodeAndLoc =
1523        StringMap<std::pair<std::unique_ptr<HNode>, SMRange>>;
1524 
1525    NameToNodeAndLoc Mapping;
1526    SmallVector<std::string, 6> ValidKeys;
1527  };
1528 
1529  class SequenceHNode : public HNode {
1530    void anchor() override;
1531 
1532  public:
1533    SequenceHNode(Node *n) : HNode(n) { }
1534 
1535    static bool classof(const HNode *n) {
1536      return SequenceNode::classof(n->_node);
1537    }
1538 
1539    static bool classof(const SequenceHNode *) { return true; }
1540 
1541    std::vector<std::unique_ptr<HNode>> Entries;
1542  };
1543 
1544  std::unique_ptr<Input::HNode> createHNodes(Node *node);
1545  void setError(HNode *hnode, const Twine &message);
1546  void setError(Node *node, const Twine &message);
1547  void setError(const SMRange &Range, const Twine &message);
1548 
1549  void reportWarning(HNode *hnode, const Twine &message);
1550  void reportWarning(Node *hnode, const Twine &message);
1551  void reportWarning(const SMRange &Range, const Twine &message);
1552 
1553public:
1554  // These are only used by operator>>. They could be private
1555  // if those templated things could be made friends.
1556  bool setCurrentDocument();
1557  bool nextDocument();
1558 
1559  /// Returns the current node that's being parsed by the YAML Parser.
1560  const Node *getCurrentNode() const;
1561 
1562  void setAllowUnknownKeys(bool Allow) override;
1563 
1564private:
1565  SourceMgr                           SrcMgr; // must be before Strm
1566  std::unique_ptr<llvm::yaml::Stream> Strm;
1567  std::unique_ptr<HNode>              TopNode;
1568  std::error_code                     EC;
1569  BumpPtrAllocator                    StringAllocator;
1570  document_iterator                   DocIterator;
1571  llvm::BitVector                     BitValuesUsed;
1572  HNode *CurrentNode = nullptr;
1573  bool                                ScalarMatchFound = false;
1574  bool AllowUnknownKeys = false;
1575};
1576 
1577///
1578/// The Output class is used to generate a yaml document from in-memory structs
1579/// and vectors.
1580///
1581class Output : public IO {
1582public:
1583  Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
1584  ~Output() override;
1585 
1586  /// Set whether or not to output optional values which are equal
1587  /// to the default value.  By default, when outputting if you attempt
1588  /// to write a value that is equal to the default, the value gets ignored.
1589  /// Sometimes, it is useful to be able to see these in the resulting YAML
1590  /// anyway.
1591  void setWriteDefaultValues(bool Write) { WriteDefaultValues = Write; }
1592 
1593  bool outputting() const override;
1594  bool mapTag(StringRef, bool) override;
1595  void beginMapping() override;
1596  void endMapping() override;
1597  bool preflightKey(const char *key, bool, bool, bool &, void *&) override;
1598  void postflightKey(void *) override;
1599  std::vector<StringRef> keys() override;
1600  void beginFlowMapping() override;
1601  void endFlowMapping() override;
1602  unsigned beginSequence() override;
1603  void endSequence() override;
1604  bool preflightElement(unsigned, void *&) override;
1605  void postflightElement(void *) override;
1606  unsigned beginFlowSequence() override;
1607  bool preflightFlowElement(unsigned, void *&) override;
1608  void postflightFlowElement(void *) override;
1609  void endFlowSequence() override;
1610  void beginEnumScalar() override;
1611  bool matchEnumScalar(const char*, bool) override;
1612  bool matchEnumFallback() override;
1613  void endEnumScalar() override;
1614  bool beginBitSetScalar(bool &) override;
1615  bool bitSetMatch(const char *, bool ) override;
1616  void endBitSetScalar() override;
1617  void scalarString(StringRef &, QuotingType) override;
1618  void blockScalarString(StringRef &) override;
1619  void scalarTag(std::string &) override;
1620  NodeKind getNodeKind() override;
1621  void setError(const Twine &message) override;
1622  bool canElideEmptySequence() override;
1623 
1624  // These are only used by operator<<. They could be private
1625  // if that templated operator could be made a friend.
1626  void beginDocuments();
1627  bool preflightDocument(unsigned);
1628  void postflightDocument();
1629  void endDocuments();
1630 
1631private:
1632  void output(StringRef s);
1633  void outputUpToEndOfLine(StringRef s);
1634  void newLineCheck(bool EmptySequence = false);
1635  void outputNewLine();
1636  void paddedKey(StringRef key);
1637  void flowKey(StringRef Key);
1638 
1639  enum InState {
1640    inSeqFirstElement,
1641    inSeqOtherElement,
1642    inFlowSeqFirstElement,
1643    inFlowSeqOtherElement,
1644    inMapFirstKey,
1645    inMapOtherKey,
1646    inFlowMapFirstKey,
1647    inFlowMapOtherKey
1648  };
1649 
1650  static bool inSeqAnyElement(InState State);
1651  static bool inFlowSeqAnyElement(InState State);
1652  static bool inMapAnyKey(InState State);
1653  static bool inFlowMapAnyKey(InState State);
1654 
1655  raw_ostream &Out;
1656  int WrapColumn;
1657  SmallVector<InState, 8> StateStack;
1658  int Column = 0;
1659  int ColumnAtFlowStart = 0;
1660  int ColumnAtMapFlowStart = 0;
1661  bool NeedBitValueComma = false;
1662  bool NeedFlowSequenceComma = false;
1663  bool EnumerationMatchFound = false;
1664  bool WriteDefaultValues = false;
1665  StringRef Padding;
1666  StringRef PaddingBeforeContainer;
1667};
1668 
1669template <typename T, typename Context>
1670void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
1671                               const std::optional<T> &DefaultValue,
1672                               bool Required, Context &Ctx) {
1673  assert(!DefaultValue && "std::optional<T> shouldn't have a value!")(static_cast <bool> (!DefaultValue && "std::optional<T> shouldn't have a value!"
) ? void (0) : __assert_fail ("!DefaultValue && \"std::optional<T> shouldn't have a value!\""
, "llvm/include/llvm/Support/YAMLTraits.h", 1673, __extension__
 __PRETTY_FUNCTION__));
1674  void *SaveInfo;
1675  bool UseDefault = true;
1676  const bool sameAsDefault = outputting() && !Val;
1677  if (!outputting() && !Val)
1678    Val = T();
1679  if (Val &&
1680      this->preflightKey(Key, Required, sameAsDefault, UseDefault, SaveInfo)) {
1681 
1682    // When reading an std::optional<X> key from a YAML description, we allow
1683    // the special "<none>" value, which can be used to specify that no value
1684    // was requested, i.e. the DefaultValue will be assigned. The DefaultValue
1685    // is usually None.
1686    bool IsNone = false;
1687    if (!outputting())
1688      if (const auto *Node =
1689              dyn_cast<ScalarNode>(((Input *)this)->getCurrentNode()))
1690        // We use rtrim to ignore possible white spaces that might exist when a
1691        // comment is present on the same line.
1692        IsNone = Node->getRawValue().rtrim(' ') == "<none>";
1693 
1694    if (IsNone)
1695      Val = DefaultValue;
1696    else
1697      yamlize(*this, *Val, Required, Ctx);
1698    this->postflightKey(SaveInfo);
1699  } else {
1700    if (UseDefault)
1701      Val = DefaultValue;
1702  }
1703}
1704 
1705/// YAML I/O does conversion based on types. But often native data types
1706/// are just a typedef of built in intergral types (e.g. int).  But the C++
1707/// type matching system sees through the typedef and all the typedefed types
1708/// look like a built in type. This will cause the generic YAML I/O conversion
1709/// to be used. To provide better control over the YAML conversion, you can
1710/// use this macro instead of typedef.  It will create a class with one field
1711/// and automatic conversion operators to and from the base type.
1712/// Based on BOOST_STRONG_TYPEDEF
1713#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)struct _type { _type() = default; _type(const _base v) : value
(v) {} _type(const _type &v) = default; _type &operator
=(const _type &rhs) = default; _type &operator=(const
 _base &rhs) { value = rhs; return *this; } operator const
 _base & () const { return value; } bool operator==(const
 _type &rhs) const { return value == rhs.value; } bool operator
==(const _base &rhs) const { return value == rhs; } bool operator
<(const _type &rhs) const { return value < rhs.value
; } _base value; using BaseType = _base; };                                 \
1714    struct _type {                                                             \
1715        _type() = default;                                                     \
1716        _type(const _base v) : value(v) {}                                     \
1717        _type(const _type &v) = default;                                       \
1718        _type &operator=(const _type &rhs) = default;                          \
1719        _type &operator=(const _base &rhs) { value = rhs; return *this; }      \
1720        operator const _base & () const { return value; }                      \
1721        bool operator==(const _type &rhs) const { return value == rhs.value; } \
1722        bool operator==(const _base &rhs) const { return value == rhs; }       \
1723        bool operator<(const _type &rhs) const { return value < rhs.value; }   \
1724        _base value;                                                           \
1725        using BaseType = _base;                                                \
1726    };
1727 
1728///
1729/// Use these types instead of uintXX_t in any mapping to have
1730/// its yaml output formatted as hexadecimal.
1731///
1732LLVM_YAML_STRONG_TYPEDEF(uint8_t, Hex8)struct Hex8 { Hex8() = default; Hex8(const uint8_t v) : value
(v) {} Hex8(const Hex8 &v) = default; Hex8 &operator=
(const Hex8 &rhs) = default; Hex8 &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const Hex8 &
rhs) const { return value == rhs.value; } bool operator==(const
 uint8_t &rhs) const { return value == rhs; } bool operator
<(const Hex8 &rhs) const { return value < rhs.value
; } uint8_t value; using BaseType = uint8_t; };
1733LLVM_YAML_STRONG_TYPEDEF(uint16_t, Hex16)struct Hex16 { Hex16() = default; Hex16(const uint16_t v) : value
(v) {} Hex16(const Hex16 &v) = default; Hex16 &operator
=(const Hex16 &rhs) = default; Hex16 &operator=(const
 uint16_t &rhs) { value = rhs; return *this; } operator const
 uint16_t & () const { return value; } bool operator==(const
 Hex16 &rhs) const { return value == rhs.value; } bool operator
==(const uint16_t &rhs) const { return value == rhs; } bool
 operator<(const Hex16 &rhs) const { return value <
 rhs.value; } uint16_t value; using BaseType = uint16_t; };
1734LLVM_YAML_STRONG_TYPEDEF(uint32_t, Hex32)struct Hex32 { Hex32() = default; Hex32(const uint32_t v) : value
(v) {} Hex32(const Hex32 &v) = default; Hex32 &operator
=(const Hex32 &rhs) = default; Hex32 &operator=(const
 uint32_t &rhs) { value = rhs; return *this; } operator const
 uint32_t & () const { return value; } bool operator==(const
 Hex32 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const Hex32 &rhs) const { return value <
 rhs.value; } uint32_t value; using BaseType = uint32_t; };
1735LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64)struct Hex64 { Hex64() = default; Hex64(const uint64_t v) : value
(v) {} Hex64(const Hex64 &v) = default; Hex64 &operator
=(const Hex64 &rhs) = default; Hex64 &operator=(const
 uint64_t &rhs) { value = rhs; return *this; } operator const
 uint64_t & () const { return value; } bool operator==(const
 Hex64 &rhs) const { return value == rhs.value; } bool operator
==(const uint64_t &rhs) const { return value == rhs; } bool
 operator<(const Hex64 &rhs) const { return value <
 rhs.value; } uint64_t value; using BaseType = uint64_t; };
1736 
1737template<>
1738struct ScalarTraits<Hex8> {
1739  static void output(const Hex8 &, void *, raw_ostream &);
1740  static StringRef input(StringRef, void *, Hex8 &);
1741  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1742};
1743 
1744template<>
1745struct ScalarTraits<Hex16> {
1746  static void output(const Hex16 &, void *, raw_ostream &);
1747  static StringRef input(StringRef, void *, Hex16 &);
1748  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1749};
1750 
1751template<>
1752struct ScalarTraits<Hex32> {
1753  static void output(const Hex32 &, void *, raw_ostream &);
1754  static StringRef input(StringRef, void *, Hex32 &);
1755  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1756};
1757 
1758template<>
1759struct ScalarTraits<Hex64> {
1760  static void output(const Hex64 &, void *, raw_ostream &);
1761  static StringRef input(StringRef, void *, Hex64 &);
1762  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1763};
1764 
1765template <> struct ScalarTraits<VersionTuple> {
1766  static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out);
1767  static StringRef input(StringRef, void *, VersionTuple &);
1768  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1769};
1770 
1771// Define non-member operator>> so that Input can stream in a document list.
1772template <typename T>
1773inline std::enable_if_t<has_DocumentListTraits<T>::value, Input &>
1774operator>>(Input &yin, T &docList) {
1775  int i = 0;
1776  EmptyContext Ctx;
1777  while ( yin.setCurrentDocument() ) {
1778    yamlize(yin, DocumentListTraits<T>::element(yin, docList, i), true, Ctx);
1779    if ( yin.error() )
1780      return yin;
1781    yin.nextDocument();
1782    ++i;
1783  }
1784  return yin;
1785}
1786 
1787// Define non-member operator>> so that Input can stream in a map as a document.
1788template <typename T>
1789inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Input &>
1790operator>>(Input &yin, T &docMap) {
1791  EmptyContext Ctx;
1792  yin.setCurrentDocument();
1793  yamlize(yin, docMap, true, Ctx);
1794  return yin;
1795}
1796 
1797// Define non-member operator>> so that Input can stream in a sequence as
1798// a document.
1799template <typename T>
1800inline std::enable_if_t<has_SequenceTraits<T>::value, Input &>
1801operator>>(Input &yin, T &docSeq) {
1802  EmptyContext Ctx;
1803  if (yin.setCurrentDocument())
1804    yamlize(yin, docSeq, true, Ctx);
1805  return yin;
1806}
1807 
1808// Define non-member operator>> so that Input can stream in a block scalar.
1809template <typename T>
1810inline std::enable_if_t<has_BlockScalarTraits<T>::value, Input &>
1811operator>>(Input &In, T &Val) {
1812  EmptyContext Ctx;
1813  if (In.setCurrentDocument())
1814    yamlize(In, Val, true, Ctx);
1815  return In;
1816}
1817 
1818// Define non-member operator>> so that Input can stream in a string map.
1819template <typename T>
1820inline std::enable_if_t<has_CustomMappingTraits<T>::value, Input &>
1821operator>>(Input &In, T &Val) {
1822  EmptyContext Ctx;
1823  if (In.setCurrentDocument())
1824    yamlize(In, Val, true, Ctx);
1825  return In;
1826}
1827 
1828// Define non-member operator>> so that Input can stream in a polymorphic type.
1829template <typename T>
1830inline std::enable_if_t<has_PolymorphicTraits<T>::value, Input &>
1831operator>>(Input &In, T &Val) {
1832  EmptyContext Ctx;
1833  if (In.setCurrentDocument())
1834    yamlize(In, Val, true, Ctx);
1835  return In;
1836}
1837 
1838// Provide better error message about types missing a trait specialization
1839template <typename T>
1840inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Input &>
1841operator>>(Input &yin, T &docSeq) {
1842  char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1843  return yin;
1844}
1845 
1846// Define non-member operator<< so that Output can stream out document list.
1847template <typename T>
1848inline std::enable_if_t<has_DocumentListTraits<T>::value, Output &>
1849operator<<(Output &yout, T &docList) {
1850  EmptyContext Ctx;
1851  yout.beginDocuments();
1852  const size_t count = DocumentListTraits<T>::size(yout, docList);
1853  for(size_t i=0; i < count; ++i) {
1854    if ( yout.preflightDocument(i) ) {
1855      yamlize(yout, DocumentListTraits<T>::element(yout, docList, i), true,
1856              Ctx);
1857      yout.postflightDocument();
1858    }
1859  }
1860  yout.endDocuments();
1861  return yout;
1862}
1863 
1864// Define non-member operator<< so that Output can stream out a map.
1865template <typename T>
1866inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Output &>
1867operator<<(Output &yout, T &map) {
1868  EmptyContext Ctx;
1869  yout.beginDocuments();
1870  if ( yout.preflightDocument(0) ) {
1871    yamlize(yout, map, true, Ctx);
1872    yout.postflightDocument();
1873  }
1874  yout.endDocuments();
1875  return yout;
1876}
1877 
1878// Define non-member operator<< so that Output can stream out a sequence.
1879template <typename T>
1880inline std::enable_if_t<has_SequenceTraits<T>::value, Output &>
1881operator<<(Output &yout, T &seq) {
1882  EmptyContext Ctx;
1883  yout.beginDocuments();
1884  if ( yout.preflightDocument(0) ) {
1885    yamlize(yout, seq, true, Ctx);
1886    yout.postflightDocument();
1887  }
1888  yout.endDocuments();
1889  return yout;
1890}
1891 
1892// Define non-member operator<< so that Output can stream out a block scalar.
1893template <typename T>
1894inline std::enable_if_t<has_BlockScalarTraits<T>::value, Output &>
1895operator<<(Output &Out, T &Val) {
1896  EmptyContext Ctx;
1897  Out.beginDocuments();
1898  if (Out.preflightDocument(0)) {
1899    yamlize(Out, Val, true, Ctx);
1900    Out.postflightDocument();
1901  }
1902  Out.endDocuments();
1903  return Out;
1904}
1905 
1906// Define non-member operator<< so that Output can stream out a string map.
1907template <typename T>
1908inline std::enable_if_t<has_CustomMappingTraits<T>::value, Output &>
1909operator<<(Output &Out, T &Val) {
1910  EmptyContext Ctx;
1911  Out.beginDocuments();
1912  if (Out.preflightDocument(0)) {
1913    yamlize(Out, Val, true, Ctx);
1914    Out.postflightDocument();
1915  }
1916  Out.endDocuments();
1917  return Out;
1918}
1919 
1920// Define non-member operator<< so that Output can stream out a polymorphic
1921// type.
1922template <typename T>
1923inline std::enable_if_t<has_PolymorphicTraits<T>::value, Output &>
1924operator<<(Output &Out, T &Val) {
1925  EmptyContext Ctx;
1926  Out.beginDocuments();
1927  if (Out.preflightDocument(0)) {
1928    // FIXME: The parser does not support explicit documents terminated with a
1929    // plain scalar; the end-marker is included as part of the scalar token.
1930    assert(PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && "plain scalar documents are not supported")(static_cast <bool> (PolymorphicTraits<T>::getKind
(Val) != NodeKind::Scalar && "plain scalar documents are not supported"
) ? void (0) : __assert_fail ("PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && \"plain scalar documents are not supported\""
, "llvm/include/llvm/Support/YAMLTraits.h", 1930, __extension__
 __PRETTY_FUNCTION__));
1931    yamlize(Out, Val, true, Ctx);
1932    Out.postflightDocument();
1933  }
1934  Out.endDocuments();
1935  return Out;
1936}
1937 
1938// Provide better error message about types missing a trait specialization
1939template <typename T>
1940inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Output &>
1941operator<<(Output &yout, T &seq) {
1942  char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1943  return yout;
1944}
1945 
1946template <bool B> struct IsFlowSequenceBase {};
1947template <> struct IsFlowSequenceBase<true> { static const bool flow = true; };
1948 
1949template <typename T, typename U = void>
1950struct IsResizable : std::false_type {};
1951 
1952template <typename T>
1953struct IsResizable<T, std::void_t<decltype(std::declval<T>().resize(0))>>
1954    : public std::true_type {};
1955 
1956template <typename T, bool B> struct IsResizableBase {
1957  using type = typename T::value_type;
1958 
1959  static type &element(IO &io, T &seq, size_t index) {
1960    if (index >= seq.size())
1961      seq.resize(index + 1);
1962    return seq[index];
1963  }
1964};
1965 
1966template <typename T> struct IsResizableBase<T, false> {
1967  using type = typename T::value_type;
1968 
1969  static type &element(IO &io, T &seq, size_t index) {
1970    if (index >= seq.size()) {
1971      io.setError(Twine("value sequence extends beyond static size (") +
1972                  Twine(seq.size()) + ")");
1973      return seq[0];
1974    }
1975    return seq[index];
1976  }
1977};
1978 
1979template <typename T, bool Flow>
1980struct SequenceTraitsImpl
1981    : IsFlowSequenceBase<Flow>, IsResizableBase<T, IsResizable<T>::value> {
1982  static size_t size(IO &io, T &seq) { return seq.size(); }
1983};
1984 
1985// Simple helper to check an expression can be used as a bool-valued template
1986// argument.
1987template <bool> struct CheckIsBool { static const bool value = true; };
1988 
1989// If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
1990// SequenceTraits that do the obvious thing.
1991template <typename T>
1992struct SequenceTraits<
1993    std::vector<T>,
1994    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
1995    : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
1996template <typename T, unsigned N>
1997struct SequenceTraits<
1998    SmallVector<T, N>,
1999    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
2000    : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
2001template <typename T>
2002struct SequenceTraits<
2003    SmallVectorImpl<T>,
2004    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
2005    : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {};
2006template <typename T>
2007struct SequenceTraits<
2008    MutableArrayRef<T>,
2009    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
2010    : SequenceTraitsImpl<MutableArrayRef<T>, SequenceElementTraits<T>::flow> {};
2011 
2012// Sequences of fundamental types use flow formatting.
2013template <typename T>
2014struct SequenceElementTraits<T,
2015                             std::enable_if_t<std::is_fundamental<T>::value>> {
2016  static const bool flow = true;
2017};
2018 
2019// Sequences of strings use block formatting.
2020template<> struct SequenceElementTraits<std::string> {
2021  static const bool flow = false;
2022};
2023template<> struct SequenceElementTraits<StringRef> {
2024  static const bool flow = false;
2025};
2026template<> struct SequenceElementTraits<std::pair<std::string, std::string>> {
2027  static const bool flow = false;
2028};
2029 
2030/// Implementation of CustomMappingTraits for std::map<std::string, T>.
2031template <typename T> struct StdMapStringCustomMappingTraitsImpl {
2032  using map_type = std::map<std::string, T>;
2033 
2034  static void inputOne(IO &io, StringRef key, map_type &v) {
2035    io.mapRequired(key.str().c_str(), v[std::string(key)]);
2036  }
2037 
2038  static void output(IO &io, map_type &v) {
2039    for (auto &p : v)
2040      io.mapRequired(p.first.c_str(), p.second);
2041  }
2042};
2043 
2044} // end namespace yaml
2045} // end namespace llvm
2046 
2047#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<TYPE> && !std::is_same_v<TYPE, std::string>
 && !std::is_same_v<TYPE, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<TYPE>
 { static const bool flow = FLOW; }; } }                          \
2048  namespace llvm {                                                             \
2049  namespace yaml {                                                             \
2050  static_assert(                                                               \
2051      !std::is_fundamental_v<TYPE> && !std::is_same_v<TYPE, std::string> &&    \
2052          !std::is_same_v<TYPE, llvm::StringRef>,                              \
2053      "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control");          \
2054  template <> struct SequenceElementTraits<TYPE> {                             \
2055    static const bool flow = FLOW;                                             \
2056  };                                                                           \
2057  }                                                                            \
2058  }
2059 
2060/// Utility for declaring that a std::vector of a particular type
2061/// should be considered a YAML sequence.
2062#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<type> && !std::is_same_v<type, std::string>
 && !std::is_same_v<type, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
 { static const bool flow = false; }; } }                                     \
2063  LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<type> && !std::is_same_v<type, std::string>
 && !std::is_same_v<type, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
 { static const bool flow = false; }; } }
2064 
2065/// Utility for declaring that a std::vector of a particular type
2066/// should be considered a YAML flow sequence.
2067#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<type> && !std::is_same_v<type, std::string>
 && !std::is_same_v<type, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
 { static const bool flow = true; }; } }                                \
2068  LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<type> && !std::is_same_v<type, std::string>
 && !std::is_same_v<type, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
 { static const bool flow = true; }; } }
2069 
2070#define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type)namespace llvm { namespace yaml { template <> struct MappingTraits
<Type> { static void mapping(IO &IO, Type &Obj)
; }; } }                                 \
2071  namespace llvm {                                                             \
2072  namespace yaml {                                                             \
2073  template <> struct MappingTraits<Type> {                                     \
2074    static void mapping(IO &IO, Type &Obj);                                    \
2075  };                                                                           \
2076  }                                                                            \
2077  }
2078 
2079#define LLVM_YAML_DECLARE_ENUM_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<Type> { static void enumeration(IO &io, Type &
Value); }; } }                                    \
2080  namespace llvm {                                                             \
2081  namespace yaml {                                                             \
2082  template <> struct ScalarEnumerationTraits<Type> {                           \
2083    static void enumeration(IO &io, Type &Value);                              \
2084  };                                                                           \
2085  }                                                                            \
2086  }
2087 
2088#define LLVM_YAML_DECLARE_BITSET_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<Type> { static void bitset(IO &IO, Type &Options
); }; } }                                  \
2089  namespace llvm {                                                             \
2090  namespace yaml {                                                             \
2091  template <> struct ScalarBitSetTraits<Type> {                                \
2092    static void bitset(IO &IO, Type &Options);                                 \
2093  };                                                                           \
2094  }                                                                            \
2095  }
2096 
2097#define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote)namespace llvm { namespace yaml { template <> struct ScalarTraits
<Type> { static void output(const Type &Value, void
 *ctx, raw_ostream &Out); static StringRef input(StringRef
 Scalar, void *ctxt, Type &Value); static QuotingType mustQuote
(StringRef) { return MustQuote; } }; } }                       \
2098  namespace llvm {                                                             \
2099  namespace yaml {                                                             \
2100  template <> struct ScalarTraits<Type> {                                      \
2101    static void output(const Type &Value, void *ctx, raw_ostream &Out);        \
2102    static StringRef input(StringRef Scalar, void *ctxt, Type &Value);         \
2103    static QuotingType mustQuote(StringRef) { return MustQuote; }              \
2104  };                                                                           \
2105  }                                                                            \
2106  }
2107 
2108/// Utility for declaring that a std::vector of a particular type
2109/// should be considered a YAML document list.
2110#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)namespace llvm { namespace yaml { template <unsigned N>
 struct DocumentListTraits<SmallVector<_type, N>>
 : public SequenceTraitsImpl<SmallVector<_type, N>, false
> {}; template <> struct DocumentListTraits<std::
vector<_type>> : public SequenceTraitsImpl<std::vector
<_type>, false> {}; } }                               \
2111  namespace llvm {                                                             \
2112  namespace yaml {                                                             \
2113  template <unsigned N>                                                        \
2114  struct DocumentListTraits<SmallVector<_type, N>>                             \
2115      : public SequenceTraitsImpl<SmallVector<_type, N>, false> {};            \
2116  template <>                                                                  \
2117  struct DocumentListTraits<std::vector<_type>>                                \
2118      : public SequenceTraitsImpl<std::vector<_type>, false> {};               \
2119  }                                                                            \
2120  }
2121 
2122/// Utility for declaring that std::map<std::string, _type> should be considered
2123/// a YAML map.
2124#define LLVM_YAML_IS_STRING_MAP(_type)namespace llvm { namespace yaml { template <> struct CustomMappingTraits
<std::map<std::string, _type>> : public StdMapStringCustomMappingTraitsImpl
<_type> {}; } }                                         \
2125  namespace llvm {                                                             \
2126  namespace yaml {                                                             \
2127  template <>                                                                  \
2128  struct CustomMappingTraits<std::map<std::string, _type>>                     \
2129      : public StdMapStringCustomMappingTraitsImpl<_type> {};                  \
2130  }                                                                            \
2131  }
2132 
2133LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex64)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::yaml::Hex64> && !std::is_same_v<llvm::
yaml::Hex64, std::string> && !std::is_same_v<llvm
::yaml::Hex64, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::yaml
::Hex64> { static const bool flow = true; }; } }
2134LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex32)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::yaml::Hex32> && !std::is_same_v<llvm::
yaml::Hex32, std::string> && !std::is_same_v<llvm
::yaml::Hex32, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::yaml
::Hex32> { static const bool flow = true; }; } }
2135LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex16)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::yaml::Hex16> && !std::is_same_v<llvm::
yaml::Hex16, std::string> && !std::is_same_v<llvm
::yaml::Hex16, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::yaml
::Hex16> { static const bool flow = true; }; } }
2136LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex8)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::yaml::Hex8> && !std::is_same_v<llvm::
yaml::Hex8, std::string> && !std::is_same_v<llvm
::yaml::Hex8, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::yaml
::Hex8> { static const bool flow = true; }; } }
2137 
2138#endif // LLVM_SUPPORT_YAMLTRAITS_H