ELFYAML.h revision 5ba1225fb074f8035668637292d994d4c39757d1 
1//===- ELFYAML.h - ELF 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/// \file
11/// \brief This file declares classes for handling the YAML representation
12/// of ELF.
13///
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_OBJECT_ELFYAML_H
17#define LLVM_OBJECT_ELFYAML_H
18
19#include "llvm/Object/YAML.h"
20#include "llvm/Support/ELF.h"
21
22namespace llvm {
23namespace ELFYAML {
24
25// These types are invariant across 32/64-bit ELF, so for simplicity just
26// directly give them their exact sizes. We don't need to worry about
27// endianness because these are just the types in the YAMLIO structures,
28// and are appropriately converted to the necessary endianness when
29// reading/generating binary object files.
30// The naming of these types is intended to be ELF_PREFIX, where PREFIX is
31// the common prefix of the respective constants. E.g. ELF_EM corresponds
32// to the `e_machine` constants, like `EM_X86_64`.
33// In the future, these would probably be better suited by C++11 enum
34// class's with appropriate fixed underlying type.
35LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)
36LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)
37LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
38LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
39LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)
40// Just use 64, since it can hold 32-bit values too.
41LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)
42LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
43LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
44
45// For now, hardcode 64 bits everywhere that 32 or 64 would be needed
46// since 64-bit can hold 32-bit values too.
47struct FileHeader {
48  ELF_ELFCLASS Class;
49  ELF_ELFDATA Data;
50  ELF_ET Type;
51  ELF_EM Machine;
52  llvm::yaml::Hex64 Entry;
53};
54struct Symbol {
55  StringRef Name;
56  ELF_STB Binding;
57  ELF_STT Type;
58};
59struct Section {
60  StringRef Name;
61  ELF_SHT Type;
62  ELF_SHF Flags;
63  llvm::yaml::Hex64 Address;
64  object::yaml::BinaryRef Content;
65  StringRef Link;
66  llvm::yaml::Hex64 AddressAlign;
67  // For SHT_SYMTAB; should be empty otherwise.
68  std::vector<Symbol> Symbols;
69};
70struct Object {
71  FileHeader Header;
72  std::vector<Section> Sections;
73};
74
75} // end namespace ELFYAML
76} // end namespace llvm
77
78LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Section)
79LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
80
81namespace llvm {
82namespace yaml {
83
84template <>
85struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
86  static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
87};
88
89template <>
90struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
91  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
92};
93
94template <>
95struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
96  static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
97};
98
99template <>
100struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
101  static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
102};
103
104template <>
105struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
106  static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
107};
108
109template <>
110struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
111  static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
112};
113
114template <>
115struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
116  static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
117};
118
119template <>
120struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
121  static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
122};
123
124template <>
125struct MappingTraits<ELFYAML::FileHeader> {
126  static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
127};
128
129template <>
130struct MappingTraits<ELFYAML::Symbol> {
131  static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
132};
133
134template <>
135struct MappingTraits<ELFYAML::Section> {
136  static void mapping(IO &IO, ELFYAML::Section &Section);
137};
138
139template <>
140struct MappingTraits<ELFYAML::Object> {
141  static void mapping(IO &IO, ELFYAML::Object &Object);
142};
143
144} // end namespace yaml
145} // end namespace llvm
146
147#endif
148