Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- COFFYAML.h - COFF 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. // This file declares classes for handling the YAML representation of COFF.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_OBJECTYAML_COFFYAML_H
  14. #define LLVM_OBJECTYAML_COFFYAML_H
  15.  
  16. #include "llvm/ADT/StringRef.h"
  17. #include "llvm/BinaryFormat/COFF.h"
  18. #include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
  19. #include "llvm/ObjectYAML/CodeViewYAMLTypeHashing.h"
  20. #include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
  21. #include "llvm/ObjectYAML/YAML.h"
  22. #include <cstdint>
  23. #include <optional>
  24. #include <vector>
  25.  
  26. namespace llvm {
  27.  
  28. namespace COFF {
  29.  
  30. inline Characteristics operator|(Characteristics a, Characteristics b) {
  31.   uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b);
  32.   return static_cast<Characteristics>(Ret);
  33. }
  34.  
  35. inline SectionCharacteristics operator|(SectionCharacteristics a,
  36.                                         SectionCharacteristics b) {
  37.   uint32_t Ret = static_cast<uint32_t>(a) | static_cast<uint32_t>(b);
  38.   return static_cast<SectionCharacteristics>(Ret);
  39. }
  40.  
  41. inline DLLCharacteristics operator|(DLLCharacteristics a,
  42.                                     DLLCharacteristics b) {
  43.   uint16_t Ret = static_cast<uint16_t>(a) | static_cast<uint16_t>(b);
  44.   return static_cast<DLLCharacteristics>(Ret);
  45. }
  46.  
  47. } // end namespace COFF
  48.  
  49. // The structure of the yaml files is not an exact 1:1 match to COFF. In order
  50. // to use yaml::IO, we use these structures which are closer to the source.
  51. namespace COFFYAML {
  52.  
  53. LLVM_YAML_STRONG_TYPEDEF(uint8_t, COMDATType)
  54. LLVM_YAML_STRONG_TYPEDEF(uint32_t, WeakExternalCharacteristics)
  55. LLVM_YAML_STRONG_TYPEDEF(uint8_t, AuxSymbolType)
  56.  
  57. struct Relocation {
  58.   uint32_t VirtualAddress;
  59.   uint16_t Type;
  60.  
  61.   // Normally a Relocation can refer to the symbol via its name.
  62.   // It can also use a direct symbol table index instead (with no name
  63.   // specified), allowing disambiguating between multiple symbols with the
  64.   // same name or crafting intentionally broken files for testing.
  65.   StringRef SymbolName;
  66.   std::optional<uint32_t> SymbolTableIndex;
  67. };
  68.  
  69. struct Section {
  70.   COFF::section Header;
  71.   unsigned Alignment = 0;
  72.   yaml::BinaryRef SectionData;
  73.   std::vector<CodeViewYAML::YAMLDebugSubsection> DebugS;
  74.   std::vector<CodeViewYAML::LeafRecord> DebugT;
  75.   std::vector<CodeViewYAML::LeafRecord> DebugP;
  76.   std::optional<CodeViewYAML::DebugHSection> DebugH;
  77.   std::vector<Relocation> Relocations;
  78.   StringRef Name;
  79.  
  80.   Section();
  81. };
  82.  
  83. struct Symbol {
  84.   COFF::symbol Header;
  85.   COFF::SymbolBaseType SimpleType = COFF::IMAGE_SYM_TYPE_NULL;
  86.   COFF::SymbolComplexType ComplexType = COFF::IMAGE_SYM_DTYPE_NULL;
  87.   std::optional<COFF::AuxiliaryFunctionDefinition> FunctionDefinition;
  88.   std::optional<COFF::AuxiliarybfAndefSymbol> bfAndefSymbol;
  89.   std::optional<COFF::AuxiliaryWeakExternal> WeakExternal;
  90.   StringRef File;
  91.   std::optional<COFF::AuxiliarySectionDefinition> SectionDefinition;
  92.   std::optional<COFF::AuxiliaryCLRToken> CLRToken;
  93.   StringRef Name;
  94.  
  95.   Symbol();
  96. };
  97.  
  98. struct PEHeader {
  99.   COFF::PE32Header Header;
  100.   std::optional<COFF::DataDirectory>
  101.       DataDirectories[COFF::NUM_DATA_DIRECTORIES];
  102. };
  103.  
  104. struct Object {
  105.   std::optional<PEHeader> OptionalHeader;
  106.   COFF::header Header;
  107.   std::vector<Section> Sections;
  108.   std::vector<Symbol> Symbols;
  109.  
  110.   Object();
  111. };
  112.  
  113. } // end namespace COFFYAML
  114.  
  115. } // end namespace llvm
  116.  
  117. LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section)
  118. LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol)
  119. LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Relocation)
  120.  
  121. namespace llvm {
  122. namespace yaml {
  123.  
  124. template <>
  125. struct ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics> {
  126.   static void enumeration(IO &IO, COFFYAML::WeakExternalCharacteristics &Value);
  127. };
  128.  
  129. template <>
  130. struct ScalarEnumerationTraits<COFFYAML::AuxSymbolType> {
  131.   static void enumeration(IO &IO, COFFYAML::AuxSymbolType &Value);
  132. };
  133.  
  134. template <>
  135. struct ScalarEnumerationTraits<COFFYAML::COMDATType> {
  136.   static void enumeration(IO &IO, COFFYAML::COMDATType &Value);
  137. };
  138.  
  139. template <>
  140. struct ScalarEnumerationTraits<COFF::MachineTypes> {
  141.   static void enumeration(IO &IO, COFF::MachineTypes &Value);
  142. };
  143.  
  144. template <>
  145. struct ScalarEnumerationTraits<COFF::SymbolBaseType> {
  146.   static void enumeration(IO &IO, COFF::SymbolBaseType &Value);
  147. };
  148.  
  149. template <>
  150. struct ScalarEnumerationTraits<COFF::SymbolStorageClass> {
  151.   static void enumeration(IO &IO, COFF::SymbolStorageClass &Value);
  152. };
  153.  
  154. template <>
  155. struct ScalarEnumerationTraits<COFF::SymbolComplexType> {
  156.   static void enumeration(IO &IO, COFF::SymbolComplexType &Value);
  157. };
  158.  
  159. template <>
  160. struct ScalarEnumerationTraits<COFF::RelocationTypeI386> {
  161.   static void enumeration(IO &IO, COFF::RelocationTypeI386 &Value);
  162. };
  163.  
  164. template <>
  165. struct ScalarEnumerationTraits<COFF::RelocationTypeAMD64> {
  166.   static void enumeration(IO &IO, COFF::RelocationTypeAMD64 &Value);
  167. };
  168.  
  169. template <>
  170. struct ScalarEnumerationTraits<COFF::RelocationTypesARM> {
  171.   static void enumeration(IO &IO, COFF::RelocationTypesARM &Value);
  172. };
  173.  
  174. template <>
  175. struct ScalarEnumerationTraits<COFF::RelocationTypesARM64> {
  176.   static void enumeration(IO &IO, COFF::RelocationTypesARM64 &Value);
  177. };
  178.  
  179. template <>
  180. struct ScalarEnumerationTraits<COFF::WindowsSubsystem> {
  181.   static void enumeration(IO &IO, COFF::WindowsSubsystem &Value);
  182. };
  183.  
  184. template <>
  185. struct ScalarBitSetTraits<COFF::Characteristics> {
  186.   static void bitset(IO &IO, COFF::Characteristics &Value);
  187. };
  188.  
  189. template <>
  190. struct ScalarBitSetTraits<COFF::SectionCharacteristics> {
  191.   static void bitset(IO &IO, COFF::SectionCharacteristics &Value);
  192. };
  193.  
  194. template <>
  195. struct ScalarBitSetTraits<COFF::DLLCharacteristics> {
  196.   static void bitset(IO &IO, COFF::DLLCharacteristics &Value);
  197. };
  198.  
  199. template <>
  200. struct MappingTraits<COFFYAML::Relocation> {
  201.   static void mapping(IO &IO, COFFYAML::Relocation &Rel);
  202. };
  203.  
  204. template <>
  205. struct MappingTraits<COFFYAML::PEHeader> {
  206.   static void mapping(IO &IO, COFFYAML::PEHeader &PH);
  207. };
  208.  
  209. template <>
  210. struct MappingTraits<COFF::DataDirectory> {
  211.   static void mapping(IO &IO, COFF::DataDirectory &DD);
  212. };
  213.  
  214. template <>
  215. struct MappingTraits<COFF::header> {
  216.   static void mapping(IO &IO, COFF::header &H);
  217. };
  218.  
  219. template <> struct MappingTraits<COFF::AuxiliaryFunctionDefinition> {
  220.   static void mapping(IO &IO, COFF::AuxiliaryFunctionDefinition &AFD);
  221. };
  222.  
  223. template <> struct MappingTraits<COFF::AuxiliarybfAndefSymbol> {
  224.   static void mapping(IO &IO, COFF::AuxiliarybfAndefSymbol &AAS);
  225. };
  226.  
  227. template <> struct MappingTraits<COFF::AuxiliaryWeakExternal> {
  228.   static void mapping(IO &IO, COFF::AuxiliaryWeakExternal &AWE);
  229. };
  230.  
  231. template <> struct MappingTraits<COFF::AuxiliarySectionDefinition> {
  232.   static void mapping(IO &IO, COFF::AuxiliarySectionDefinition &ASD);
  233. };
  234.  
  235. template <> struct MappingTraits<COFF::AuxiliaryCLRToken> {
  236.   static void mapping(IO &IO, COFF::AuxiliaryCLRToken &ACT);
  237. };
  238.  
  239. template <>
  240. struct MappingTraits<COFFYAML::Symbol> {
  241.   static void mapping(IO &IO, COFFYAML::Symbol &S);
  242. };
  243.  
  244. template <>
  245. struct MappingTraits<COFFYAML::Section> {
  246.   static void mapping(IO &IO, COFFYAML::Section &Sec);
  247. };
  248.  
  249. template <>
  250. struct MappingTraits<COFFYAML::Object> {
  251.   static void mapping(IO &IO, COFFYAML::Object &Obj);
  252. };
  253.  
  254. } // end namespace yaml
  255. } // end namespace llvm
  256.  
  257. #endif // LLVM_OBJECTYAML_COFFYAML_H
  258.