contrib/llvm/include/llvm/Object/COFFYAML.h

   1 //===- COFFYAML.h - COFF YAMLIO implementation ------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares classes for handling the YAML representation of COFF.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_OBJECT_COFFYAML_H
  15 #define LLVM_OBJECT_COFFYAML_H
  16
  17 #include "llvm/Object/YAML.h"
  18 #include "llvm/Support/COFF.h"
  19
  20 namespace llvm {
  21
  22 namespace COFF {
  23 inline Characteristics operator|(Characteristics a, Characteristics b) {
  24   uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b);
  25   return static_cast<Characteristics>(Ret);
  26 }
  27
  28 inline SectionCharacteristics operator|(SectionCharacteristics a,
  29                                         SectionCharacteristics b) {
  30   uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b);
  31   return static_cast<SectionCharacteristics>(Ret);
  32 }
  33 }
  34
  35 // The structure of the yaml files is not an exact 1:1 match to COFF. In order
  36 // to use yaml::IO, we use these structures which are closer to the source.
  37 namespace COFFYAML {
  38   struct Relocation {
  39     uint32_t VirtualAddress;
  40     uint16_t Type;
  41     StringRef SymbolName;
  42   };
  43
  44   struct Section {
  45     COFF::section Header;
  46     unsigned Alignment;
  47     object::yaml::BinaryRef SectionData;
  48     std::vector<Relocation> Relocations;
  49     StringRef Name;
  50     Section();
  51   };
  52
  53   struct Symbol {
  54     COFF::symbol Header;
  55     COFF::SymbolBaseType SimpleType;
  56     COFF::SymbolComplexType ComplexType;
  57     object::yaml::BinaryRef AuxiliaryData;
  58     StringRef Name;
  59     Symbol();
  60   };
  61
  62   struct Object {
  63     COFF::header Header;
  64     std::vector<Section> Sections;
  65     std::vector<Symbol> Symbols;
  66     Object();
  67   };
  68 }
  69 }
  70
  71 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section)
  72 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol)
  73 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Relocation)
  74
  75 namespace llvm {
  76 namespace yaml {
  77
  78 template <>
  79 struct ScalarEnumerationTraits<COFF::MachineTypes> {
  80   static void enumeration(IO &IO, COFF::MachineTypes &Value);
  81 };
  82
  83 template <>
  84 struct ScalarEnumerationTraits<COFF::SymbolBaseType> {
  85   static void enumeration(IO &IO, COFF::SymbolBaseType &Value);
  86 };
  87
  88 template <>
  89 struct ScalarEnumerationTraits<COFF::SymbolStorageClass> {
  90   static void enumeration(IO &IO, COFF::SymbolStorageClass &Value);
  91 };
  92
  93 template <>
  94 struct ScalarEnumerationTraits<COFF::SymbolComplexType> {
  95   static void enumeration(IO &IO, COFF::SymbolComplexType &Value);
  96 };
  97
  98 template <>
  99 struct ScalarEnumerationTraits<COFF::RelocationTypeX86> {
 100   static void enumeration(IO &IO, COFF::RelocationTypeX86 &Value);
 101 };
 102
 103 template <>
 104 struct ScalarBitSetTraits<COFF::Characteristics> {
 105   static void bitset(IO &IO, COFF::Characteristics &Value);
 106 };
 107
 108 template <>
 109 struct ScalarBitSetTraits<COFF::SectionCharacteristics> {
 110   static void bitset(IO &IO, COFF::SectionCharacteristics &Value);
 111 };
 112
 113 template <>
 114 struct MappingTraits<COFFYAML::Relocation> {
 115   static void mapping(IO &IO, COFFYAML::Relocation &Rel);
 116 };
 117
 118 template <>
 119 struct MappingTraits<COFF::header> {
 120   static void mapping(IO &IO, COFF::header &H);
 121 };
 122
 123 template <>
 124 struct MappingTraits<COFFYAML::Symbol> {
 125   static void mapping(IO &IO, COFFYAML::Symbol &S);
 126 };
 127
 128 template <>
 129 struct MappingTraits<COFFYAML::Section> {
 130   static void mapping(IO &IO, COFFYAML::Section &Sec);
 131 };
 132
 133 template <>
 134 struct MappingTraits<COFFYAML::Object> {
 135   static void mapping(IO &IO, COFFYAML::Object &Obj);
 136 };
 137
 138 } // end namespace yaml
 139 } // end namespace llvm
 140
 141 #endif