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