1//===- MachOWriter.cpp ------------------------------------------*- 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#include "MachOWriter.h"
10#include "MachOLayoutBuilder.h"
11#include "MachOObject.h"
12#include "llvm/ADT/STLExtras.h"
13#include "llvm/BinaryFormat/MachO.h"
14#include "llvm/Object/MachO.h"
15#include "llvm/Support/Errc.h"
16#include "llvm/Support/ErrorHandling.h"
17#include "llvm/Support/SHA256.h"
18#include <memory>
19
20#if defined(__APPLE__)
21#include <sys/mman.h>
22#endif
23
24using namespace llvm;
25using namespace llvm::objcopy::macho;
26using namespace llvm::support::endian;
27
28size_t MachOWriter::headerSize() const {
29 return Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
30}
31
32size_t MachOWriter::loadCommandsSize() const { return O.Header.SizeOfCmds; }
33
34size_t MachOWriter::symTableSize() const {
35 return O.SymTable.Symbols.size() *
36 (Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist));
37}
38
39size_t MachOWriter::totalSize() const {
40 // Going from tail to head and looking for an appropriate "anchor" to
41 // calculate the total size assuming that all the offsets are either valid
42 // ("true") or 0 (0 indicates that the corresponding part is missing).
43
44 SmallVector<size_t, 7> Ends;
45 if (O.SymTabCommandIndex) {
46 const MachO::symtab_command &SymTabCommand =
47 O.LoadCommands[*O.SymTabCommandIndex]
48 .MachOLoadCommand.symtab_command_data;
49 if (SymTabCommand.symoff)
50 Ends.push_back(Elt: SymTabCommand.symoff + symTableSize());
51 if (SymTabCommand.stroff)
52 Ends.push_back(Elt: SymTabCommand.stroff + SymTabCommand.strsize);
53 }
54 if (O.DyLdInfoCommandIndex) {
55 const MachO::dyld_info_command &DyLdInfoCommand =
56 O.LoadCommands[*O.DyLdInfoCommandIndex]
57 .MachOLoadCommand.dyld_info_command_data;
58 if (DyLdInfoCommand.rebase_off) {
59 assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
60 "Incorrect rebase opcodes size");
61 Ends.push_back(Elt: DyLdInfoCommand.rebase_off + DyLdInfoCommand.rebase_size);
62 }
63 if (DyLdInfoCommand.bind_off) {
64 assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
65 "Incorrect bind opcodes size");
66 Ends.push_back(Elt: DyLdInfoCommand.bind_off + DyLdInfoCommand.bind_size);
67 }
68 if (DyLdInfoCommand.weak_bind_off) {
69 assert((DyLdInfoCommand.weak_bind_size == O.WeakBinds.Opcodes.size()) &&
70 "Incorrect weak bind opcodes size");
71 Ends.push_back(Elt: DyLdInfoCommand.weak_bind_off +
72 DyLdInfoCommand.weak_bind_size);
73 }
74 if (DyLdInfoCommand.lazy_bind_off) {
75 assert((DyLdInfoCommand.lazy_bind_size == O.LazyBinds.Opcodes.size()) &&
76 "Incorrect lazy bind opcodes size");
77 Ends.push_back(Elt: DyLdInfoCommand.lazy_bind_off +
78 DyLdInfoCommand.lazy_bind_size);
79 }
80 if (DyLdInfoCommand.export_off) {
81 assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
82 "Incorrect trie size");
83 Ends.push_back(Elt: DyLdInfoCommand.export_off + DyLdInfoCommand.export_size);
84 }
85 }
86
87 if (O.DySymTabCommandIndex) {
88 const MachO::dysymtab_command &DySymTabCommand =
89 O.LoadCommands[*O.DySymTabCommandIndex]
90 .MachOLoadCommand.dysymtab_command_data;
91
92 if (DySymTabCommand.indirectsymoff)
93 Ends.push_back(Elt: DySymTabCommand.indirectsymoff +
94 sizeof(uint32_t) * O.IndirectSymTable.Symbols.size());
95 }
96
97 for (std::optional<size_t> LinkEditDataCommandIndex :
98 {O.CodeSignatureCommandIndex, O.DylibCodeSignDRsIndex,
99 O.DataInCodeCommandIndex, O.LinkerOptimizationHintCommandIndex,
100 O.FunctionStartsCommandIndex, O.ChainedFixupsCommandIndex,
101 O.ExportsTrieCommandIndex})
102 if (LinkEditDataCommandIndex) {
103 const MachO::linkedit_data_command &LinkEditDataCommand =
104 O.LoadCommands[*LinkEditDataCommandIndex]
105 .MachOLoadCommand.linkedit_data_command_data;
106 if (LinkEditDataCommand.dataoff)
107 Ends.push_back(Elt: LinkEditDataCommand.dataoff +
108 LinkEditDataCommand.datasize);
109 }
110
111 // Otherwise, use the last section / reloction.
112 for (const LoadCommand &LC : O.LoadCommands)
113 for (const std::unique_ptr<Section> &S : LC.Sections) {
114 if (!S->hasValidOffset()) {
115 assert((S->Offset == 0) && "Skipped section's offset must be zero");
116 assert((S->isVirtualSection() || S->Size == 0) &&
117 "Non-zero-fill sections with zero offset must have zero size");
118 continue;
119 }
120 assert((S->Offset != 0) &&
121 "Non-zero-fill section's offset cannot be zero");
122 Ends.push_back(Elt: S->Offset + S->Size);
123 if (S->RelOff)
124 Ends.push_back(Elt: S->RelOff +
125 S->NReloc * sizeof(MachO::any_relocation_info));
126 }
127
128 if (!Ends.empty())
129 return *llvm::max_element(Range&: Ends);
130
131 // Otherwise, we have only Mach header and load commands.
132 return headerSize() + loadCommandsSize();
133}
134
135void MachOWriter::writeHeader() {
136 MachO::mach_header_64 Header;
137
138 Header.magic = O.Header.Magic;
139 Header.cputype = O.Header.CPUType;
140 Header.cpusubtype = O.Header.CPUSubType;
141 Header.filetype = O.Header.FileType;
142 Header.ncmds = O.Header.NCmds;
143 Header.sizeofcmds = O.Header.SizeOfCmds;
144 Header.flags = O.Header.Flags;
145 Header.reserved = O.Header.Reserved;
146
147 if (IsLittleEndian != sys::IsLittleEndianHost)
148 MachO::swapStruct(H&: Header);
149
150 auto HeaderSize =
151 Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
152 memcpy(dest: Buf->getBufferStart(), src: &Header, n: HeaderSize);
153}
154
155void MachOWriter::writeLoadCommands() {
156 uint8_t *Begin =
157 reinterpret_cast<uint8_t *>(Buf->getBufferStart()) + headerSize();
158 for (const LoadCommand &LC : O.LoadCommands) {
159 // Construct a load command.
160 MachO::macho_load_command MLC = LC.MachOLoadCommand;
161 switch (MLC.load_command_data.cmd) {
162 case MachO::LC_SEGMENT:
163 if (IsLittleEndian != sys::IsLittleEndianHost)
164 MachO::swapStruct(seg&: MLC.segment_command_data);
165 memcpy(dest: Begin, src: &MLC.segment_command_data, n: sizeof(MachO::segment_command));
166 Begin += sizeof(MachO::segment_command);
167
168 for (const std::unique_ptr<Section> &Sec : LC.Sections)
169 writeSectionInLoadCommand<MachO::section>(Sec: *Sec, Out&: Begin);
170 continue;
171 case MachO::LC_SEGMENT_64:
172 if (IsLittleEndian != sys::IsLittleEndianHost)
173 MachO::swapStruct(seg&: MLC.segment_command_64_data);
174 memcpy(dest: Begin, src: &MLC.segment_command_64_data,
175 n: sizeof(MachO::segment_command_64));
176 Begin += sizeof(MachO::segment_command_64);
177
178 for (const std::unique_ptr<Section> &Sec : LC.Sections)
179 writeSectionInLoadCommand<MachO::section_64>(Sec: *Sec, Out&: Begin);
180 continue;
181 }
182
183#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
184 case MachO::LCName: \
185 assert(sizeof(MachO::LCStruct) + LC.Payload.size() == \
186 MLC.load_command_data.cmdsize); \
187 if (IsLittleEndian != sys::IsLittleEndianHost) \
188 MachO::swapStruct(MLC.LCStruct##_data); \
189 memcpy(Begin, &MLC.LCStruct##_data, sizeof(MachO::LCStruct)); \
190 Begin += sizeof(MachO::LCStruct); \
191 if (!LC.Payload.empty()) \
192 memcpy(Begin, LC.Payload.data(), LC.Payload.size()); \
193 Begin += LC.Payload.size(); \
194 break;
195
196 // Copy the load command as it is.
197 switch (MLC.load_command_data.cmd) {
198 default:
199 assert(sizeof(MachO::load_command) + LC.Payload.size() ==
200 MLC.load_command_data.cmdsize);
201 if (IsLittleEndian != sys::IsLittleEndianHost)
202 MachO::swapStruct(lc&: MLC.load_command_data);
203 memcpy(dest: Begin, src: &MLC.load_command_data, n: sizeof(MachO::load_command));
204 Begin += sizeof(MachO::load_command);
205 if (!LC.Payload.empty())
206 memcpy(dest: Begin, src: LC.Payload.data(), n: LC.Payload.size());
207 Begin += LC.Payload.size();
208 break;
209#include "llvm/BinaryFormat/MachO.def"
210 }
211 }
212}
213
214template <typename StructType>
215void MachOWriter::writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out) {
216 StructType Temp;
217 assert(Sec.Segname.size() <= sizeof(Temp.segname) && "too long segment name");
218 assert(Sec.Sectname.size() <= sizeof(Temp.sectname) &&
219 "too long section name");
220 memset(&Temp, 0, sizeof(StructType));
221 memcpy(Temp.segname, Sec.Segname.data(), Sec.Segname.size());
222 memcpy(Temp.sectname, Sec.Sectname.data(), Sec.Sectname.size());
223 Temp.addr = Sec.Addr;
224 Temp.size = Sec.Size;
225 Temp.offset = Sec.Offset;
226 Temp.align = Sec.Align;
227 Temp.reloff = Sec.RelOff;
228 Temp.nreloc = Sec.NReloc;
229 Temp.flags = Sec.Flags;
230 Temp.reserved1 = Sec.Reserved1;
231 Temp.reserved2 = Sec.Reserved2;
232
233 if (IsLittleEndian != sys::IsLittleEndianHost)
234 MachO::swapStruct(Temp);
235 memcpy(Out, &Temp, sizeof(StructType));
236 Out += sizeof(StructType);
237}
238
239void MachOWriter::writeSections() {
240 for (const LoadCommand &LC : O.LoadCommands)
241 for (const std::unique_ptr<Section> &Sec : LC.Sections) {
242 if (!Sec->hasValidOffset()) {
243 assert((Sec->Offset == 0) && "Skipped section's offset must be zero");
244 assert((Sec->isVirtualSection() || Sec->Size == 0) &&
245 "Non-zero-fill sections with zero offset must have zero size");
246 continue;
247 }
248
249 assert(Sec->Offset && "Section offset can not be zero");
250 assert((Sec->Size == Sec->Content.size()) && "Incorrect section size");
251 memcpy(dest: Buf->getBufferStart() + Sec->Offset, src: Sec->Content.data(),
252 n: Sec->Content.size());
253 for (size_t Index = 0; Index < Sec->Relocations.size(); ++Index) {
254 RelocationInfo RelocInfo = Sec->Relocations[Index];
255 if (!RelocInfo.Scattered && !RelocInfo.IsAddend) {
256 const uint32_t SymbolNum = RelocInfo.Extern
257 ? (*RelocInfo.Symbol)->Index
258 : (*RelocInfo.Sec)->Index;
259 RelocInfo.setPlainRelocationSymbolNum(SymbolNum, IsLittleEndian);
260 }
261 if (IsLittleEndian != sys::IsLittleEndianHost)
262 MachO::swapStruct(
263 reloc&: reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));
264 memcpy(dest: Buf->getBufferStart() + Sec->RelOff +
265 Index * sizeof(MachO::any_relocation_info),
266 src: &RelocInfo.Info, n: sizeof(RelocInfo.Info));
267 }
268 }
269}
270
271template <typename NListType>
272void writeNListEntry(const SymbolEntry &SE, bool IsLittleEndian, char *&Out,
273 uint32_t Nstrx) {
274 NListType ListEntry;
275 ListEntry.n_strx = Nstrx;
276 ListEntry.n_type = SE.n_type;
277 ListEntry.n_sect = SE.n_sect;
278 ListEntry.n_desc = SE.n_desc;
279 ListEntry.n_value = SE.n_value;
280
281 if (IsLittleEndian != sys::IsLittleEndianHost)
282 MachO::swapStruct(ListEntry);
283 memcpy(dest: Out, src: reinterpret_cast<const char *>(&ListEntry), n: sizeof(NListType));
284 Out += sizeof(NListType);
285}
286
287void MachOWriter::writeStringTable() {
288 if (!O.SymTabCommandIndex)
289 return;
290 const MachO::symtab_command &SymTabCommand =
291 O.LoadCommands[*O.SymTabCommandIndex]
292 .MachOLoadCommand.symtab_command_data;
293
294 uint8_t *StrTable = (uint8_t *)Buf->getBufferStart() + SymTabCommand.stroff;
295 LayoutBuilder.getStringTableBuilder().write(Buf: StrTable);
296}
297
298void MachOWriter::writeSymbolTable() {
299 if (!O.SymTabCommandIndex)
300 return;
301 const MachO::symtab_command &SymTabCommand =
302 O.LoadCommands[*O.SymTabCommandIndex]
303 .MachOLoadCommand.symtab_command_data;
304
305 char *SymTable = (char *)Buf->getBufferStart() + SymTabCommand.symoff;
306 for (auto &Symbol : O.SymTable.Symbols) {
307 SymbolEntry *Sym = Symbol.get();
308 uint32_t Nstrx = LayoutBuilder.getStringTableBuilder().getOffset(S: Sym->Name);
309
310 if (Is64Bit)
311 writeNListEntry<MachO::nlist_64>(SE: *Sym, IsLittleEndian, Out&: SymTable, Nstrx);
312 else
313 writeNListEntry<MachO::nlist>(SE: *Sym, IsLittleEndian, Out&: SymTable, Nstrx);
314 }
315}
316
317void MachOWriter::writeRebaseInfo() {
318 if (!O.DyLdInfoCommandIndex)
319 return;
320 const MachO::dyld_info_command &DyLdInfoCommand =
321 O.LoadCommands[*O.DyLdInfoCommandIndex]
322 .MachOLoadCommand.dyld_info_command_data;
323 char *Out = (char *)Buf->getBufferStart() + DyLdInfoCommand.rebase_off;
324 assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
325 "Incorrect rebase opcodes size");
326 memcpy(dest: Out, src: O.Rebases.Opcodes.data(), n: O.Rebases.Opcodes.size());
327}
328
329void MachOWriter::writeBindInfo() {
330 if (!O.DyLdInfoCommandIndex)
331 return;
332 const MachO::dyld_info_command &DyLdInfoCommand =
333 O.LoadCommands[*O.DyLdInfoCommandIndex]
334 .MachOLoadCommand.dyld_info_command_data;
335 char *Out = (char *)Buf->getBufferStart() + DyLdInfoCommand.bind_off;
336 assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
337 "Incorrect bind opcodes size");
338 memcpy(dest: Out, src: O.Binds.Opcodes.data(), n: O.Binds.Opcodes.size());
339}
340
341void MachOWriter::writeWeakBindInfo() {
342 if (!O.DyLdInfoCommandIndex)
343 return;
344 const MachO::dyld_info_command &DyLdInfoCommand =
345 O.LoadCommands[*O.DyLdInfoCommandIndex]
346 .MachOLoadCommand.dyld_info_command_data;
347 char *Out = (char *)Buf->getBufferStart() + DyLdInfoCommand.weak_bind_off;
348 assert((DyLdInfoCommand.weak_bind_size == O.WeakBinds.Opcodes.size()) &&
349 "Incorrect weak bind opcodes size");
350 memcpy(dest: Out, src: O.WeakBinds.Opcodes.data(), n: O.WeakBinds.Opcodes.size());
351}
352
353void MachOWriter::writeLazyBindInfo() {
354 if (!O.DyLdInfoCommandIndex)
355 return;
356 const MachO::dyld_info_command &DyLdInfoCommand =
357 O.LoadCommands[*O.DyLdInfoCommandIndex]
358 .MachOLoadCommand.dyld_info_command_data;
359 char *Out = (char *)Buf->getBufferStart() + DyLdInfoCommand.lazy_bind_off;
360 assert((DyLdInfoCommand.lazy_bind_size == O.LazyBinds.Opcodes.size()) &&
361 "Incorrect lazy bind opcodes size");
362 memcpy(dest: Out, src: O.LazyBinds.Opcodes.data(), n: O.LazyBinds.Opcodes.size());
363}
364
365void MachOWriter::writeExportInfo() {
366 if (!O.DyLdInfoCommandIndex)
367 return;
368 const MachO::dyld_info_command &DyLdInfoCommand =
369 O.LoadCommands[*O.DyLdInfoCommandIndex]
370 .MachOLoadCommand.dyld_info_command_data;
371 char *Out = (char *)Buf->getBufferStart() + DyLdInfoCommand.export_off;
372 assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
373 "Incorrect export trie size");
374 memcpy(dest: Out, src: O.Exports.Trie.data(), n: O.Exports.Trie.size());
375}
376
377void MachOWriter::writeIndirectSymbolTable() {
378 if (!O.DySymTabCommandIndex)
379 return;
380
381 const MachO::dysymtab_command &DySymTabCommand =
382 O.LoadCommands[*O.DySymTabCommandIndex]
383 .MachOLoadCommand.dysymtab_command_data;
384
385 uint32_t *Out =
386 (uint32_t *)(Buf->getBufferStart() + DySymTabCommand.indirectsymoff);
387 for (const IndirectSymbolEntry &Sym : O.IndirectSymTable.Symbols) {
388 uint32_t Entry = (Sym.Symbol) ? (*Sym.Symbol)->Index : Sym.OriginalIndex;
389 if (IsLittleEndian != sys::IsLittleEndianHost)
390 sys::swapByteOrder(Value&: Entry);
391 *Out++ = Entry;
392 }
393}
394
395void MachOWriter::writeLinkData(std::optional<size_t> LCIndex,
396 const LinkData &LD) {
397 if (!LCIndex)
398 return;
399 const MachO::linkedit_data_command &LinkEditDataCommand =
400 O.LoadCommands[*LCIndex].MachOLoadCommand.linkedit_data_command_data;
401 char *Out = (char *)Buf->getBufferStart() + LinkEditDataCommand.dataoff;
402 assert((LinkEditDataCommand.datasize == LD.Data.size()) &&
403 "Incorrect data size");
404 memcpy(dest: Out, src: LD.Data.data(), n: LD.Data.size());
405}
406
407static uint64_t
408getSegmentFileOffset(const LoadCommand &TextSegmentLoadCommand) {
409 const MachO::macho_load_command &MLC =
410 TextSegmentLoadCommand.MachOLoadCommand;
411 switch (MLC.load_command_data.cmd) {
412 case MachO::LC_SEGMENT:
413 return MLC.segment_command_data.fileoff;
414 case MachO::LC_SEGMENT_64:
415 return MLC.segment_command_64_data.fileoff;
416 default:
417 return 0;
418 }
419}
420
421static uint64_t getSegmentFileSize(const LoadCommand &TextSegmentLoadCommand) {
422 const MachO::macho_load_command &MLC =
423 TextSegmentLoadCommand.MachOLoadCommand;
424 switch (MLC.load_command_data.cmd) {
425 case MachO::LC_SEGMENT:
426 return MLC.segment_command_data.filesize;
427 case MachO::LC_SEGMENT_64:
428 return MLC.segment_command_64_data.filesize;
429 default:
430 return 0;
431 }
432}
433
434void MachOWriter::writeCodeSignatureData() {
435 // NOTE: This CodeSignature section behaviour must be kept in sync with that
436 // performed in LLD's CodeSignatureSection::write /
437 // CodeSignatureSection::writeHashes. Furthermore, this call must occur only
438 // after the rest of the binary has already been written to the buffer. This
439 // is because the buffer is read from to perform the necessary hashing.
440
441 // The CodeSignature section is the last section in the MachO binary and
442 // contains a hash of all content in the binary before it. Since llvm-objcopy
443 // has likely modified the target binary, the hash must be regenerated
444 // entirely. To generate this hash, we must read from the start of the binary
445 // (HashReadStart) to just before the start of the CodeSignature section
446 // (HashReadEnd).
447
448 const CodeSignatureInfo &CodeSignature = LayoutBuilder.getCodeSignature();
449
450 uint8_t *BufferStart = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
451 uint8_t *HashReadStart = BufferStart;
452 uint8_t *HashReadEnd = BufferStart + CodeSignature.StartOffset;
453
454 // The CodeSignature section begins with a header, after which the hashes
455 // of each page of the binary are written.
456 uint8_t *HashWriteStart = HashReadEnd + CodeSignature.AllHeadersSize;
457
458 uint32_t TextSegmentFileOff = 0;
459 uint32_t TextSegmentFileSize = 0;
460 if (O.TextSegmentCommandIndex) {
461 const LoadCommand &TextSegmentLoadCommand =
462 O.LoadCommands[*O.TextSegmentCommandIndex];
463 assert(TextSegmentLoadCommand.MachOLoadCommand.load_command_data.cmd ==
464 MachO::LC_SEGMENT ||
465 TextSegmentLoadCommand.MachOLoadCommand.load_command_data.cmd ==
466 MachO::LC_SEGMENT_64);
467 assert(StringRef(TextSegmentLoadCommand.MachOLoadCommand
468 .segment_command_data.segname) == "__TEXT");
469 TextSegmentFileOff = getSegmentFileOffset(TextSegmentLoadCommand);
470 TextSegmentFileSize = getSegmentFileSize(TextSegmentLoadCommand);
471 }
472
473 const uint32_t FileNamePad = CodeSignature.AllHeadersSize -
474 CodeSignature.FixedHeadersSize -
475 CodeSignature.OutputFileName.size();
476
477 // Write code section header.
478 auto *SuperBlob = reinterpret_cast<MachO::CS_SuperBlob *>(HashReadEnd);
479 write32be(P: &SuperBlob->magic, V: MachO::CSMAGIC_EMBEDDED_SIGNATURE);
480 write32be(P: &SuperBlob->length, V: CodeSignature.Size);
481 write32be(P: &SuperBlob->count, V: 1);
482 auto *BlobIndex = reinterpret_cast<MachO::CS_BlobIndex *>(&SuperBlob[1]);
483 write32be(P: &BlobIndex->type, V: MachO::CSSLOT_CODEDIRECTORY);
484 write32be(P: &BlobIndex->offset, V: CodeSignature.BlobHeadersSize);
485 auto *CodeDirectory = reinterpret_cast<MachO::CS_CodeDirectory *>(
486 HashReadEnd + CodeSignature.BlobHeadersSize);
487 write32be(P: &CodeDirectory->magic, V: MachO::CSMAGIC_CODEDIRECTORY);
488 write32be(P: &CodeDirectory->length,
489 V: CodeSignature.Size - CodeSignature.BlobHeadersSize);
490 write32be(P: &CodeDirectory->version, V: MachO::CS_SUPPORTSEXECSEG);
491 write32be(P: &CodeDirectory->flags, V: MachO::CS_ADHOC | MachO::CS_LINKER_SIGNED);
492 write32be(P: &CodeDirectory->hashOffset,
493 V: sizeof(MachO::CS_CodeDirectory) +
494 CodeSignature.OutputFileName.size() + FileNamePad);
495 write32be(P: &CodeDirectory->identOffset, V: sizeof(MachO::CS_CodeDirectory));
496 CodeDirectory->nSpecialSlots = 0;
497 write32be(P: &CodeDirectory->nCodeSlots, V: CodeSignature.BlockCount);
498 write32be(P: &CodeDirectory->codeLimit, V: CodeSignature.StartOffset);
499 CodeDirectory->hashSize = static_cast<uint8_t>(CodeSignature.HashSize);
500 CodeDirectory->hashType = MachO::kSecCodeSignatureHashSHA256;
501 CodeDirectory->platform = 0;
502 CodeDirectory->pageSize = CodeSignature.BlockSizeShift;
503 CodeDirectory->spare2 = 0;
504 CodeDirectory->scatterOffset = 0;
505 CodeDirectory->teamOffset = 0;
506 CodeDirectory->spare3 = 0;
507 CodeDirectory->codeLimit64 = 0;
508 write64be(P: &CodeDirectory->execSegBase, V: TextSegmentFileOff);
509 write64be(P: &CodeDirectory->execSegLimit, V: TextSegmentFileSize);
510 write64be(P: &CodeDirectory->execSegFlags, V: O.Header.FileType == MachO::MH_EXECUTE
511 ? MachO::CS_EXECSEG_MAIN_BINARY
512 : 0);
513
514 auto *Id = reinterpret_cast<char *>(&CodeDirectory[1]);
515 memcpy(dest: Id, src: CodeSignature.OutputFileName.begin(),
516 n: CodeSignature.OutputFileName.size());
517 memset(s: Id + CodeSignature.OutputFileName.size(), c: 0, n: FileNamePad);
518
519 // Write the hashes.
520 uint8_t *CurrHashReadPosition = HashReadStart;
521 uint8_t *CurrHashWritePosition = HashWriteStart;
522 while (CurrHashReadPosition < HashReadEnd) {
523 StringRef Block(reinterpret_cast<char *>(CurrHashReadPosition),
524 std::min(a: static_cast<size_t>(HashReadEnd
525 - CurrHashReadPosition),
526 b: static_cast<size_t>(CodeSignature.BlockSize)));
527 SHA256 Hasher;
528 Hasher.update(Str: Block);
529 std::array<uint8_t, 32> Hash = Hasher.final();
530 assert(Hash.size() == CodeSignature.HashSize);
531 memcpy(dest: CurrHashWritePosition, src: Hash.data(), n: CodeSignature.HashSize);
532 CurrHashReadPosition += CodeSignature.BlockSize;
533 CurrHashWritePosition += CodeSignature.HashSize;
534 }
535#if defined(__APPLE__)
536 // This is macOS-specific work-around and makes no sense for any
537 // other host OS. See https://openradar.appspot.com/FB8914231
538 //
539 // The macOS kernel maintains a signature-verification cache to
540 // quickly validate applications at time of execve(2). The trouble
541 // is that for the kernel creates the cache entry at the time of the
542 // mmap(2) call, before we have a chance to write either the code to
543 // sign or the signature header+hashes. The fix is to invalidate
544 // all cached data associated with the output file, thus discarding
545 // the bogus prematurely-cached signature.
546 msync(BufferStart, CodeSignature.StartOffset + CodeSignature.Size,
547 MS_INVALIDATE);
548#endif
549}
550
551void MachOWriter::writeDataInCodeData() {
552 return writeLinkData(LCIndex: O.DataInCodeCommandIndex, LD: O.DataInCode);
553}
554
555void MachOWriter::writeLinkerOptimizationHint() {
556 return writeLinkData(LCIndex: O.LinkerOptimizationHintCommandIndex,
557 LD: O.LinkerOptimizationHint);
558}
559
560void MachOWriter::writeFunctionStartsData() {
561 return writeLinkData(LCIndex: O.FunctionStartsCommandIndex, LD: O.FunctionStarts);
562}
563
564void MachOWriter::writeDylibCodeSignDRsData() {
565 return writeLinkData(LCIndex: O.DylibCodeSignDRsIndex, LD: O.DylibCodeSignDRs);
566}
567
568void MachOWriter::writeChainedFixupsData() {
569 return writeLinkData(LCIndex: O.ChainedFixupsCommandIndex, LD: O.ChainedFixups);
570}
571
572void MachOWriter::writeExportsTrieData() {
573 if (!O.ExportsTrieCommandIndex)
574 return;
575 const MachO::linkedit_data_command &ExportsTrieCmd =
576 O.LoadCommands[*O.ExportsTrieCommandIndex]
577 .MachOLoadCommand.linkedit_data_command_data;
578 char *Out = (char *)Buf->getBufferStart() + ExportsTrieCmd.dataoff;
579 assert((ExportsTrieCmd.datasize == O.Exports.Trie.size()) &&
580 "Incorrect export trie size");
581 memcpy(dest: Out, src: O.Exports.Trie.data(), n: O.Exports.Trie.size());
582}
583
584void MachOWriter::writeTail() {
585 typedef void (MachOWriter::*WriteHandlerType)();
586 typedef std::pair<uint64_t, WriteHandlerType> WriteOperation;
587 SmallVector<WriteOperation, 7> Queue;
588
589 if (O.SymTabCommandIndex) {
590 const MachO::symtab_command &SymTabCommand =
591 O.LoadCommands[*O.SymTabCommandIndex]
592 .MachOLoadCommand.symtab_command_data;
593 if (SymTabCommand.symoff)
594 Queue.push_back(Elt: {SymTabCommand.symoff, &MachOWriter::writeSymbolTable});
595 if (SymTabCommand.stroff)
596 Queue.push_back(Elt: {SymTabCommand.stroff, &MachOWriter::writeStringTable});
597 }
598
599 if (O.DyLdInfoCommandIndex) {
600 const MachO::dyld_info_command &DyLdInfoCommand =
601 O.LoadCommands[*O.DyLdInfoCommandIndex]
602 .MachOLoadCommand.dyld_info_command_data;
603 if (DyLdInfoCommand.rebase_off)
604 Queue.push_back(
605 Elt: {DyLdInfoCommand.rebase_off, &MachOWriter::writeRebaseInfo});
606 if (DyLdInfoCommand.bind_off)
607 Queue.push_back(Elt: {DyLdInfoCommand.bind_off, &MachOWriter::writeBindInfo});
608 if (DyLdInfoCommand.weak_bind_off)
609 Queue.push_back(
610 Elt: {DyLdInfoCommand.weak_bind_off, &MachOWriter::writeWeakBindInfo});
611 if (DyLdInfoCommand.lazy_bind_off)
612 Queue.push_back(
613 Elt: {DyLdInfoCommand.lazy_bind_off, &MachOWriter::writeLazyBindInfo});
614 if (DyLdInfoCommand.export_off)
615 Queue.push_back(
616 Elt: {DyLdInfoCommand.export_off, &MachOWriter::writeExportInfo});
617 }
618
619 if (O.DySymTabCommandIndex) {
620 const MachO::dysymtab_command &DySymTabCommand =
621 O.LoadCommands[*O.DySymTabCommandIndex]
622 .MachOLoadCommand.dysymtab_command_data;
623
624 if (DySymTabCommand.indirectsymoff)
625 Queue.emplace_back(Args: DySymTabCommand.indirectsymoff,
626 Args: &MachOWriter::writeIndirectSymbolTable);
627 }
628
629 std::initializer_list<std::pair<std::optional<size_t>, WriteHandlerType>>
630 LinkEditDataCommandWriters = {
631 {O.CodeSignatureCommandIndex, &MachOWriter::writeCodeSignatureData},
632 {O.DylibCodeSignDRsIndex, &MachOWriter::writeDylibCodeSignDRsData},
633 {O.DataInCodeCommandIndex, &MachOWriter::writeDataInCodeData},
634 {O.LinkerOptimizationHintCommandIndex,
635 &MachOWriter::writeLinkerOptimizationHint},
636 {O.FunctionStartsCommandIndex, &MachOWriter::writeFunctionStartsData},
637 {O.ChainedFixupsCommandIndex, &MachOWriter::writeChainedFixupsData},
638 {O.ExportsTrieCommandIndex, &MachOWriter::writeExportsTrieData}};
639 for (const auto &W : LinkEditDataCommandWriters) {
640 std::optional<size_t> LinkEditDataCommandIndex;
641 WriteHandlerType WriteHandler;
642 std::tie(args&: LinkEditDataCommandIndex, args&: WriteHandler) = W;
643 if (LinkEditDataCommandIndex) {
644 const MachO::linkedit_data_command &LinkEditDataCommand =
645 O.LoadCommands[*LinkEditDataCommandIndex]
646 .MachOLoadCommand.linkedit_data_command_data;
647 if (LinkEditDataCommand.dataoff)
648 Queue.emplace_back(Args: LinkEditDataCommand.dataoff, Args&: WriteHandler);
649 }
650 }
651
652 llvm::sort(C&: Queue, Comp: llvm::less_first());
653
654 for (auto WriteOp : Queue)
655 (this->*WriteOp.second)();
656}
657
658Error MachOWriter::finalize() { return LayoutBuilder.layout(); }
659
660Error MachOWriter::write() {
661 size_t TotalSize = totalSize();
662 Buf = WritableMemoryBuffer::getNewMemBuffer(Size: TotalSize);
663 if (!Buf)
664 return createStringError(EC: errc::not_enough_memory,
665 S: "failed to allocate memory buffer of " +
666 Twine::utohexstr(Val: TotalSize) + " bytes");
667 writeHeader();
668 writeLoadCommands();
669 writeSections();
670 writeTail();
671
672 // TODO: Implement direct writing to the output stream (without intermediate
673 // memory buffer Buf).
674 Out.write(Ptr: Buf->getBufferStart(), Size: Buf->getBufferSize());
675 return Error::success();
676}
677