MachOYAML.h revision f3014761c955345d6e05491608e73228d014afb7 
1//===- MachOYAML.h - Mach-O 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 Mach-O.
13///
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_OBJECTYAML_MACHOYAML_H
17#define LLVM_OBJECTYAML_MACHOYAML_H
18
19#include "llvm/ADT/StringRef.h"
20#include "llvm/BinaryFormat/MachO.h"
21#include "llvm/ObjectYAML/DWARFYAML.h"
22#include "llvm/Support/YAMLTraits.h"
23#include <cstdint>
24#include <string>
25#include <vector>
26
27namespace llvm {
28namespace MachOYAML {
29
30struct Section {
31  char sectname[16];
32  char segname[16];
33  llvm::yaml::Hex64 addr;
34  uint64_t size;
35  llvm::yaml::Hex32 offset;
36  uint32_t align;
37  llvm::yaml::Hex32 reloff;
38  uint32_t nreloc;
39  llvm::yaml::Hex32 flags;
40  llvm::yaml::Hex32 reserved1;
41  llvm::yaml::Hex32 reserved2;
42  llvm::yaml::Hex32 reserved3;
43};
44
45struct FileHeader {
46  llvm::yaml::Hex32 magic;
47  llvm::yaml::Hex32 cputype;
48  llvm::yaml::Hex32 cpusubtype;
49  llvm::yaml::Hex32 filetype;
50  uint32_t ncmds;
51  uint32_t sizeofcmds;
52  llvm::yaml::Hex32 flags;
53  llvm::yaml::Hex32 reserved;
54};
55
56struct LoadCommand {
57  virtual ~LoadCommand();
58
59  llvm::MachO::macho_load_command Data;
60  std::vector<Section> Sections;
61  std::vector<MachO::build_tool_version> Tools;
62  std::vector<llvm::yaml::Hex8> PayloadBytes;
63  std::string PayloadString;
64  uint64_t ZeroPadBytes;
65};
66
67struct NListEntry {
68  uint32_t n_strx;
69  llvm::yaml::Hex8 n_type;
70  uint8_t n_sect;
71  uint16_t n_desc;
72  uint64_t n_value;
73};
74
75struct RebaseOpcode {
76  MachO::RebaseOpcode Opcode;
77  uint8_t Imm;
78  std::vector<yaml::Hex64> ExtraData;
79};
80
81struct BindOpcode {
82  MachO::BindOpcode Opcode;
83  uint8_t Imm;
84  std::vector<yaml::Hex64> ULEBExtraData;
85  std::vector<int64_t> SLEBExtraData;
86  StringRef Symbol;
87};
88
89struct ExportEntry {
90  uint64_t TerminalSize = 0;
91  uint64_t NodeOffset = 0;
92  std::string Name;
93  llvm::yaml::Hex64 Flags = 0;
94  llvm::yaml::Hex64 Address = 0;
95  llvm::yaml::Hex64 Other = 0;
96  std::string ImportName;
97  std::vector<MachOYAML::ExportEntry> Children;
98};
99
100struct LinkEditData {
101  std::vector<MachOYAML::RebaseOpcode> RebaseOpcodes;
102  std::vector<MachOYAML::BindOpcode> BindOpcodes;
103  std::vector<MachOYAML::BindOpcode> WeakBindOpcodes;
104  std::vector<MachOYAML::BindOpcode> LazyBindOpcodes;
105  MachOYAML::ExportEntry ExportTrie;
106  std::vector<NListEntry> NameList;
107  std::vector<StringRef> StringTable;
108
109  bool isEmpty() const;
110};
111
112struct Object {
113  bool IsLittleEndian;
114  FileHeader Header;
115  std::vector<LoadCommand> LoadCommands;
116  std::vector<Section> Sections;
117  LinkEditData LinkEdit;
118  DWARFYAML::Data DWARF;
119};
120
121struct FatHeader {
122  llvm::yaml::Hex32 magic;
123  uint32_t nfat_arch;
124};
125
126struct FatArch {
127  llvm::yaml::Hex32 cputype;
128  llvm::yaml::Hex32 cpusubtype;
129  llvm::yaml::Hex64 offset;
130  uint64_t size;
131  uint32_t align;
132  llvm::yaml::Hex32 reserved;
133};
134
135struct UniversalBinary {
136  FatHeader Header;
137  std::vector<FatArch> FatArchs;
138  std::vector<Object> Slices;
139};
140
141} // end namespace MachOYAML
142} // end namespace llvm
143
144LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand)
145LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section)
146LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode)
147LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode)
148LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::ExportEntry)
149LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::NListEntry)
150LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Object)
151LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::FatArch)
152LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachO::build_tool_version)
153
154namespace llvm {
155
156class raw_ostream;
157
158namespace yaml {
159
160template <> struct MappingTraits<MachOYAML::FileHeader> {
161  static void mapping(IO &IO, MachOYAML::FileHeader &FileHeader);
162};
163
164template <> struct MappingTraits<MachOYAML::Object> {
165  static void mapping(IO &IO, MachOYAML::Object &Object);
166};
167
168template <> struct MappingTraits<MachOYAML::FatHeader> {
169  static void mapping(IO &IO, MachOYAML::FatHeader &FatHeader);
170};
171
172template <> struct MappingTraits<MachOYAML::FatArch> {
173  static void mapping(IO &IO, MachOYAML::FatArch &FatArch);
174};
175
176template <> struct MappingTraits<MachOYAML::UniversalBinary> {
177  static void mapping(IO &IO, MachOYAML::UniversalBinary &UniversalBinary);
178};
179
180template <> struct MappingTraits<MachOYAML::LoadCommand> {
181  static void mapping(IO &IO, MachOYAML::LoadCommand &LoadCommand);
182};
183
184template <> struct MappingTraits<MachOYAML::LinkEditData> {
185  static void mapping(IO &IO, MachOYAML::LinkEditData &LinkEditData);
186};
187
188template <> struct MappingTraits<MachOYAML::RebaseOpcode> {
189  static void mapping(IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode);
190};
191
192template <> struct MappingTraits<MachOYAML::BindOpcode> {
193  static void mapping(IO &IO, MachOYAML::BindOpcode &BindOpcode);
194};
195
196template <> struct MappingTraits<MachOYAML::ExportEntry> {
197  static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry);
198};
199
200template <> struct MappingTraits<MachOYAML::Section> {
201  static void mapping(IO &IO, MachOYAML::Section &Section);
202};
203
204template <> struct MappingTraits<MachOYAML::NListEntry> {
205  static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry);
206};
207
208template <> struct MappingTraits<MachO::build_tool_version> {
209  static void mapping(IO &IO, MachO::build_tool_version &tool);
210};
211
212#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
213  io.enumCase(value, #LCName, MachO::LCName);
214
215template <> struct ScalarEnumerationTraits<MachO::LoadCommandType> {
216  static void enumeration(IO &io, MachO::LoadCommandType &value) {
217#include "llvm/BinaryFormat/MachO.def"
218    io.enumFallback<Hex32>(value);
219  }
220};
221
222#define ENUM_CASE(Enum) io.enumCase(value, #Enum, MachO::Enum);
223
224template <> struct ScalarEnumerationTraits<MachO::RebaseOpcode> {
225  static void enumeration(IO &io, MachO::RebaseOpcode &value) {
226    ENUM_CASE(REBASE_OPCODE_DONE)
227    ENUM_CASE(REBASE_OPCODE_SET_TYPE_IMM)
228    ENUM_CASE(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
229    ENUM_CASE(REBASE_OPCODE_ADD_ADDR_ULEB)
230    ENUM_CASE(REBASE_OPCODE_ADD_ADDR_IMM_SCALED)
231    ENUM_CASE(REBASE_OPCODE_DO_REBASE_IMM_TIMES)
232    ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES)
233    ENUM_CASE(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB)
234    ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB)
235    io.enumFallback<Hex8>(value);
236  }
237};
238
239template <> struct ScalarEnumerationTraits<MachO::BindOpcode> {
240  static void enumeration(IO &io, MachO::BindOpcode &value) {
241    ENUM_CASE(BIND_OPCODE_DONE)
242    ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM)
243    ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB)
244    ENUM_CASE(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM)
245    ENUM_CASE(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
246    ENUM_CASE(BIND_OPCODE_SET_TYPE_IMM)
247    ENUM_CASE(BIND_OPCODE_SET_ADDEND_SLEB)
248    ENUM_CASE(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
249    ENUM_CASE(BIND_OPCODE_ADD_ADDR_ULEB)
250    ENUM_CASE(BIND_OPCODE_DO_BIND)
251    ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
252    ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED)
253    ENUM_CASE(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB)
254    io.enumFallback<Hex8>(value);
255  }
256};
257
258// This trait is used for 16-byte chars in Mach structures used for strings
259using char_16 = char[16];
260
261template <> struct ScalarTraits<char_16> {
262  static void output(const char_16 &Val, void *, raw_ostream &Out);
263  static StringRef input(StringRef Scalar, void *, char_16 &Val);
264  static bool mustQuote(StringRef S);
265};
266
267// This trait is used for UUIDs. It reads and writes them matching otool's
268// formatting style.
269using uuid_t = raw_ostream::uuid_t;
270
271template <> struct ScalarTraits<uuid_t> {
272  static void output(const uuid_t &Val, void *, raw_ostream &Out);
273  static StringRef input(StringRef Scalar, void *, uuid_t &Val);
274  static bool mustQuote(StringRef S);
275};
276
277// Load Command struct mapping traits
278
279#define LOAD_COMMAND_STRUCT(LCStruct)                                          \
280  template <> struct MappingTraits<MachO::LCStruct> {                          \
281    static void mapping(IO &IO, MachO::LCStruct &LoadCommand);                 \
282  };
283
284#include "llvm/BinaryFormat/MachO.def"
285
286// Extra structures used by load commands
287template <> struct MappingTraits<MachO::dylib> {
288  static void mapping(IO &IO, MachO::dylib &LoadCommand);
289};
290
291template <> struct MappingTraits<MachO::fvmlib> {
292  static void mapping(IO &IO, MachO::fvmlib &LoadCommand);
293};
294
295template <> struct MappingTraits<MachO::section> {
296  static void mapping(IO &IO, MachO::section &LoadCommand);
297};
298
299template <> struct MappingTraits<MachO::section_64> {
300  static void mapping(IO &IO, MachO::section_64 &LoadCommand);
301};
302
303} // end namespace yaml
304
305} // end namespace llvm
306
307#endif // LLVM_OBJECTYAML_MACHOYAML_H
308