LLVM 17.0.0git
MachOYAML.cpp
Go to the documentation of this file.
1//===- MachOYAML.cpp - MachO YAMLIO implementation ------------------------===//
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// This file defines classes for handling the YAML representation of MachO.
10//
11//===----------------------------------------------------------------------===//
12
14#include "llvm/ADT/StringRef.h"
16#include "llvm/Support/Format.h"
17#include "llvm/Support/Host.h"
20#include <cinttypes>
21#include <cstdint>
22#include <cstring>
23
24namespace llvm {
25
27
29 return 0 == RebaseOpcodes.size() + BindOpcodes.size() +
30 WeakBindOpcodes.size() + LazyBindOpcodes.size() +
31 ExportTrie.Children.size() + NameList.size() +
32 StringTable.size() + FunctionStarts.size() +
33 ChainedFixups.size() + DataInCode.size();
34}
35
36namespace yaml {
37
38void ScalarTraits<char_16>::output(const char_16 &Val, void *,
39 raw_ostream &Out) {
40 auto Len = strnlen(&Val[0], 16);
41 Out << StringRef(&Val[0], Len);
42}
43
44StringRef ScalarTraits<char_16>::input(StringRef Scalar, void *, char_16 &Val) {
45 size_t CopySize = 16 >= Scalar.size() ? 16 : Scalar.size();
46 memcpy((void *)Val, Scalar.data(), CopySize);
47
48 if (Scalar.size() < 16) {
49 memset((void *)&Val[Scalar.size()], 0, 16 - Scalar.size());
50 }
51
52 return StringRef();
53}
54
55QuotingType ScalarTraits<char_16>::mustQuote(StringRef S) {
56 return needsQuotes(S);
57}
58
59void ScalarTraits<uuid_t>::output(const uuid_t &Val, void *, raw_ostream &Out) {
60 Out.write_uuid(Val);
61}
62
63StringRef ScalarTraits<uuid_t>::input(StringRef Scalar, void *, uuid_t &Val) {
64 size_t OutIdx = 0;
65 for (size_t Idx = 0; Idx < Scalar.size(); ++Idx) {
66 if (Scalar[Idx] == '-' || OutIdx >= 16)
67 continue;
68 unsigned long long TempInt;
69 if (getAsUnsignedInteger(Scalar.slice(Idx, Idx + 2), 16, TempInt))
70 return "invalid number";
71 if (TempInt > 0xFF)
72 return "out of range number";
73 Val[OutIdx] = static_cast<uint8_t>(TempInt);
74 ++Idx; // increment idx an extra time because we're consuming 2 chars
75 ++OutIdx;
76 }
77 return StringRef();
78}
79
80QuotingType ScalarTraits<uuid_t>::mustQuote(StringRef S) {
81 return needsQuotes(S);
82}
83
85 IO &IO, MachOYAML::FileHeader &FileHdr) {
86 IO.mapRequired("magic", FileHdr.magic);
87 IO.mapRequired("cputype", FileHdr.cputype);
88 IO.mapRequired("cpusubtype", FileHdr.cpusubtype);
89 IO.mapRequired("filetype", FileHdr.filetype);
90 IO.mapRequired("ncmds", FileHdr.ncmds);
91 IO.mapRequired("sizeofcmds", FileHdr.sizeofcmds);
92 IO.mapRequired("flags", FileHdr.flags);
93 if (FileHdr.magic == MachO::MH_MAGIC_64 ||
94 FileHdr.magic == MachO::MH_CIGAM_64)
95 IO.mapRequired("reserved", FileHdr.reserved);
96}
97
99 MachOYAML::Object &Object) {
100 // If the context isn't already set, tag the document as !mach-o.
101 // For Fat files there will be a different tag so they can be differentiated.
102 if (!IO.getContext()) {
103 IO.setContext(&Object);
104 }
105 IO.mapTag("!mach-o", true);
106 IO.mapOptional("IsLittleEndian", Object.IsLittleEndian,
107 sys::IsLittleEndianHost);
108 Object.DWARF.IsLittleEndian = Object.IsLittleEndian;
109
110 IO.mapRequired("FileHeader", Object.Header);
111 Object.DWARF.Is64BitAddrSize = Object.Header.magic == MachO::MH_MAGIC_64 ||
112 Object.Header.magic == MachO::MH_CIGAM_64;
113 IO.mapOptional("LoadCommands", Object.LoadCommands);
114
115 if (Object.RawLinkEditSegment || !IO.outputting())
116 IO.mapOptional("__LINKEDIT", Object.RawLinkEditSegment);
117 if(!Object.LinkEdit.isEmpty() || !IO.outputting())
118 IO.mapOptional("LinkEditData", Object.LinkEdit);
119
120 if(!Object.DWARF.isEmpty() || !IO.outputting())
121 IO.mapOptional("DWARF", Object.DWARF);
122
123 if (IO.getContext() == &Object)
124 IO.setContext(nullptr);
125}
126
128 IO &IO, MachOYAML::FatHeader &FatHeader) {
129 IO.mapRequired("magic", FatHeader.magic);
130 IO.mapRequired("nfat_arch", FatHeader.nfat_arch);
131}
132
134 MachOYAML::FatArch &FatArch) {
135 IO.mapRequired("cputype", FatArch.cputype);
136 IO.mapRequired("cpusubtype", FatArch.cpusubtype);
137 IO.mapRequired("offset", FatArch.offset);
138 IO.mapRequired("size", FatArch.size);
139 IO.mapRequired("align", FatArch.align);
140 IO.mapOptional("reserved", FatArch.reserved,
141 static_cast<llvm::yaml::Hex32>(0));
142}
143
145 IO &IO, MachOYAML::UniversalBinary &UniversalBinary) {
146 if (!IO.getContext()) {
147 IO.setContext(&UniversalBinary);
148 IO.mapTag("!fat-mach-o", true);
149 }
150 IO.mapRequired("FatHeader", UniversalBinary.Header);
151 IO.mapRequired("FatArchs", UniversalBinary.FatArchs);
152 IO.mapRequired("Slices", UniversalBinary.Slices);
153
154 if (IO.getContext() == &UniversalBinary)
155 IO.setContext(nullptr);
156}
157
159 IO &IO, MachOYAML::LinkEditData &LinkEditData) {
160 IO.mapOptional("RebaseOpcodes", LinkEditData.RebaseOpcodes);
161 IO.mapOptional("BindOpcodes", LinkEditData.BindOpcodes);
162 IO.mapOptional("WeakBindOpcodes", LinkEditData.WeakBindOpcodes);
163 IO.mapOptional("LazyBindOpcodes", LinkEditData.LazyBindOpcodes);
164 if (!LinkEditData.ExportTrie.Children.empty() || !IO.outputting())
165 IO.mapOptional("ExportTrie", LinkEditData.ExportTrie);
166 IO.mapOptional("NameList", LinkEditData.NameList);
167 IO.mapOptional("StringTable", LinkEditData.StringTable);
168 IO.mapOptional("IndirectSymbols", LinkEditData.IndirectSymbols);
169 IO.mapOptional("FunctionStarts", LinkEditData.FunctionStarts);
170 IO.mapOptional("ChainedFixups", LinkEditData.ChainedFixups);
171 IO.mapOptional("DataInCode", LinkEditData.DataInCode);
172}
173
175 IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode) {
176 IO.mapRequired("Opcode", RebaseOpcode.Opcode);
177 IO.mapRequired("Imm", RebaseOpcode.Imm);
178 IO.mapOptional("ExtraData", RebaseOpcode.ExtraData);
179}
180
182 IO &IO, MachOYAML::BindOpcode &BindOpcode) {
183 IO.mapRequired("Opcode", BindOpcode.Opcode);
184 IO.mapRequired("Imm", BindOpcode.Imm);
185 IO.mapOptional("ULEBExtraData", BindOpcode.ULEBExtraData);
186 IO.mapOptional("SLEBExtraData", BindOpcode.SLEBExtraData);
187 IO.mapOptional("Symbol", BindOpcode.Symbol);
188}
189
191 IO &IO, MachOYAML::ExportEntry &ExportEntry) {
192 IO.mapRequired("TerminalSize", ExportEntry.TerminalSize);
193 IO.mapOptional("NodeOffset", ExportEntry.NodeOffset);
194 IO.mapOptional("Name", ExportEntry.Name);
195 IO.mapOptional("Flags", ExportEntry.Flags);
196 IO.mapOptional("Address", ExportEntry.Address);
197 IO.mapOptional("Other", ExportEntry.Other);
198 IO.mapOptional("ImportName", ExportEntry.ImportName);
199 IO.mapOptional("Children", ExportEntry.Children);
200}
201
203 IO &IO, MachOYAML::NListEntry &NListEntry) {
204 IO.mapRequired("n_strx", NListEntry.n_strx);
205 IO.mapRequired("n_type", NListEntry.n_type);
206 IO.mapRequired("n_sect", NListEntry.n_sect);
207 IO.mapRequired("n_desc", NListEntry.n_desc);
208 IO.mapRequired("n_value", NListEntry.n_value);
209}
210
212 IO &IO, MachOYAML::DataInCodeEntry &DataInCodeEntry) {
213 IO.mapRequired("Offset", DataInCodeEntry.Offset);
214 IO.mapRequired("Length", DataInCodeEntry.Length);
215 IO.mapRequired("Kind", DataInCodeEntry.Kind);
216}
217
218template <typename StructType>
219void mapLoadCommandData(IO &IO, MachOYAML::LoadCommand &LoadCommand) {}
220
221template <>
222void mapLoadCommandData<MachO::segment_command>(
223 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
224 IO.mapOptional("Sections", LoadCommand.Sections);
225}
226
227template <>
228void mapLoadCommandData<MachO::segment_command_64>(
229 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
230 IO.mapOptional("Sections", LoadCommand.Sections);
231}
232
233template <>
234void mapLoadCommandData<MachO::dylib_command>(
235 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
236 IO.mapOptional("Content", LoadCommand.Content);
237}
238
239template <>
240void mapLoadCommandData<MachO::rpath_command>(
241 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
242 IO.mapOptional("Content", LoadCommand.Content);
243}
244
245template <>
246void mapLoadCommandData<MachO::dylinker_command>(
247 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
248 IO.mapOptional("Content", LoadCommand.Content);
249}
250
251template <>
252void mapLoadCommandData<MachO::sub_framework_command>(
253 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
254 IO.mapOptional("Content", LoadCommand.Content);
255}
256
257template <>
258void mapLoadCommandData<MachO::sub_umbrella_command>(
259 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
260 IO.mapOptional("Content", LoadCommand.Content);
261}
262
263template <>
264void mapLoadCommandData<MachO::sub_client_command>(
265 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
266 IO.mapOptional("Content", LoadCommand.Content);
267}
268
269template <>
270void mapLoadCommandData<MachO::sub_library_command>(
271 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
272 IO.mapOptional("Content", LoadCommand.Content);
273}
274
275template <>
276void mapLoadCommandData<MachO::build_version_command>(
277 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
278 IO.mapOptional("Tools", LoadCommand.Tools);
279}
280
282 IO &IO, MachOYAML::LoadCommand &LoadCommand) {
283 MachO::LoadCommandType TempCmd = static_cast<MachO::LoadCommandType>(
284 LoadCommand.Data.load_command_data.cmd);
285 IO.mapRequired("cmd", TempCmd);
286 LoadCommand.Data.load_command_data.cmd = TempCmd;
287 IO.mapRequired("cmdsize", LoadCommand.Data.load_command_data.cmdsize);
288
289#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
290 case MachO::LCName: \
291 MappingTraits<MachO::LCStruct>::mapping(IO, \
292 LoadCommand.Data.LCStruct##_data); \
293 mapLoadCommandData<MachO::LCStruct>(IO, LoadCommand); \
294 break;
295
296 switch (LoadCommand.Data.load_command_data.cmd) {
297#include "llvm/BinaryFormat/MachO.def"
298 }
299 IO.mapOptional("PayloadBytes", LoadCommand.PayloadBytes);
300 IO.mapOptional("ZeroPadBytes", LoadCommand.ZeroPadBytes, (uint64_t)0ull);
301}
302
304 IO &IO, MachO::dyld_info_command &LoadCommand) {
305 IO.mapRequired("rebase_off", LoadCommand.rebase_off);
306 IO.mapRequired("rebase_size", LoadCommand.rebase_size);
307 IO.mapRequired("bind_off", LoadCommand.bind_off);
308 IO.mapRequired("bind_size", LoadCommand.bind_size);
309 IO.mapRequired("weak_bind_off", LoadCommand.weak_bind_off);
310 IO.mapRequired("weak_bind_size", LoadCommand.weak_bind_size);
311 IO.mapRequired("lazy_bind_off", LoadCommand.lazy_bind_off);
312 IO.mapRequired("lazy_bind_size", LoadCommand.lazy_bind_size);
313 IO.mapRequired("export_off", LoadCommand.export_off);
314 IO.mapRequired("export_size", LoadCommand.export_size);
315}
316
318 IO &IO, MachOYAML::Relocation &Relocation) {
319 IO.mapRequired("address", Relocation.address);
320 IO.mapRequired("symbolnum", Relocation.symbolnum);
321 IO.mapRequired("pcrel", Relocation.is_pcrel);
322 IO.mapRequired("length", Relocation.length);
323 IO.mapRequired("extern", Relocation.is_extern);
324 IO.mapRequired("type", Relocation.type);
325 IO.mapRequired("scattered", Relocation.is_scattered);
326 IO.mapRequired("value", Relocation.value);
327}
328
330 MachOYAML::Section &Section) {
331 IO.mapRequired("sectname", Section.sectname);
332 IO.mapRequired("segname", Section.segname);
333 IO.mapRequired("addr", Section.addr);
334 IO.mapRequired("size", Section.size);
335 IO.mapRequired("offset", Section.offset);
336 IO.mapRequired("align", Section.align);
337 IO.mapRequired("reloff", Section.reloff);
338 IO.mapRequired("nreloc", Section.nreloc);
339 IO.mapRequired("flags", Section.flags);
340 IO.mapRequired("reserved1", Section.reserved1);
341 IO.mapRequired("reserved2", Section.reserved2);
342 IO.mapOptional("reserved3", Section.reserved3);
343 IO.mapOptional("content", Section.content);
344 IO.mapOptional("relocations", Section.relocations);
345}
346
347std::string
349 MachOYAML::Section &Section) {
350 if (Section.content && Section.size < Section.content->binary_size())
351 return "Section size must be greater than or equal to the content size";
352 return "";
353}
354
356 IO &IO, MachO::build_tool_version &tool) {
357 IO.mapRequired("tool", tool.tool);
358 IO.mapRequired("version", tool.version);
359}
360
362 IO.mapRequired("name", DylibStruct.name);
363 IO.mapRequired("timestamp", DylibStruct.timestamp);
364 IO.mapRequired("current_version", DylibStruct.current_version);
365 IO.mapRequired("compatibility_version", DylibStruct.compatibility_version);
366}
367
369 IO &IO, MachO::dylib_command &LoadCommand) {
370 IO.mapRequired("dylib", LoadCommand.dylib);
371}
372
373void MappingTraits<MachO::dylinker_command>::mapping(
374 IO &IO, MachO::dylinker_command &LoadCommand) {
375 IO.mapRequired("name", LoadCommand.name);
376}
377
378void MappingTraits<MachO::dysymtab_command>::mapping(
379 IO &IO, MachO::dysymtab_command &LoadCommand) {
380 IO.mapRequired("ilocalsym", LoadCommand.ilocalsym);
381 IO.mapRequired("nlocalsym", LoadCommand.nlocalsym);
382 IO.mapRequired("iextdefsym", LoadCommand.iextdefsym);
383 IO.mapRequired("nextdefsym", LoadCommand.nextdefsym);
384 IO.mapRequired("iundefsym", LoadCommand.iundefsym);
385 IO.mapRequired("nundefsym", LoadCommand.nundefsym);
386 IO.mapRequired("tocoff", LoadCommand.tocoff);
387 IO.mapRequired("ntoc", LoadCommand.ntoc);
388 IO.mapRequired("modtaboff", LoadCommand.modtaboff);
389 IO.mapRequired("nmodtab", LoadCommand.nmodtab);
390 IO.mapRequired("extrefsymoff", LoadCommand.extrefsymoff);
391 IO.mapRequired("nextrefsyms", LoadCommand.nextrefsyms);
392 IO.mapRequired("indirectsymoff", LoadCommand.indirectsymoff);
393 IO.mapRequired("nindirectsyms", LoadCommand.nindirectsyms);
394 IO.mapRequired("extreloff", LoadCommand.extreloff);
395 IO.mapRequired("nextrel", LoadCommand.nextrel);
396 IO.mapRequired("locreloff", LoadCommand.locreloff);
397 IO.mapRequired("nlocrel", LoadCommand.nlocrel);
398}
399
400void MappingTraits<MachO::encryption_info_command>::mapping(
401 IO &IO, MachO::encryption_info_command &LoadCommand) {
402 IO.mapRequired("cryptoff", LoadCommand.cryptoff);
403 IO.mapRequired("cryptsize", LoadCommand.cryptsize);
404 IO.mapRequired("cryptid", LoadCommand.cryptid);
405}
406
407void MappingTraits<MachO::encryption_info_command_64>::mapping(
408 IO &IO, MachO::encryption_info_command_64 &LoadCommand) {
409 IO.mapRequired("cryptoff", LoadCommand.cryptoff);
410 IO.mapRequired("cryptsize", LoadCommand.cryptsize);
411 IO.mapRequired("cryptid", LoadCommand.cryptid);
412 IO.mapRequired("pad", LoadCommand.pad);
413}
414
415void MappingTraits<MachO::entry_point_command>::mapping(
416 IO &IO, MachO::entry_point_command &LoadCommand) {
417 IO.mapRequired("entryoff", LoadCommand.entryoff);
418 IO.mapRequired("stacksize", LoadCommand.stacksize);
419}
420
421void MappingTraits<MachO::fvmfile_command>::mapping(
422 IO &IO, MachO::fvmfile_command &LoadCommand) {
423 IO.mapRequired("name", LoadCommand.name);
424 IO.mapRequired("header_addr", LoadCommand.header_addr);
425}
426
428 IO.mapRequired("name", FVMLib.name);
429 IO.mapRequired("minor_version", FVMLib.minor_version);
430 IO.mapRequired("header_addr", FVMLib.header_addr);
431}
432
434 IO &IO, MachO::fvmlib_command &LoadCommand) {
435 IO.mapRequired("fvmlib", LoadCommand.fvmlib);
436}
437
438void MappingTraits<MachO::ident_command>::mapping(
439 IO &IO, MachO::ident_command &LoadCommand) {}
440
441void MappingTraits<MachO::linkedit_data_command>::mapping(
442 IO &IO, MachO::linkedit_data_command &LoadCommand) {
443 IO.mapRequired("dataoff", LoadCommand.dataoff);
444 IO.mapRequired("datasize", LoadCommand.datasize);
445}
446
447void MappingTraits<MachO::linker_option_command>::mapping(
448 IO &IO, MachO::linker_option_command &LoadCommand) {
449 IO.mapRequired("count", LoadCommand.count);
450}
451
452void MappingTraits<MachO::prebind_cksum_command>::mapping(
453 IO &IO, MachO::prebind_cksum_command &LoadCommand) {
454 IO.mapRequired("cksum", LoadCommand.cksum);
455}
456
457void MappingTraits<MachO::load_command>::mapping(
458 IO &IO, MachO::load_command &LoadCommand) {}
459
460void MappingTraits<MachO::prebound_dylib_command>::mapping(
461 IO &IO, MachO::prebound_dylib_command &LoadCommand) {
462 IO.mapRequired("name", LoadCommand.name);
463 IO.mapRequired("nmodules", LoadCommand.nmodules);
464 IO.mapRequired("linked_modules", LoadCommand.linked_modules);
465}
466
467void MappingTraits<MachO::routines_command>::mapping(
468 IO &IO, MachO::routines_command &LoadCommand) {
469 IO.mapRequired("init_address", LoadCommand.init_address);
470 IO.mapRequired("init_module", LoadCommand.init_module);
471 IO.mapRequired("reserved1", LoadCommand.reserved1);
472 IO.mapRequired("reserved2", LoadCommand.reserved2);
473 IO.mapRequired("reserved3", LoadCommand.reserved3);
474 IO.mapRequired("reserved4", LoadCommand.reserved4);
475 IO.mapRequired("reserved5", LoadCommand.reserved5);
476 IO.mapRequired("reserved6", LoadCommand.reserved6);
477}
478
479void MappingTraits<MachO::routines_command_64>::mapping(
480 IO &IO, MachO::routines_command_64 &LoadCommand) {
481 IO.mapRequired("init_address", LoadCommand.init_address);
482 IO.mapRequired("init_module", LoadCommand.init_module);
483 IO.mapRequired("reserved1", LoadCommand.reserved1);
484 IO.mapRequired("reserved2", LoadCommand.reserved2);
485 IO.mapRequired("reserved3", LoadCommand.reserved3);
486 IO.mapRequired("reserved4", LoadCommand.reserved4);
487 IO.mapRequired("reserved5", LoadCommand.reserved5);
488 IO.mapRequired("reserved6", LoadCommand.reserved6);
489}
490
491void MappingTraits<MachO::rpath_command>::mapping(
492 IO &IO, MachO::rpath_command &LoadCommand) {
493 IO.mapRequired("path", LoadCommand.path);
494}
495
497 IO.mapRequired("sectname", Section.sectname);
498 IO.mapRequired("segname", Section.segname);
499 IO.mapRequired("addr", Section.addr);
500 IO.mapRequired("size", Section.size);
501 IO.mapRequired("offset", Section.offset);
502 IO.mapRequired("align", Section.align);
503 IO.mapRequired("reloff", Section.reloff);
504 IO.mapRequired("nreloc", Section.nreloc);
505 IO.mapRequired("flags", Section.flags);
506 IO.mapRequired("reserved1", Section.reserved1);
507 IO.mapRequired("reserved2", Section.reserved2);
508}
509
511 MachO::section_64 &Section) {
512 IO.mapRequired("sectname", Section.sectname);
513 IO.mapRequired("segname", Section.segname);
514 IO.mapRequired("addr", Section.addr);
515 IO.mapRequired("size", Section.size);
516 IO.mapRequired("offset", Section.offset);
517 IO.mapRequired("align", Section.align);
518 IO.mapRequired("reloff", Section.reloff);
519 IO.mapRequired("nreloc", Section.nreloc);
520 IO.mapRequired("flags", Section.flags);
521 IO.mapRequired("reserved1", Section.reserved1);
522 IO.mapRequired("reserved2", Section.reserved2);
523 IO.mapRequired("reserved3", Section.reserved3);
524}
525
527 IO &IO, MachO::segment_command &LoadCommand) {
528 IO.mapRequired("segname", LoadCommand.segname);
529 IO.mapRequired("vmaddr", LoadCommand.vmaddr);
530 IO.mapRequired("vmsize", LoadCommand.vmsize);
531 IO.mapRequired("fileoff", LoadCommand.fileoff);
532 IO.mapRequired("filesize", LoadCommand.filesize);
533 IO.mapRequired("maxprot", LoadCommand.maxprot);
534 IO.mapRequired("initprot", LoadCommand.initprot);
535 IO.mapRequired("nsects", LoadCommand.nsects);
536 IO.mapRequired("flags", LoadCommand.flags);
537}
538
539void MappingTraits<MachO::segment_command_64>::mapping(
540 IO &IO, MachO::segment_command_64 &LoadCommand) {
541 IO.mapRequired("segname", LoadCommand.segname);
542 IO.mapRequired("vmaddr", LoadCommand.vmaddr);
543 IO.mapRequired("vmsize", LoadCommand.vmsize);
544 IO.mapRequired("fileoff", LoadCommand.fileoff);
545 IO.mapRequired("filesize", LoadCommand.filesize);
546 IO.mapRequired("maxprot", LoadCommand.maxprot);
547 IO.mapRequired("initprot", LoadCommand.initprot);
548 IO.mapRequired("nsects", LoadCommand.nsects);
549 IO.mapRequired("flags", LoadCommand.flags);
550}
551
552void MappingTraits<MachO::source_version_command>::mapping(
553 IO &IO, MachO::source_version_command &LoadCommand) {
554 IO.mapRequired("version", LoadCommand.version);
555}
556
557void MappingTraits<MachO::sub_client_command>::mapping(
558 IO &IO, MachO::sub_client_command &LoadCommand) {
559 IO.mapRequired("client", LoadCommand.client);
560}
561
562void MappingTraits<MachO::sub_framework_command>::mapping(
563 IO &IO, MachO::sub_framework_command &LoadCommand) {
564 IO.mapRequired("umbrella", LoadCommand.umbrella);
565}
566
567void MappingTraits<MachO::sub_library_command>::mapping(
568 IO &IO, MachO::sub_library_command &LoadCommand) {
569 IO.mapRequired("sub_library", LoadCommand.sub_library);
570}
571
572void MappingTraits<MachO::sub_umbrella_command>::mapping(
573 IO &IO, MachO::sub_umbrella_command &LoadCommand) {
574 IO.mapRequired("sub_umbrella", LoadCommand.sub_umbrella);
575}
576
577void MappingTraits<MachO::symseg_command>::mapping(
578 IO &IO, MachO::symseg_command &LoadCommand) {
579 IO.mapRequired("offset", LoadCommand.offset);
580 IO.mapRequired("size", LoadCommand.size);
581}
582
583void MappingTraits<MachO::symtab_command>::mapping(
584 IO &IO, MachO::symtab_command &LoadCommand) {
585 IO.mapRequired("symoff", LoadCommand.symoff);
586 IO.mapRequired("nsyms", LoadCommand.nsyms);
587 IO.mapRequired("stroff", LoadCommand.stroff);
588 IO.mapRequired("strsize", LoadCommand.strsize);
589}
590
591void MappingTraits<MachO::thread_command>::mapping(
592 IO &IO, MachO::thread_command &LoadCommand) {}
593
594void MappingTraits<MachO::twolevel_hints_command>::mapping(
595 IO &IO, MachO::twolevel_hints_command &LoadCommand) {
596 IO.mapRequired("offset", LoadCommand.offset);
597 IO.mapRequired("nhints", LoadCommand.nhints);
598}
599
600void MappingTraits<MachO::uuid_command>::mapping(
601 IO &IO, MachO::uuid_command &LoadCommand) {
602 IO.mapRequired("uuid", LoadCommand.uuid);
603}
604
605void MappingTraits<MachO::version_min_command>::mapping(
606 IO &IO, MachO::version_min_command &LoadCommand) {
607 IO.mapRequired("version", LoadCommand.version);
608 IO.mapRequired("sdk", LoadCommand.sdk);
609}
610
611void MappingTraits<MachO::note_command>::mapping(
612 IO &IO, MachO::note_command &LoadCommand) {
613 IO.mapRequired("data_owner", LoadCommand.data_owner);
614 IO.mapRequired("offset", LoadCommand.offset);
615 IO.mapRequired("size", LoadCommand.size);
616}
617
618void MappingTraits<MachO::build_version_command>::mapping(
619 IO &IO, MachO::build_version_command &LoadCommand) {
620 IO.mapRequired("platform", LoadCommand.platform);
621 IO.mapRequired("minos", LoadCommand.minos);
622 IO.mapRequired("sdk", LoadCommand.sdk);
623 IO.mapRequired("ntools", LoadCommand.ntools);
624}
625
626void MappingTraits<MachO::fileset_entry_command>::mapping(
627 IO &IO, MachO::fileset_entry_command &LoadCommand) {
628 IO.mapRequired("vmaddr", LoadCommand.vmaddr);
629 IO.mapRequired("fileoff", LoadCommand.fileoff);
630 IO.mapRequired("id", LoadCommand.entry_id);
631}
632
633} // end namespace yaml
634
635} // end namespace llvm
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file declares classes for handling the YAML representation of Mach-O.
This header is deprecated in favour of llvm/TargetParser/Host.h.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
raw_ostream & write_uuid(const uuid_t UUID)
LoadCommandType
Definition: MachO.h:98
void mapLoadCommandData(IO &IO, MachOYAML::LoadCommand &LoadCommand)
Definition: MachOYAML.cpp:219
raw_ostream::uuid_t uuid_t
Definition: MachOYAML.h:308
char[16] char_16
Definition: MachOYAML.h:298
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:492
std::vector< MachOYAML::ExportEntry > Children
Definition: MachOYAML.h:114
llvm::yaml::Hex64 Address
Definition: MachOYAML.h:111
llvm::yaml::Hex64 Other
Definition: MachOYAML.h:112
llvm::yaml::Hex64 Flags
Definition: MachOYAML.h:110
llvm::yaml::Hex64 offset
Definition: MachOYAML.h:157
llvm::yaml::Hex32 cputype
Definition: MachOYAML.h:155
llvm::yaml::Hex32 cpusubtype
Definition: MachOYAML.h:156
llvm::yaml::Hex32 reserved
Definition: MachOYAML.h:160
llvm::yaml::Hex32 magic
Definition: MachOYAML.h:150
llvm::yaml::Hex32 filetype
Definition: MachOYAML.h:66
llvm::yaml::Hex32 cpusubtype
Definition: MachOYAML.h:65
llvm::yaml::Hex32 cputype
Definition: MachOYAML.h:64
llvm::yaml::Hex32 flags
Definition: MachOYAML.h:69
llvm::yaml::Hex32 reserved
Definition: MachOYAML.h:70
llvm::yaml::Hex32 magic
Definition: MachOYAML.h:63
std::vector< MachOYAML::BindOpcode > WeakBindOpcodes
Definition: MachOYAML.h:126
std::vector< DataInCodeEntry > DataInCode
Definition: MachOYAML.h:133
std::vector< yaml::Hex8 > ChainedFixups
Definition: MachOYAML.h:134
std::vector< MachOYAML::BindOpcode > LazyBindOpcodes
Definition: MachOYAML.h:127
std::vector< MachOYAML::BindOpcode > BindOpcodes
Definition: MachOYAML.h:125
std::vector< MachOYAML::RebaseOpcode > RebaseOpcodes
Definition: MachOYAML.h:124
std::vector< StringRef > StringTable
Definition: MachOYAML.h:130
std::vector< yaml::Hex32 > IndirectSymbols
Definition: MachOYAML.h:131
std::vector< yaml::Hex64 > FunctionStarts
Definition: MachOYAML.h:132
MachOYAML::ExportEntry ExportTrie
Definition: MachOYAML.h:128
std::vector< NListEntry > NameList
Definition: MachOYAML.h:129
llvm::MachO::macho_load_command Data
Definition: MachOYAML.h:76
std::vector< Section > Sections
Definition: MachOYAML.h:77
std::vector< MachO::build_tool_version > Tools
Definition: MachOYAML.h:78
std::vector< llvm::yaml::Hex8 > PayloadBytes
Definition: MachOYAML.h:79
llvm::yaml::Hex8 n_type
Definition: MachOYAML.h:86
llvm::yaml::Hex32 address
Definition: MachOYAML.h:33
std::vector< Object > Slices
Definition: MachOYAML.h:166
std::vector< FatArch > FatArchs
Definition: MachOYAML.h:165
struct dylib dylib
Definition: MachO.h:627
uint32_t current_version
Definition: MachO.h:620
uint32_t name
Definition: MachO.h:618
uint32_t compatibility_version
Definition: MachO.h:621
uint32_t timestamp
Definition: MachO.h:619
struct fvmlib fvmlib
Definition: MachO.h:614
uint32_t header_addr
Definition: MachO.h:607
uint32_t name
Definition: MachO.h:605
uint32_t minor_version
Definition: MachO.h:606