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