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 Content;
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   std::vector<yaml::Hex32> IndirectSymbols;
125   std::vector<yaml::Hex64> FunctionStarts;
126 
127   bool isEmpty() const;
128 };
129 
130 struct Object {
131   bool IsLittleEndian;
132   FileHeader Header;
133   std::vector<LoadCommand> LoadCommands;
134   std::vector<Section> Sections;
135   LinkEditData LinkEdit;
136   Optional<llvm::yaml::BinaryRef> RawLinkEditSegment;
137   DWARFYAML::Data DWARF;
138 };
139 
140 struct FatHeader {
141   llvm::yaml::Hex32 magic;
142   uint32_t nfat_arch;
143 };
144 
145 struct FatArch {
146   llvm::yaml::Hex32 cputype;
147   llvm::yaml::Hex32 cpusubtype;
148   llvm::yaml::Hex64 offset;
149   uint64_t size;
150   uint32_t align;
151   llvm::yaml::Hex32 reserved;
152 };
153 
154 struct UniversalBinary {
155   FatHeader Header;
156   std::vector<FatArch> FatArchs;
157   std::vector<Object> Slices;
158 };
159 
160 } // end namespace MachOYAML
161 } // end namespace llvm
162 
163 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Relocation)164 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Relocation)
165 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section)
166 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode)
167 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode)
168 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::ExportEntry)
169 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::NListEntry)
170 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Object)
171 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::FatArch)
172 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachO::build_tool_version)
173 
174 namespace llvm {
175 
176 class raw_ostream;
177 
178 namespace yaml {
179 
180 template <> struct MappingTraits<MachOYAML::FileHeader> {
181   static void mapping(IO &IO, MachOYAML::FileHeader &FileHeader);
182 };
183 
184 template <> struct MappingTraits<MachOYAML::Object> {
185   static void mapping(IO &IO, MachOYAML::Object &Object);
186 };
187 
188 template <> struct MappingTraits<MachOYAML::FatHeader> {
189   static void mapping(IO &IO, MachOYAML::FatHeader &FatHeader);
190 };
191 
192 template <> struct MappingTraits<MachOYAML::FatArch> {
193   static void mapping(IO &IO, MachOYAML::FatArch &FatArch);
194 };
195 
196 template <> struct MappingTraits<MachOYAML::UniversalBinary> {
197   static void mapping(IO &IO, MachOYAML::UniversalBinary &UniversalBinary);
198 };
199 
200 template <> struct MappingTraits<MachOYAML::LoadCommand> {
201   static void mapping(IO &IO, MachOYAML::LoadCommand &LoadCommand);
202 };
203 
204 template <> struct MappingTraits<MachOYAML::LinkEditData> {
205   static void mapping(IO &IO, MachOYAML::LinkEditData &LinkEditData);
206 };
207 
208 template <> struct MappingTraits<MachOYAML::RebaseOpcode> {
209   static void mapping(IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode);
210 };
211 
212 template <> struct MappingTraits<MachOYAML::BindOpcode> {
213   static void mapping(IO &IO, MachOYAML::BindOpcode &BindOpcode);
214 };
215 
216 template <> struct MappingTraits<MachOYAML::ExportEntry> {
217   static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry);
218 };
219 
220 template <> struct MappingTraits<MachOYAML::Relocation> {
221   static void mapping(IO &IO, MachOYAML::Relocation &R);
222 };
223 
224 template <> struct MappingTraits<MachOYAML::Section> {
225   static void mapping(IO &IO, MachOYAML::Section &Section);
226   static std::string validate(IO &io, MachOYAML::Section &Section);
227 };
228 
229 template <> struct MappingTraits<MachOYAML::NListEntry> {
230   static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry);
231 };
232 
233 template <> struct MappingTraits<MachO::build_tool_version> {
234   static void mapping(IO &IO, MachO::build_tool_version &tool);
235 };
236 
237 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
238   io.enumCase(value, #LCName, MachO::LCName);
239 
240 template <> struct ScalarEnumerationTraits<MachO::LoadCommandType> {
241   static void enumeration(IO &io, MachO::LoadCommandType &value) {
242 #include "llvm/BinaryFormat/MachO.def"
243     io.enumFallback<Hex32>(value);
244   }
245 };
246 
247 #define ENUM_CASE(Enum) io.enumCase(value, #Enum, MachO::Enum);
248 
249 template <> struct ScalarEnumerationTraits<MachO::RebaseOpcode> {
250   static void enumeration(IO &io, MachO::RebaseOpcode &value) {
251     ENUM_CASE(REBASE_OPCODE_DONE)
252     ENUM_CASE(REBASE_OPCODE_SET_TYPE_IMM)
253     ENUM_CASE(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
254     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_ULEB)
255     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_IMM_SCALED)
256     ENUM_CASE(REBASE_OPCODE_DO_REBASE_IMM_TIMES)
257     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES)
258     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB)
259     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB)
260     io.enumFallback<Hex8>(value);
261   }
262 };
263 
264 template <> struct ScalarEnumerationTraits<MachO::BindOpcode> {
265   static void enumeration(IO &io, MachO::BindOpcode &value) {
266     ENUM_CASE(BIND_OPCODE_DONE)
267     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM)
268     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB)
269     ENUM_CASE(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM)
270     ENUM_CASE(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
271     ENUM_CASE(BIND_OPCODE_SET_TYPE_IMM)
272     ENUM_CASE(BIND_OPCODE_SET_ADDEND_SLEB)
273     ENUM_CASE(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
274     ENUM_CASE(BIND_OPCODE_ADD_ADDR_ULEB)
275     ENUM_CASE(BIND_OPCODE_DO_BIND)
276     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
277     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED)
278     ENUM_CASE(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB)
279     io.enumFallback<Hex8>(value);
280   }
281 };
282 
283 // This trait is used for 16-byte chars in Mach structures used for strings
284 using char_16 = char[16];
285 
286 template <> struct ScalarTraits<char_16> {
287   static void output(const char_16 &Val, void *, raw_ostream &Out);
288   static StringRef input(StringRef Scalar, void *, char_16 &Val);
289   static QuotingType mustQuote(StringRef S);
290 };
291 
292 // This trait is used for UUIDs. It reads and writes them matching otool's
293 // formatting style.
294 using uuid_t = raw_ostream::uuid_t;
295 
296 template <> struct ScalarTraits<uuid_t> {
297   static void output(const uuid_t &Val, void *, raw_ostream &Out);
298   static StringRef input(StringRef Scalar, void *, uuid_t &Val);
299   static QuotingType mustQuote(StringRef S);
300 };
301 
302 // Load Command struct mapping traits
303 
304 #define LOAD_COMMAND_STRUCT(LCStruct)                                          \
305   template <> struct MappingTraits<MachO::LCStruct> {                          \
306     static void mapping(IO &IO, MachO::LCStruct &LoadCommand);                 \
307   };
308 
309 #include "llvm/BinaryFormat/MachO.def"
310 
311 // Extra structures used by load commands
312 template <> struct MappingTraits<MachO::dylib> {
313   static void mapping(IO &IO, MachO::dylib &LoadCommand);
314 };
315 
316 template <> struct MappingTraits<MachO::fvmlib> {
317   static void mapping(IO &IO, MachO::fvmlib &LoadCommand);
318 };
319 
320 template <> struct MappingTraits<MachO::section> {
321   static void mapping(IO &IO, MachO::section &LoadCommand);
322 };
323 
324 template <> struct MappingTraits<MachO::section_64> {
325   static void mapping(IO &IO, MachO::section_64 &LoadCommand);
326 };
327 
328 } // end namespace yaml
329 
330 } // end namespace llvm
331 
332 #endif // LLVM_OBJECTYAML_MACHOYAML_H
333