1//===- MachOObjcopy.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 "llvm/ObjCopy/MachO/MachOObjcopy.h"
10#include "Archive.h"
11#include "MachOReader.h"
12#include "MachOWriter.h"
13#include "llvm/ADT/DenseSet.h"
14#include "llvm/ObjCopy/CommonConfig.h"
15#include "llvm/ObjCopy/MachO/MachOConfig.h"
16#include "llvm/ObjCopy/MultiFormatConfig.h"
17#include "llvm/ObjCopy/ObjCopy.h"
18#include "llvm/Object/ArchiveWriter.h"
19#include "llvm/Object/MachOUniversal.h"
20#include "llvm/Object/MachOUniversalWriter.h"
21#include "llvm/Support/Errc.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/FileOutputBuffer.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/SmallVectorMemoryBuffer.h"
26
27using namespace llvm;
28using namespace llvm::objcopy;
29using namespace llvm::objcopy::macho;
30using namespace llvm::object;
31
32using SectionPred = std::function<bool(const std::unique_ptr<Section> &Sec)>;
33using LoadCommandPred = std::function<bool(const LoadCommand &LC)>;
34
35#ifndef NDEBUG
36static bool isLoadCommandWithPayloadString(const LoadCommand &LC) {
37 // TODO: Add support for LC_REEXPORT_DYLIB, LC_LOAD_UPWARD_DYLIB and
38 // LC_LAZY_LOAD_DYLIB
39 return LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_RPATH ||
40 LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_ID_DYLIB ||
41 LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_LOAD_DYLIB ||
42 LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_LOAD_WEAK_DYLIB;
43}
44#endif
45
46static StringRef getPayloadString(const LoadCommand &LC) {
47 assert(isLoadCommandWithPayloadString(LC) &&
48 "unsupported load command encountered");
49
50 return StringRef(reinterpret_cast<const char *>(LC.Payload.data()),
51 LC.Payload.size())
52 .rtrim(Char: '\0');
53}
54
55static Error removeSections(const CommonConfig &Config, Object &Obj) {
56 SectionPred RemovePred = [](const std::unique_ptr<Section> &) {
57 return false;
58 };
59
60 if (!Config.ToRemove.empty()) {
61 RemovePred = [&Config, RemovePred](const std::unique_ptr<Section> &Sec) {
62 return Config.ToRemove.matches(S: Sec->CanonicalName);
63 };
64 }
65
66 if (Config.StripAll || Config.StripDebug) {
67 // Remove all debug sections.
68 RemovePred = [RemovePred](const std::unique_ptr<Section> &Sec) {
69 if (Sec->Segname == "__DWARF")
70 return true;
71
72 return RemovePred(Sec);
73 };
74 }
75
76 if (!Config.OnlySection.empty()) {
77 // Overwrite RemovePred because --only-section takes priority.
78 RemovePred = [&Config](const std::unique_ptr<Section> &Sec) {
79 return !Config.OnlySection.matches(S: Sec->CanonicalName);
80 };
81 }
82
83 return Obj.removeSections(ToRemove: RemovePred);
84}
85
86static void markSymbols(const CommonConfig &Config, Object &Obj) {
87 // Symbols referenced from the indirect symbol table must not be removed.
88 for (IndirectSymbolEntry &ISE : Obj.IndirectSymTable.Symbols)
89 if (ISE.Symbol)
90 (*ISE.Symbol)->Referenced = true;
91
92 // --strip-all removes relocations, so their symbols need not be preserved.
93 if (Config.StripAll)
94 return;
95
96 for (const LoadCommand &LC : Obj.LoadCommands)
97 for (const std::unique_ptr<Section> &Sec : LC.Sections)
98 for (const RelocationInfo &R : Sec->Relocations)
99 if (R.Symbol && *R.Symbol)
100 (*R.Symbol)->Referenced = true;
101}
102
103static void updateAndRemoveSymbols(const CommonConfig &Config,
104 const MachOConfig &MachOConfig,
105 Object &Obj) {
106 Obj.SymTable.updateSymbols(Callable: [&](SymbolEntry &Sym) {
107 if (Config.SymbolsToSkip.matches(S: Sym.Name))
108 return;
109
110 if (!Sym.isUndefinedSymbol() && Config.SymbolsToLocalize.matches(S: Sym.Name))
111 Sym.n_type &= ~MachO::N_EXT;
112
113 // Note: these two globalize flags have very similar names but different
114 // meanings:
115 //
116 // --globalize-symbol: promote a symbol to global
117 // --keep-global-symbol: all symbols except for these should be made local
118 //
119 // If --globalize-symbol is specified for a given symbol, it will be
120 // global in the output file even if it is not included via
121 // --keep-global-symbol. Because of that, make sure to check
122 // --globalize-symbol second.
123 if (!Sym.isUndefinedSymbol() && !Config.SymbolsToKeepGlobal.empty() &&
124 !Config.SymbolsToKeepGlobal.matches(S: Sym.Name))
125 Sym.n_type &= ~MachO::N_EXT;
126
127 if (!Sym.isUndefinedSymbol() && Config.SymbolsToGlobalize.matches(S: Sym.Name))
128 Sym.n_type |= MachO::N_EXT;
129
130 if (Sym.isExternalSymbol() && !Sym.isUndefinedSymbol() &&
131 (Config.Weaken || Config.SymbolsToWeaken.matches(S: Sym.Name)))
132 Sym.n_desc |= MachO::N_WEAK_DEF;
133
134 auto I = Config.SymbolsToRename.find(Key: Sym.Name);
135 if (I != Config.SymbolsToRename.end())
136 Sym.Name = std::string(I->getValue());
137 });
138
139 auto RemovePred = [&Config, &MachOConfig,
140 &Obj](const std::unique_ptr<SymbolEntry> &N) {
141 if (N->Referenced)
142 return false;
143 if (MachOConfig.KeepUndefined && N->isUndefinedSymbol())
144 return false;
145 if (N->n_desc & MachO::REFERENCED_DYNAMICALLY)
146 return false;
147 if (Config.StripAll)
148 return true;
149 if (Config.DiscardMode == DiscardType::All && !(N->n_type & MachO::N_EXT))
150 return true;
151 // This behavior is consistent with cctools' strip.
152 if (Config.StripDebug && (N->n_type & MachO::N_STAB))
153 return true;
154 // This behavior is consistent with cctools' strip.
155 if (MachOConfig.StripSwiftSymbols &&
156 (Obj.Header.Flags & MachO::MH_DYLDLINK) && Obj.SwiftVersion &&
157 *Obj.SwiftVersion && N->isSwiftSymbol())
158 return true;
159 return false;
160 };
161
162 Obj.SymTable.removeSymbols(ToRemove: RemovePred);
163}
164
165template <typename LCType>
166static void updateLoadCommandPayloadString(LoadCommand &LC, StringRef S) {
167 assert(isLoadCommandWithPayloadString(LC) &&
168 "unsupported load command encountered");
169
170 uint32_t NewCmdsize = alignToPowerOf2(Value: sizeof(LCType) + S.size() + 1, Align: 8);
171
172 LC.MachOLoadCommand.load_command_data.cmdsize = NewCmdsize;
173 LC.Payload.assign(n: NewCmdsize - sizeof(LCType), val: 0);
174 llvm::copy(Range&: S, Out: LC.Payload.begin());
175}
176
177static LoadCommand buildRPathLoadCommand(StringRef Path) {
178 LoadCommand LC;
179 MachO::rpath_command RPathLC;
180 RPathLC.cmd = MachO::LC_RPATH;
181 RPathLC.path = sizeof(MachO::rpath_command);
182 RPathLC.cmdsize =
183 alignToPowerOf2(Value: sizeof(MachO::rpath_command) + Path.size() + 1, Align: 8);
184 LC.MachOLoadCommand.rpath_command_data = RPathLC;
185 LC.Payload.assign(n: RPathLC.cmdsize - sizeof(MachO::rpath_command), val: 0);
186 llvm::copy(Range&: Path, Out: LC.Payload.begin());
187 return LC;
188}
189
190static Error processLoadCommands(const MachOConfig &MachOConfig, Object &Obj) {
191 // Remove RPaths.
192 DenseSet<StringRef> RPathsToRemove(MachOConfig.RPathsToRemove.begin(),
193 MachOConfig.RPathsToRemove.end());
194
195 LoadCommandPred RemovePred = [&RPathsToRemove,
196 &MachOConfig](const LoadCommand &LC) {
197 if (LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_RPATH) {
198 // When removing all RPaths we don't need to care
199 // about what it contains
200 if (MachOConfig.RemoveAllRpaths)
201 return true;
202
203 StringRef RPath = getPayloadString(LC);
204 if (RPathsToRemove.count(V: RPath)) {
205 RPathsToRemove.erase(V: RPath);
206 return true;
207 }
208 }
209 return false;
210 };
211
212 if (Error E = Obj.removeLoadCommands(ToRemove: RemovePred))
213 return E;
214
215 // Emit an error if the Mach-O binary does not contain an rpath path name
216 // specified in -delete_rpath.
217 for (StringRef RPath : MachOConfig.RPathsToRemove) {
218 if (RPathsToRemove.count(V: RPath))
219 return createStringError(EC: errc::invalid_argument,
220 Fmt: "no LC_RPATH load command with path: %s",
221 Vals: RPath.str().c_str());
222 }
223
224 DenseSet<StringRef> RPaths;
225
226 // Get all existing RPaths.
227 for (LoadCommand &LC : Obj.LoadCommands) {
228 if (LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_RPATH)
229 RPaths.insert(V: getPayloadString(LC));
230 }
231
232 // Throw errors for invalid RPaths.
233 for (const auto &OldNew : MachOConfig.RPathsToUpdate) {
234 StringRef Old = OldNew.getFirst();
235 StringRef New = OldNew.getSecond();
236 if (!RPaths.contains(V: Old))
237 return createStringError(EC: errc::invalid_argument,
238 S: "no LC_RPATH load command with path: " + Old);
239 if (RPaths.contains(V: New))
240 return createStringError(EC: errc::invalid_argument,
241 S: "rpath '" + New +
242 "' would create a duplicate load command");
243 }
244
245 // Update load commands.
246 for (LoadCommand &LC : Obj.LoadCommands) {
247 switch (LC.MachOLoadCommand.load_command_data.cmd) {
248 case MachO::LC_ID_DYLIB:
249 if (MachOConfig.SharedLibId)
250 updateLoadCommandPayloadString<MachO::dylib_command>(
251 LC, S: *MachOConfig.SharedLibId);
252 break;
253
254 case MachO::LC_RPATH: {
255 StringRef RPath = getPayloadString(LC);
256 StringRef NewRPath = MachOConfig.RPathsToUpdate.lookup(Val: RPath);
257 if (!NewRPath.empty())
258 updateLoadCommandPayloadString<MachO::rpath_command>(LC, S: NewRPath);
259 break;
260 }
261
262 // TODO: Add LC_REEXPORT_DYLIB, LC_LAZY_LOAD_DYLIB, and LC_LOAD_UPWARD_DYLIB
263 // here once llvm-objcopy supports them.
264 case MachO::LC_LOAD_DYLIB:
265 case MachO::LC_LOAD_WEAK_DYLIB:
266 StringRef InstallName = getPayloadString(LC);
267 StringRef NewInstallName =
268 MachOConfig.InstallNamesToUpdate.lookup(Val: InstallName);
269 if (!NewInstallName.empty())
270 updateLoadCommandPayloadString<MachO::dylib_command>(LC,
271 S: NewInstallName);
272 break;
273 }
274 }
275
276 // Add new RPaths.
277 for (StringRef RPath : MachOConfig.RPathToAdd) {
278 if (RPaths.contains(V: RPath))
279 return createStringError(EC: errc::invalid_argument,
280 S: "rpath '" + RPath +
281 "' would create a duplicate load command");
282 RPaths.insert(V: RPath);
283 Obj.LoadCommands.push_back(x: buildRPathLoadCommand(Path: RPath));
284 }
285
286 for (StringRef RPath : MachOConfig.RPathToPrepend) {
287 if (RPaths.contains(V: RPath))
288 return createStringError(EC: errc::invalid_argument,
289 S: "rpath '" + RPath +
290 "' would create a duplicate load command");
291
292 RPaths.insert(V: RPath);
293 Obj.LoadCommands.insert(position: Obj.LoadCommands.begin(),
294 x: buildRPathLoadCommand(Path: RPath));
295 }
296
297 // Unlike appending rpaths, the indexes of subsequent load commands must
298 // be recalculated after prepending one.
299 if (!MachOConfig.RPathToPrepend.empty())
300 Obj.updateLoadCommandIndexes();
301
302 // Remove any empty segments if required.
303 if (!MachOConfig.EmptySegmentsToRemove.empty()) {
304 auto RemovePred = [&MachOConfig](const LoadCommand &LC) {
305 if (LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_SEGMENT_64 ||
306 LC.MachOLoadCommand.load_command_data.cmd == MachO::LC_SEGMENT) {
307 return LC.Sections.empty() &&
308 MachOConfig.EmptySegmentsToRemove.contains(V: *LC.getSegmentName());
309 }
310 return false;
311 };
312 if (Error E = Obj.removeLoadCommands(ToRemove: RemovePred))
313 return E;
314 }
315
316 return Error::success();
317}
318
319static Error dumpSectionToFile(StringRef SecName, StringRef Filename,
320 StringRef InputFilename, Object &Obj) {
321 for (LoadCommand &LC : Obj.LoadCommands)
322 for (const std::unique_ptr<Section> &Sec : LC.Sections) {
323 if (Sec->CanonicalName == SecName) {
324 Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
325 FileOutputBuffer::create(FilePath: Filename, Size: Sec->Content.size());
326 if (!BufferOrErr)
327 return createFileError(F: Filename, E: BufferOrErr.takeError());
328 std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
329 llvm::copy(Range&: Sec->Content, Out: Buf->getBufferStart());
330
331 if (Error E = Buf->commit())
332 return createFileError(F: Filename, E: std::move(E));
333 return Error::success();
334 }
335 }
336
337 return createFileError(F: InputFilename, EC: object_error::parse_failed,
338 Fmt: "section '%s' not found", Vals: SecName.str().c_str());
339}
340
341static Error addSection(const NewSectionInfo &NewSection, Object &Obj) {
342 std::pair<StringRef, StringRef> Pair = NewSection.SectionName.split(Separator: ',');
343 StringRef TargetSegName = Pair.first;
344 Section Sec(TargetSegName, Pair.second);
345 Sec.Content =
346 Obj.NewSectionsContents.save(S: NewSection.SectionData->getBuffer());
347 Sec.Size = Sec.Content.size();
348
349 // Add the a section into an existing segment.
350 for (LoadCommand &LC : Obj.LoadCommands) {
351 std::optional<StringRef> SegName = LC.getSegmentName();
352 if (SegName && SegName == TargetSegName) {
353 uint64_t Addr = *LC.getSegmentVMAddr();
354 for (const std::unique_ptr<Section> &S : LC.Sections)
355 Addr = std::max(a: Addr, b: S->Addr + S->Size);
356 LC.Sections.push_back(x: std::make_unique<Section>(args&: Sec));
357 LC.Sections.back()->Addr = Addr;
358 return Error::success();
359 }
360 }
361
362 // There's no segment named TargetSegName. Create a new load command and
363 // Insert a new section into it.
364 LoadCommand &NewSegment =
365 Obj.addSegment(SegName: TargetSegName, SegVMSize: alignToPowerOf2(Value: Sec.Size, Align: 16384));
366 NewSegment.Sections.push_back(x: std::make_unique<Section>(args&: Sec));
367 NewSegment.Sections.back()->Addr = *NewSegment.getSegmentVMAddr();
368 return Error::success();
369}
370
371static Expected<Section &> findSection(StringRef SecName, Object &O) {
372 StringRef SegName;
373 std::tie(args&: SegName, args&: SecName) = SecName.split(Separator: ",");
374 // For compactness, intermediate object files (MH_OBJECT) contain
375 // only one segment in which all sections are placed.
376 // The static linker places each section in the named segment when building
377 // the final product (any file that is not of type MH_OBJECT).
378 //
379 // Source:
380 // https://math-atlas.sourceforge.net/devel/assembly/MachORuntime.pdf
381 // page 57
382 if (O.Header.FileType == MachO::HeaderFileType::MH_OBJECT) {
383 for (const auto& LC : O.LoadCommands)
384 for (const auto& Sec : LC.Sections)
385 if (Sec->Segname == SegName && Sec->Sectname == SecName)
386 return *Sec;
387
388 StringRef ErrMsg = "could not find section with name '%s' in '%s' segment";
389 return createStringError(EC: errc::invalid_argument, Fmt: ErrMsg.str().c_str(),
390 Vals: SecName.str().c_str(), Vals: SegName.str().c_str());
391 }
392 auto FoundSeg =
393 llvm::find_if(Range&: O.LoadCommands, P: [SegName](const LoadCommand &LC) {
394 return LC.getSegmentName() == SegName;
395 });
396 if (FoundSeg == O.LoadCommands.end())
397 return createStringError(EC: errc::invalid_argument,
398 Fmt: "could not find segment with name '%s'",
399 Vals: SegName.str().c_str());
400 auto FoundSec = llvm::find_if(Range&: FoundSeg->Sections,
401 P: [SecName](const std::unique_ptr<Section> &Sec) {
402 return Sec->Sectname == SecName;
403 });
404 if (FoundSec == FoundSeg->Sections.end())
405 return createStringError(EC: errc::invalid_argument,
406 Fmt: "could not find section with name '%s'",
407 Vals: SecName.str().c_str());
408
409 assert(FoundSec->get()->CanonicalName == (SegName + "," + SecName).str());
410 return **FoundSec;
411}
412
413static Error updateSection(const NewSectionInfo &NewSection, Object &O) {
414 Expected<Section &> SecToUpdateOrErr = findSection(SecName: NewSection.SectionName, O);
415
416 if (!SecToUpdateOrErr)
417 return SecToUpdateOrErr.takeError();
418 Section &Sec = *SecToUpdateOrErr;
419
420 if (NewSection.SectionData->getBufferSize() > Sec.Size)
421 return createStringError(
422 EC: errc::invalid_argument,
423 S: "new section cannot be larger than previous section");
424 Sec.Content = O.NewSectionsContents.save(S: NewSection.SectionData->getBuffer());
425 Sec.Size = Sec.Content.size();
426 return Error::success();
427}
428
429// isValidMachOCannonicalName returns success if Name is a MachO cannonical name
430// ("<segment>,<section>") and lengths of both segment and section names are
431// valid.
432static Error isValidMachOCannonicalName(StringRef Name) {
433 if (Name.count(C: ',') != 1)
434 return createStringError(EC: errc::invalid_argument,
435 Fmt: "invalid section name '%s' (should be formatted "
436 "as '<segment name>,<section name>')",
437 Vals: Name.str().c_str());
438
439 std::pair<StringRef, StringRef> Pair = Name.split(Separator: ',');
440 if (Pair.first.size() > 16)
441 return createStringError(EC: errc::invalid_argument,
442 Fmt: "too long segment name: '%s'",
443 Vals: Pair.first.str().c_str());
444 if (Pair.second.size() > 16)
445 return createStringError(EC: errc::invalid_argument,
446 Fmt: "too long section name: '%s'",
447 Vals: Pair.second.str().c_str());
448 return Error::success();
449}
450
451static Error handleArgs(const CommonConfig &Config,
452 const MachOConfig &MachOConfig, Object &Obj) {
453 // Dump sections before add/remove for compatibility with GNU objcopy.
454 for (StringRef Flag : Config.DumpSection) {
455 StringRef SectionName;
456 StringRef FileName;
457 std::tie(args&: SectionName, args&: FileName) = Flag.split(Separator: '=');
458 if (Error E =
459 dumpSectionToFile(SecName: SectionName, Filename: FileName, InputFilename: Config.InputFilename, Obj))
460 return E;
461 }
462
463 if (Error E = removeSections(Config, Obj))
464 return createFileError(F: Config.InputFilename, E: std::move(E));
465
466 // Mark symbols to determine which symbols are still needed.
467 markSymbols(Config, Obj);
468
469 updateAndRemoveSymbols(Config, MachOConfig, Obj);
470
471 if (Config.StripAll)
472 for (LoadCommand &LC : Obj.LoadCommands)
473 for (std::unique_ptr<Section> &Sec : LC.Sections)
474 Sec->Relocations.clear();
475
476 for (const NewSectionInfo &NewSection : Config.AddSection) {
477 if (Error E = isValidMachOCannonicalName(Name: NewSection.SectionName))
478 return createFileError(F: Config.InputFilename, E: std::move(E));
479 if (Error E = addSection(NewSection, Obj))
480 return createFileError(F: Config.InputFilename, E: std::move(E));
481 }
482
483 for (const NewSectionInfo &NewSection : Config.UpdateSection) {
484 if (Error E = isValidMachOCannonicalName(Name: NewSection.SectionName))
485 return createFileError(F: Config.InputFilename, E: std::move(E));
486 if (Error E = updateSection(NewSection, O&: Obj))
487 return createFileError(F: Config.InputFilename, E: std::move(E));
488 }
489
490 if (Error E = processLoadCommands(MachOConfig, Obj))
491 return createFileError(F: Config.InputFilename, E: std::move(E));
492
493 return Error::success();
494}
495
496Error objcopy::macho::executeObjcopyOnBinary(const CommonConfig &Config,
497 const MachOConfig &MachOConfig,
498 object::MachOObjectFile &In,
499 raw_ostream &Out) {
500 MachOReader Reader(In);
501 Expected<std::unique_ptr<Object>> O = Reader.create();
502 if (!O)
503 return createFileError(F: Config.InputFilename, E: O.takeError());
504
505 if (O->get()->Header.FileType == MachO::HeaderFileType::MH_PRELOAD)
506 return createStringError(EC: std::errc::not_supported,
507 Fmt: "%s: MH_PRELOAD files are not supported",
508 Vals: Config.InputFilename.str().c_str());
509
510 if (Error E = handleArgs(Config, MachOConfig, Obj&: **O))
511 return E;
512
513 // Page size used for alignment of segment sizes in Mach-O executables and
514 // dynamic libraries.
515 uint64_t PageSize;
516 switch (In.getArch()) {
517 case Triple::ArchType::arm:
518 case Triple::ArchType::aarch64:
519 case Triple::ArchType::aarch64_32:
520 PageSize = 16384;
521 break;
522 default:
523 PageSize = 4096;
524 }
525
526 MachOWriter Writer(**O, In.is64Bit(), In.isLittleEndian(),
527 sys::path::filename(path: Config.OutputFilename), PageSize, Out);
528 if (auto E = Writer.finalize())
529 return E;
530 return Writer.write();
531}
532
533Error objcopy::macho::executeObjcopyOnMachOUniversalBinary(
534 const MultiFormatConfig &Config, const MachOUniversalBinary &In,
535 raw_ostream &Out) {
536 SmallVector<OwningBinary<Binary>, 2> Binaries;
537 SmallVector<Slice, 2> Slices;
538 for (const auto &O : In.objects()) {
539 Expected<std::unique_ptr<Archive>> ArOrErr = O.getAsArchive();
540 if (ArOrErr) {
541 Expected<std::vector<NewArchiveMember>> NewArchiveMembersOrErr =
542 createNewArchiveMembers(Config, Ar: **ArOrErr);
543 if (!NewArchiveMembersOrErr)
544 return NewArchiveMembersOrErr.takeError();
545 auto Kind = (*ArOrErr)->kind();
546 if (Kind == object::Archive::K_BSD)
547 Kind = object::Archive::K_DARWIN;
548 Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr =
549 writeArchiveToBuffer(
550 NewMembers: *NewArchiveMembersOrErr,
551 WriteSymtab: (*ArOrErr)->hasSymbolTable() ? SymtabWritingMode::NormalSymtab
552 : SymtabWritingMode::NoSymtab,
553 Kind, Deterministic: Config.getCommonConfig().DeterministicArchives,
554 Thin: (*ArOrErr)->isThin());
555 if (!OutputBufferOrErr)
556 return OutputBufferOrErr.takeError();
557 Expected<std::unique_ptr<Binary>> BinaryOrErr =
558 object::createBinary(Source: **OutputBufferOrErr);
559 if (!BinaryOrErr)
560 return BinaryOrErr.takeError();
561 Binaries.emplace_back(Args: std::move(*BinaryOrErr),
562 Args: std::move(*OutputBufferOrErr));
563 Slices.emplace_back(Args&: *cast<Archive>(Val: Binaries.back().getBinary()),
564 Args: O.getCPUType(), Args: O.getCPUSubType(),
565 Args: O.getArchFlagName(), Args: O.getAlign());
566 continue;
567 }
568 // The methods getAsArchive, getAsObjectFile, getAsIRObject of the class
569 // ObjectForArch return an Error in case of the type mismatch. We need to
570 // check each in turn to see what kind of slice this is, so ignore errors
571 // produced along the way.
572 consumeError(Err: ArOrErr.takeError());
573
574 Expected<std::unique_ptr<MachOObjectFile>> ObjOrErr = O.getAsObjectFile();
575 if (!ObjOrErr) {
576 consumeError(Err: ObjOrErr.takeError());
577 return createStringError(
578 EC: std::errc::invalid_argument,
579 Fmt: "slice for '%s' of the universal Mach-O binary "
580 "'%s' is not a Mach-O object or an archive",
581 Vals: O.getArchFlagName().c_str(),
582 Vals: Config.getCommonConfig().InputFilename.str().c_str());
583 }
584 std::string ArchFlagName = O.getArchFlagName();
585
586 SmallVector<char, 0> Buffer;
587 raw_svector_ostream MemStream(Buffer);
588
589 Expected<const MachOConfig &> MachO = Config.getMachOConfig();
590 if (!MachO)
591 return MachO.takeError();
592
593 if (Error E = executeObjcopyOnBinary(Config: Config.getCommonConfig(), MachOConfig: *MachO,
594 In&: **ObjOrErr, Out&: MemStream))
595 return E;
596
597 auto MB = std::make_unique<SmallVectorMemoryBuffer>(
598 args: std::move(Buffer), args&: ArchFlagName, /*RequiresNullTerminator=*/args: false);
599 Expected<std::unique_ptr<Binary>> BinaryOrErr = object::createBinary(Source: *MB);
600 if (!BinaryOrErr)
601 return BinaryOrErr.takeError();
602 Binaries.emplace_back(Args: std::move(*BinaryOrErr), Args: std::move(MB));
603 Slices.emplace_back(Args&: *cast<MachOObjectFile>(Val: Binaries.back().getBinary()),
604 Args: O.getAlign());
605 }
606
607 if (Error Err = writeUniversalBinaryToStream(Slices, Out))
608 return Err;
609
610 return Error::success();
611}
612