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 { |
63 | llvm::yaml::Hex32 ; |
64 | llvm::yaml::Hex32 ; |
65 | llvm::yaml::Hex32 ; |
66 | llvm::yaml::Hex32 ; |
67 | uint32_t ; |
68 | uint32_t ; |
69 | llvm::yaml::Hex32 ; |
70 | llvm::yaml::Hex32 ; |
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> ; |
96 | }; |
97 | |
98 | struct BindOpcode { |
99 | MachO::BindOpcode Opcode; |
100 | uint8_t Imm; |
101 | std::vector<yaml::Hex64> ; |
102 | std::vector<int64_t> ; |
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 ; |
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 { |
150 | llvm::yaml::Hex32 ; |
151 | uint32_t ; |
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 ; |
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) |
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 (IO &IO, MachOYAML::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 (IO &IO, MachOYAML::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>(Val&: 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>(Val&: 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>(Val&: 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 | |