LLVM: lib/ObjCopy/MachO/MachOWriter.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
17#include
18
19#if defined(__APPLE__)
20#include <sys/mman.h>
21#endif
22
23using namespace llvm;
26
27size_t MachOWriter::headerSize() const {
28 return Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
29}
30
31size_t MachOWriter::loadCommandsSize() const { return O.Header.SizeOfCmds; }
32
33size_t MachOWriter::symTableSize() const {
34 return O.SymTable.Symbols.size() *
35 (Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist));
36}
37
39
40
41
42
44 if (O.SymTabCommandIndex) {
46 O.LoadCommands[*O.SymTabCommandIndex]
47 .MachOLoadCommand.symtab_command_data;
48 if (SymTabCommand.symoff)
50 if (SymTabCommand.stroff)
52 }
53 if (O.DyLdInfoCommandIndex) {
55 O.LoadCommands[*O.DyLdInfoCommandIndex]
56 .MachOLoadCommand.dyld_info_command_data;
58 assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
59 "Incorrect rebase opcodes size");
61 }
62 if (DyLdInfoCommand.bind_off) {
63 assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
64 "Incorrect bind opcodes size");
66 }
69 "Incorrect weak bind opcodes size");
72 }
75 "Incorrect lazy bind opcodes size");
78 }
81 "Incorrect trie size");
83 }
84 }
85
86 if (O.DySymTabCommandIndex) {
88 O.LoadCommands[*O.DySymTabCommandIndex]
89 .MachOLoadCommand.dysymtab_command_data;
90
93 sizeof(uint32_t) * O.IndirectSymTable.Symbols.size());
94 }
95
96 for (std::optional<size_t> LinkEditDataCommandIndex :
97 {O.CodeSignatureCommandIndex, O.DylibCodeSignDRsIndex,
98 O.DataInCodeCommandIndex, O.LinkerOptimizationHintCommandIndex,
99 O.FunctionStartsCommandIndex, O.ChainedFixupsCommandIndex,
100 O.ExportsTrieCommandIndex})
101 if (LinkEditDataCommandIndex) {
103 O.LoadCommands[*LinkEditDataCommandIndex]
104 .MachOLoadCommand.linkedit_data_command_data;
105 if (LinkEditDataCommand.dataoff)
107 LinkEditDataCommand.datasize);
108 }
109
110
111 for (const LoadCommand &LC : O.LoadCommands)
112 for (const std::unique_ptr
113 if (!S->hasValidOffset()) {
114 assert((S->Offset == 0) && "Skipped section's offset must be zero");
115 assert((S->isBssSection() || S->Size == 0) &&
116 "Non-zero-fill sections with zero offset must have zero size");
117 continue;
118 }
119 assert((S->Offset != 0) &&
120 "Non-zero-fill section's offset cannot be zero");
121 Ends.push_back(S->Offset + S->Size);
122 if (S->RelOff)
125 }
126
127 if (!Ends.empty())
129
130
131 return headerSize() + loadCommandsSize();
132}
133
134void MachOWriter::writeHeader() {
136
145
148
149 auto HeaderSize =
151 memcpy(Buf->getBufferStart(), &Header, HeaderSize);
152}
153
154void MachOWriter::writeLoadCommands() {
156 reinterpret_cast<uint8_t *>(Buf->getBufferStart()) + headerSize();
158
160 switch (MLC.load_command_data.cmd) {
161 case MachO::LC_SEGMENT:
166
167 for (const std::unique_ptr
168 writeSectionInLoadCommandMachO::section(*Sec, Begin);
169 continue;
170 case MachO::LC_SEGMENT_64:
173 memcpy(Begin, &MLC.segment_command_64_data,
176
177 for (const std::unique_ptr
178 writeSectionInLoadCommandMachO::section\_64(*Sec, Begin);
179 continue;
180 }
181
182#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
183 case MachO::LCName: \
184 assert(sizeof(MachO::LCStruct) + LC.Payload.size() == \
185 MLC.load_command_data.cmdsize); \
186 if (IsLittleEndian != sys::IsLittleEndianHost) \
187 MachO::swapStruct(MLC.LCStruct##_data); \
188 memcpy(Begin, &MLC.LCStruct##_data, sizeof(MachO::LCStruct)); \
189 Begin += sizeof(MachO::LCStruct); \
190 if (!LC.Payload.empty()) \
191 memcpy(Begin, LC.Payload.data(), LC.Payload.size()); \
192 Begin += LC.Payload.size(); \
193 break;
194
195
196 switch (MLC.load_command_data.cmd) {
197 default:
199 MLC.load_command_data.cmdsize);
206 Begin += LC.Payload.size();
207 break;
208#include "llvm/BinaryFormat/MachO.def"
209 }
210 }
211}
212
213template
214void MachOWriter::writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out) {
215 StructType Temp;
216 assert(Sec.Segname.size() <= sizeof(Temp.segname) && "too long segment name");
217 assert(Sec.Sectname.size() <= sizeof(Temp.sectname) &&
218 "too long section name");
219 memset(&Temp, 0, sizeof(StructType));
220 memcpy(Temp.segname, Sec.Segname.data(), Sec.Segname.size());
221 memcpy(Temp.sectname, Sec.Sectname.data(), Sec.Sectname.size());
222 Temp.addr = Sec.Addr;
223 Temp.size = Sec.Size;
224 Temp.offset = Sec.Offset;
225 Temp.align = Sec.Align;
226 Temp.reloff = Sec.RelOff;
227 Temp.nreloc = Sec.NReloc;
228 Temp.flags = Sec.Flags;
231
234 memcpy(Out, &Temp, sizeof(StructType));
235 Out += sizeof(StructType);
236}
237
238void MachOWriter::writeSections() {
239 for (const LoadCommand &LC : O.LoadCommands)
240 for (const std::unique_ptr
241 if (!Sec->hasValidOffset()) {
242 assert((Sec->Offset == 0) && "Skipped section's offset must be zero");
243 assert((Sec->isBssSection() || Sec->Size == 0) &&
244 "Non-zero-fill sections with zero offset must have zero size");
245 continue;
246 }
247
248 assert(Sec->Offset && "Section offset can not be zero");
249 assert((Sec->Size == Sec->Content.size()) && "Incorrect section size");
250 memcpy(Buf->getBufferStart() + Sec->Offset, Sec->Content.data(),
251 Sec->Content.size());
252 for (size_t Index = 0; Index < Sec->Relocations.size(); ++Index) {
253 RelocationInfo RelocInfo = Sec->Relocations[Index];
255 const uint32_t SymbolNum = RelocInfo.Extern
256 ? (*RelocInfo.Symbol)->Index
257 : (*RelocInfo.Sec)->Index;
259 }
262 reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));
263 memcpy(Buf->getBufferStart() + Sec->RelOff +
264 Index * sizeof(MachO::any_relocation_info),
265 &RelocInfo.Info, sizeof(RelocInfo.Info));
266 }
267 }
268}
269
270template
273 NListType ListEntry;
274 ListEntry.n_strx = Nstrx;
275 ListEntry.n_type = SE.n_type;
276 ListEntry.n_sect = SE.n_sect;
277 ListEntry.n_desc = SE.n_desc;
278 ListEntry.n_value = SE.n_value;
279
282 memcpy(Out, reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
283 Out += sizeof(NListType);
284}
285
286void MachOWriter::writeStringTable() {
287 if (!O.SymTabCommandIndex)
288 return;
289 const MachO::symtab_command &SymTabCommand =
290 O.LoadCommands[*O.SymTabCommandIndex]
291 .MachOLoadCommand.symtab_command_data;
292
293 uint8_t *StrTable = (uint8_t *)Buf->getBufferStart() + SymTabCommand.stroff;
294 LayoutBuilder.getStringTableBuilder().write(StrTable);
295}
296
297void MachOWriter::writeSymbolTable() {
298 if (!O.SymTabCommandIndex)
299 return;
300 const MachO::symtab_command &SymTabCommand =
301 O.LoadCommands[*O.SymTabCommandIndex]
302 .MachOLoadCommand.symtab_command_data;
303
304 char *SymTable = Buf->getBufferStart() + SymTabCommand.symoff;
305 for (auto &Symbol : O.SymTable.Symbols) {
306 SymbolEntry *Sym = Symbol.get();
307 uint32_t Nstrx = LayoutBuilder.getStringTableBuilder().getOffset(Sym->Name);
308
309 if (Is64Bit)
311 else
313 }
314}
315
316void MachOWriter::writeRebaseInfo() {
317 if (!O.DyLdInfoCommandIndex)
318 return;
319 const MachO::dyld_info_command &DyLdInfoCommand =
320 O.LoadCommands[*O.DyLdInfoCommandIndex]
321 .MachOLoadCommand.dyld_info_command_data;
322 char *Out = Buf->getBufferStart() + DyLdInfoCommand.rebase_off;
323 assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
324 "Incorrect rebase opcodes size");
325 memcpy(Out, O.Rebases.Opcodes.data(), O.Rebases.Opcodes.size());
326}
327
328void MachOWriter::writeBindInfo() {
329 if (!O.DyLdInfoCommandIndex)
330 return;
331 const MachO::dyld_info_command &DyLdInfoCommand =
332 O.LoadCommands[*O.DyLdInfoCommandIndex]
333 .MachOLoadCommand.dyld_info_command_data;
334 char *Out = Buf->getBufferStart() + DyLdInfoCommand.bind_off;
335 assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
336 "Incorrect bind opcodes size");
337 memcpy(Out, O.Binds.Opcodes.data(), O.Binds.Opcodes.size());
338}
339
340void MachOWriter::writeWeakBindInfo() {
341 if (!O.DyLdInfoCommandIndex)
342 return;
343 const MachO::dyld_info_command &DyLdInfoCommand =
344 O.LoadCommands[*O.DyLdInfoCommandIndex]
345 .MachOLoadCommand.dyld_info_command_data;
346 char *Out = Buf->getBufferStart() + DyLdInfoCommand.weak_bind_off;
348 "Incorrect weak bind opcodes size");
349 memcpy(Out, O.WeakBinds.Opcodes.data(), O.WeakBinds.Opcodes.size());
350}
351
352void MachOWriter::writeLazyBindInfo() {
353 if (!O.DyLdInfoCommandIndex)
354 return;
355 const MachO::dyld_info_command &DyLdInfoCommand =
356 O.LoadCommands[*O.DyLdInfoCommandIndex]
357 .MachOLoadCommand.dyld_info_command_data;
358 char *Out = Buf->getBufferStart() + DyLdInfoCommand.lazy_bind_off;
360 "Incorrect lazy bind opcodes size");
361 memcpy(Out, O.LazyBinds.Opcodes.data(), O.LazyBinds.Opcodes.size());
362}
363
364void MachOWriter::writeExportInfo() {
365 if (!O.DyLdInfoCommandIndex)
366 return;
367 const MachO::dyld_info_command &DyLdInfoCommand =
368 O.LoadCommands[*O.DyLdInfoCommandIndex]
369 .MachOLoadCommand.dyld_info_command_data;
370 char *Out = Buf->getBufferStart() + DyLdInfoCommand.export_off;
372 "Incorrect export trie size");
373 memcpy(Out, O.Exports.Trie.data(), O.Exports.Trie.size());
374}
375
376void MachOWriter::writeIndirectSymbolTable() {
377 if (!O.DySymTabCommandIndex)
378 return;
379
380 const MachO::dysymtab_command &DySymTabCommand =
381 O.LoadCommands[*O.DySymTabCommandIndex]
382 .MachOLoadCommand.dysymtab_command_data;
383
384 uint32_t *Out =
385 (uint32_t *)(Buf->getBufferStart() + DySymTabCommand.indirectsymoff);
386 for (const IndirectSymbolEntry &Sym : O.IndirectSymTable.Symbols) {
391 }
392}
393
394void MachOWriter::writeLinkData(std::optional<size_t> LCIndex,
396 if (!LCIndex)
397 return;
398 const MachO::linkedit_data_command &LinkEditDataCommand =
399 O.LoadCommands[*LCIndex].MachOLoadCommand.linkedit_data_command_data;
400 char *Out = Buf->getBufferStart() + LinkEditDataCommand.dataoff;
402 "Incorrect data size");
403 memcpy(Out, LD.Data.data(), LD.Data.size());
404}
405
406static uint64_t
410 switch (MLC.load_command_data.cmd) {
411 case MachO::LC_SEGMENT:
412 return MLC.segment_command_data.fileoff;
413 case MachO::LC_SEGMENT_64:
414 return MLC.segment_command_64_data.fileoff;
415 default:
416 return 0;
417 }
418}
419
423 switch (MLC.load_command_data.cmd) {
424 case MachO::LC_SEGMENT:
425 return MLC.segment_command_data.filesize;
426 case MachO::LC_SEGMENT_64:
427 return MLC.segment_command_64_data.filesize;
428 default:
429 return 0;
430 }
431}
432
433void MachOWriter::writeCodeSignatureData() {
434
435
436
437
438
439
440
441
442
443
444
445
446
447 const CodeSignatureInfo &CodeSignature = LayoutBuilder.getCodeSignature();
448
449 uint8_t *BufferStart = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
450 uint8_t *HashReadStart = BufferStart;
451 uint8_t *HashReadEnd = BufferStart + CodeSignature.StartOffset;
452
453
454
455 uint8_t *HashWriteStart = HashReadEnd + CodeSignature.AllHeadersSize;
456
457 uint32_t TextSegmentFileOff = 0;
458 uint32_t TextSegmentFileSize = 0;
459 if (O.TextSegmentCommandIndex) {
460 const LoadCommand &TextSegmentLoadCommand =
461 O.LoadCommands[*O.TextSegmentCommandIndex];
463 MachO::LC_SEGMENT ||
464 TextSegmentLoadCommand.MachOLoadCommand.load_command_data.cmd ==
465 MachO::LC_SEGMENT_64);
467 .segment_command_data.segname) == "__TEXT");
470 }
471
472 const uint32_t FileNamePad = CodeSignature.AllHeadersSize -
475
476
477 auto *SuperBlob = reinterpret_cast<MachO::CS_SuperBlob *>(HashReadEnd);
479 write32be(&SuperBlob->length, CodeSignature.Size);
481 auto *BlobIndex = reinterpret_cast<MachO::CS_BlobIndex *>(&SuperBlob[1]);
484 auto *CodeDirectory = reinterpret_cast<MachO::CS_CodeDirectory *>(
487 write32be(&CodeDirectory->length,
491 write32be(&CodeDirectory->hashOffset,
492 sizeof(MachO::CS_CodeDirectory) +
494 write32be(&CodeDirectory->identOffset, sizeof(MachO::CS_CodeDirectory));
495 CodeDirectory->nSpecialSlots = 0;
498 CodeDirectory->hashSize = static_cast<uint8_t>(CodeSignature.HashSize);
500 CodeDirectory->platform = 0;
501 CodeDirectory->pageSize = CodeSignature.BlockSizeShift;
502 CodeDirectory->spare2 = 0;
503 CodeDirectory->scatterOffset = 0;
504 CodeDirectory->teamOffset = 0;
505 CodeDirectory->spare3 = 0;
506 CodeDirectory->codeLimit64 = 0;
507 write64be(&CodeDirectory->execSegBase, TextSegmentFileOff);
508 write64be(&CodeDirectory->execSegLimit, TextSegmentFileSize);
511 : 0);
512
513 auto *Id = reinterpret_cast<char *>(&CodeDirectory[1]);
517
518
519 uint8_t *CurrHashReadPosition = HashReadStart;
520 uint8_t *CurrHashWritePosition = HashWriteStart;
521 while (CurrHashReadPosition < HashReadEnd) {
522 StringRef Block(reinterpret_cast<char *>(CurrHashReadPosition),
523 std::min(static_cast<size_t>(HashReadEnd
524 - CurrHashReadPosition),
525 static_cast<size_t>(CodeSignature.BlockSize)));
528 std::array<uint8_t, 32> Hash = Hasher.final();
530 memcpy(CurrHashWritePosition, Hash.data(), CodeSignature.HashSize);
531 CurrHashReadPosition += CodeSignature.BlockSize;
532 CurrHashWritePosition += CodeSignature.HashSize;
533 }
534#if defined(__APPLE__)
535
536
537
538
539
540
541
542
543
544
545 msync(BufferStart, CodeSignature.StartOffset + CodeSignature.Size,
546 MS_INVALIDATE);
547#endif
548}
549
550void MachOWriter::writeDataInCodeData() {
551 return writeLinkData(O.DataInCodeCommandIndex, O.DataInCode);
552}
553
554void MachOWriter::writeLinkerOptimizationHint() {
555 return writeLinkData(O.LinkerOptimizationHintCommandIndex,
556 O.LinkerOptimizationHint);
557}
558
559void MachOWriter::writeFunctionStartsData() {
560 return writeLinkData(O.FunctionStartsCommandIndex, O.FunctionStarts);
561}
562
563void MachOWriter::writeDylibCodeSignDRsData() {
564 return writeLinkData(O.DylibCodeSignDRsIndex, O.DylibCodeSignDRs);
565}
566
567void MachOWriter::writeChainedFixupsData() {
568 return writeLinkData(O.ChainedFixupsCommandIndex, O.ChainedFixups);
569}
570
571void MachOWriter::writeExportsTrieData() {
572 if (!O.ExportsTrieCommandIndex)
573 return;
574 const MachO::linkedit_data_command &ExportsTrieCmd =
575 O.LoadCommands[*O.ExportsTrieCommandIndex]
576 .MachOLoadCommand.linkedit_data_command_data;
577 char *Out = Buf->getBufferStart() + ExportsTrieCmd.dataoff;
578 assert((ExportsTrieCmd.datasize == O.Exports.Trie.size()) &&
579 "Incorrect export trie size");
580 memcpy(Out, O.Exports.Trie.data(), O.Exports.Trie.size());
581}
582
583void MachOWriter::writeTail() {
584 typedef void (MachOWriter::*WriteHandlerType)();
585 typedef std::pair<uint64_t, WriteHandlerType> WriteOperation;
587
588 if (O.SymTabCommandIndex) {
589 const MachO::symtab_command &SymTabCommand =
590 O.LoadCommands[*O.SymTabCommandIndex]
591 .MachOLoadCommand.symtab_command_data;
592 if (SymTabCommand.symoff)
593 Queue.push_back({SymTabCommand.symoff, &MachOWriter::writeSymbolTable});
594 if (SymTabCommand.stroff)
595 Queue.push_back({SymTabCommand.stroff, &MachOWriter::writeStringTable});
596 }
597
598 if (O.DyLdInfoCommandIndex) {
599 const MachO::dyld_info_command &DyLdInfoCommand =
600 O.LoadCommands[*O.DyLdInfoCommandIndex]
601 .MachOLoadCommand.dyld_info_command_data;
604 {DyLdInfoCommand.rebase_off, &MachOWriter::writeRebaseInfo});
605 if (DyLdInfoCommand.bind_off)
606 Queue.push_back({DyLdInfoCommand.bind_off, &MachOWriter::writeBindInfo});
609 {DyLdInfoCommand.weak_bind_off, &MachOWriter::writeWeakBindInfo});
612 {DyLdInfoCommand.lazy_bind_off, &MachOWriter::writeLazyBindInfo});
615 {DyLdInfoCommand.export_off, &MachOWriter::writeExportInfo});
616 }
617
618 if (O.DySymTabCommandIndex) {
619 const MachO::dysymtab_command &DySymTabCommand =
620 O.LoadCommands[*O.DySymTabCommandIndex]
621 .MachOLoadCommand.dysymtab_command_data;
622
625 &MachOWriter::writeIndirectSymbolTable);
626 }
627
628 std::initializer_list<std::pair<std::optional<size_t>, WriteHandlerType>>
629 LinkEditDataCommandWriters = {
630 {O.CodeSignatureCommandIndex, &MachOWriter::writeCodeSignatureData},
631 {O.DylibCodeSignDRsIndex, &MachOWriter::writeDylibCodeSignDRsData},
632 {O.DataInCodeCommandIndex, &MachOWriter::writeDataInCodeData},
633 {O.LinkerOptimizationHintCommandIndex,
634 &MachOWriter::writeLinkerOptimizationHint},
635 {O.FunctionStartsCommandIndex, &MachOWriter::writeFunctionStartsData},
636 {O.ChainedFixupsCommandIndex, &MachOWriter::writeChainedFixupsData},
637 {O.ExportsTrieCommandIndex, &MachOWriter::writeExportsTrieData}};
638 for (const auto &W : LinkEditDataCommandWriters) {
639 std::optional<size_t> LinkEditDataCommandIndex;
640 WriteHandlerType WriteHandler;
641 std::tie(LinkEditDataCommandIndex, WriteHandler) = W;
642 if (LinkEditDataCommandIndex) {
643 const MachO::linkedit_data_command &LinkEditDataCommand =
644 O.LoadCommands[*LinkEditDataCommandIndex]
645 .MachOLoadCommand.linkedit_data_command_data;
646 if (LinkEditDataCommand.dataoff)
647 Queue.emplace_back(LinkEditDataCommand.dataoff, WriteHandler);
648 }
649 }
650
651 llvm::sort(Queue, llvm::less_first());
652
653 for (auto WriteOp : Queue)
654 (this->*WriteOp.second)();
655}
656
658
662 if (!Buf)
664 "failed to allocate memory buffer of " +
666 writeHeader();
667 writeLoadCommands();
668 writeSections();
669 writeTail();
670
671
672
673 Out.write(Buf->getBufferStart(), Buf->getBufferSize());
675}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static uint64_t getSegmentFileOffset(const LoadCommand &TextSegmentLoadCommand)
Definition MachOWriter.cpp:407
static uint64_t getSegmentFileSize(const LoadCommand &TextSegmentLoadCommand)
Definition MachOWriter.cpp:420
void writeNListEntry(const SymbolEntry &SE, bool IsLittleEndian, char *&Out, uint32_t Nstrx)
Definition MachOWriter.cpp:271
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
LLVM_ABI std::array< uint8_t, 32 > final()
Return the current raw 256-bits SHA256 for the digested data since the last call to init().
LLVM_ABI void update(ArrayRef< uint8_t > Data)
Digest more data.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
constexpr size_t size() const
size - Get the string size.
static Twine utohexstr(uint64_t Val)
static LLVM_ABI std::unique_ptr< WritableMemoryBuffer > getNewMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new zero-initialized MemoryBuffer of the specified size.
Error finalize()
Definition MachOWriter.cpp:657
Error write()
Definition MachOWriter.cpp:659
MachOWriter(Object &O, bool Is64Bit, bool IsLittleEndian, StringRef OutputFileName, uint64_t PageSize, raw_ostream &Out)
size_t totalSize() const
Definition MachOWriter.cpp:38
@ CSMAGIC_EMBEDDED_SIGNATURE
@ kSecCodeSignatureHashSHA256
void swapStruct(fat_header &mh)
void write32be(void *P, uint32_t V)
void write64be(void *P, uint64_t V)
constexpr bool IsLittleEndianHost
void swapByteOrder(T &Value)
This is an optimization pass for GlobalISel generic memory operations.
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
void sort(IteratorTy Start, IteratorTy End)
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
auto max_element(R &&Range)
Provide wrappers to std::max_element which take ranges instead of having to pass begin/end explicitly...
static constexpr size_t BlobHeadersSize
static constexpr size_t HashSize
static constexpr uint32_t FixedHeadersSize
static constexpr uint8_t BlockSizeShift
static constexpr size_t BlockSize
std::optional< SymbolEntry * > Symbol
The Symbol referenced by this entry.
MachO::macho_load_command MachOLoadCommand
std::vector< std::unique_ptr< Section > > Sections
std::vector< uint8_t > Payload
std::vector< LoadCommand > LoadCommands
MachO::any_relocation_info Info
std::optional< const SymbolEntry * > Symbol
void setPlainRelocationSymbolNum(unsigned SymbolNum, bool IsLittleEndian)