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