llvm/llvm/lib/ObjectYAML/COFFYAML.cpp

//===- COFFYAML.cpp - COFF YAMLIO implementation --------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of COFF.
//
//===----------------------------------------------------------------------===//

#include "llvm/ObjectYAML/COFFYAML.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/YAMLTraits.h"
#include <cstdint>
#include <cstring>

#define ECase …

namespace llvm {

namespace COFFYAML {

Section::Section() { … }
Symbol::Symbol() { … }
Object::Object() { … }

} // end namespace COFFYAML

namespace yaml {

void ScalarEnumerationTraits<COFFYAML::COMDATType>::enumeration(
    IO &IO, COFFYAML::COMDATType &Value) { … }

void
ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics>::enumeration(
    IO &IO, COFFYAML::WeakExternalCharacteristics &Value) { … }

void ScalarEnumerationTraits<COFFYAML::AuxSymbolType>::enumeration(
    IO &IO, COFFYAML::AuxSymbolType &Value) { … }

void ScalarEnumerationTraits<COFF::MachineTypes>::enumeration(
    IO &IO, COFF::MachineTypes &Value) { … }

void ScalarEnumerationTraits<COFF::SymbolBaseType>::enumeration(
    IO &IO, COFF::SymbolBaseType &Value) { … }

void ScalarEnumerationTraits<COFF::SymbolStorageClass>::enumeration(
    IO &IO, COFF::SymbolStorageClass &Value) { … }

void ScalarEnumerationTraits<COFF::SymbolComplexType>::enumeration(
    IO &IO, COFF::SymbolComplexType &Value) { … }

void ScalarEnumerationTraits<COFF::RelocationTypeI386>::enumeration(
    IO &IO, COFF::RelocationTypeI386 &Value) { … }

void ScalarEnumerationTraits<COFF::RelocationTypeAMD64>::enumeration(
    IO &IO, COFF::RelocationTypeAMD64 &Value) { … }

void ScalarEnumerationTraits<COFF::RelocationTypesARM>::enumeration(
    IO &IO, COFF::RelocationTypesARM &Value) { … }

void ScalarEnumerationTraits<COFF::RelocationTypesARM64>::enumeration(
    IO &IO, COFF::RelocationTypesARM64 &Value) { … }

void ScalarEnumerationTraits<COFF::WindowsSubsystem>::enumeration(
    IO &IO, COFF::WindowsSubsystem &Value) { … }
#undef ECase

#define BCase …
void ScalarBitSetTraits<COFF::Characteristics>::bitset(
    IO &IO, COFF::Characteristics &Value) { … }

void ScalarBitSetTraits<COFF::SectionCharacteristics>::bitset(
    IO &IO, COFF::SectionCharacteristics &Value) { … }

void ScalarBitSetTraits<COFF::DLLCharacteristics>::bitset(
    IO &IO, COFF::DLLCharacteristics &Value) { … }
#undef BCase

namespace {

struct NSectionSelectionType { … };

struct NWeakExternalCharacteristics { … };

struct NSectionCharacteristics { … };

struct NAuxTokenType { … };

struct NStorageClass { … };

struct NMachine { … };

struct NHeaderCharacteristics { … };

template <typename RelocType>
struct NType { … };

struct NWindowsSubsystem { … };

struct NDLLCharacteristics { … };

} // end anonymous namespace

void MappingTraits<COFFYAML::Relocation>::mapping(IO &IO,
                                                  COFFYAML::Relocation &Rel) { … }

void MappingTraits<COFF::DataDirectory>::mapping(IO &IO,
                                                 COFF::DataDirectory &DD) { … }

void MappingTraits<COFFYAML::PEHeader>::mapping(IO &IO,
                                                COFFYAML::PEHeader &PH) { … }

void MappingTraits<COFF::header>::mapping(IO &IO, COFF::header &H) { … }

void MappingTraits<COFF::AuxiliaryFunctionDefinition>::mapping(
    IO &IO, COFF::AuxiliaryFunctionDefinition &AFD) { … }

void MappingTraits<COFF::AuxiliarybfAndefSymbol>::mapping(
    IO &IO, COFF::AuxiliarybfAndefSymbol &AAS) { … }

void MappingTraits<COFF::AuxiliaryWeakExternal>::mapping(
    IO &IO, COFF::AuxiliaryWeakExternal &AWE) { … }

void MappingTraits<COFF::AuxiliarySectionDefinition>::mapping(
    IO &IO, COFF::AuxiliarySectionDefinition &ASD) { … }

void MappingTraits<COFF::AuxiliaryCLRToken>::mapping(
    IO &IO, COFF::AuxiliaryCLRToken &ACT) { … }

void MappingTraits<object::coff_load_config_code_integrity>::mapping(
    IO &IO, object::coff_load_config_code_integrity &S) { … }

template <typename T, typename M>
void mapLoadConfigMember(IO &IO, T &LoadConfig, const char *Name, M &Member) { … }

template <typename T> void mapLoadConfig(IO &IO, T &LoadConfig) { … }

void MappingTraits<object::coff_load_configuration32>::mapping(
    IO &IO, object::coff_load_configuration32 &S) { … }

void MappingTraits<object::coff_load_configuration64>::mapping(
    IO &IO, object::coff_load_configuration64 &S) { … }

void MappingTraits<COFFYAML::SectionDataEntry>::mapping(
    IO &IO, COFFYAML::SectionDataEntry &E) { … }

void MappingTraits<COFFYAML::Symbol>::mapping(IO &IO, COFFYAML::Symbol &S) { … }

void MappingTraits<COFFYAML::Section>::mapping(IO &IO, COFFYAML::Section &Sec) { … }

void MappingTraits<COFFYAML::Object>::mapping(IO &IO, COFFYAML::Object &Obj) { … }

} // end namespace yaml

} // end namespace llvm