1//===-- llvm-libtool-darwin.cpp - a tool for creating libraries -----------===//
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// A utility for creating static and dynamic libraries for Darwin.
10//
11//===----------------------------------------------------------------------===//
12
13#include "DependencyInfo.h"
14#include "llvm/ADT/MapVector.h"
15#include "llvm/BinaryFormat/Magic.h"
16#include "llvm/IR/LLVMContext.h"
17#include "llvm/Object/ArchiveWriter.h"
18#include "llvm/Object/IRObjectFile.h"
19#include "llvm/Object/MachO.h"
20#include "llvm/Object/MachOUniversal.h"
21#include "llvm/Object/MachOUniversalWriter.h"
22#include "llvm/Object/ObjectFile.h"
23#include "llvm/Option/ArgList.h"
24#include "llvm/Option/Option.h"
25#include "llvm/Support/CommandLine.h"
26#include "llvm/Support/Driver.h"
27#include "llvm/Support/LineIterator.h"
28#include "llvm/Support/TargetSelect.h"
29#include "llvm/Support/VirtualFileSystem.h"
30#include "llvm/Support/WithColor.h"
31#include "llvm/Support/raw_ostream.h"
32#include "llvm/TextAPI/Architecture.h"
33#include <cstdlib>
34#include <map>
35#include <type_traits>
36
37using namespace llvm;
38using namespace llvm::object;
39using namespace llvm::opt;
40
41// Command-line option boilerplate.
42namespace {
43enum ID {
44 OPT_INVALID = 0, // This is not an option ID.
45#define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),
46#include "Opts.inc"
47#undef OPTION
48};
49
50#define OPTTABLE_CODE
51#include "Opts.inc"
52
53class LibtoolDarwinOptTable : public opt::OptTable {
54public:
55 LibtoolDarwinOptTable() : OptTable(optionTables()) {}
56};
57} // end anonymous namespace
58
59class NewArchiveMemberList;
60typedef std::map<uint64_t, NewArchiveMemberList> MembersPerArchitectureMap;
61
62static std::string OutputFile;
63static std::vector<std::string> InputFiles;
64static std::optional<std::string> ArchType;
65
66enum class Operation { None, Static };
67static Operation LibraryOperation = Operation::None;
68
69static bool DeterministicOption;
70static bool NonDeterministicOption;
71static std::string FileList;
72static std::vector<std::string> Libraries;
73static std::vector<std::string> LibrarySearchDirs;
74static std::string DependencyInfoPath;
75static bool VersionOption;
76static bool NoWarningForNoSymbols;
77static bool WarningsAsErrors;
78
79static const std::array<std::string, 3> StandardSearchDirs{
80 "/lib",
81 "/usr/lib",
82 "/usr/local/lib",
83};
84
85std::unique_ptr<DependencyInfo> GlobalDependencyInfo;
86
87struct Config {
88 bool Deterministic = true; // Updated by 'D' and 'U' modifiers.
89 uint32_t ArchCPUType;
90 uint32_t ArchCPUSubtype;
91};
92
93static Expected<std::string> searchForFile(const Twine &FileName) {
94 auto FindLib =
95 [FileName](
96 ArrayRef<std::string> SearchDirs) -> std::optional<std::string> {
97 for (StringRef Dir : SearchDirs) {
98 SmallString<128> Path;
99 sys::path::append(path&: Path, a: Dir, b: FileName);
100
101 if (sys::fs::exists(Path))
102 return std::string(Path);
103
104 GlobalDependencyInfo->addMissingInput(Path);
105 }
106 return std::nullopt;
107 };
108
109 std::optional<std::string> Found = FindLib(LibrarySearchDirs);
110 if (!Found)
111 Found = FindLib(StandardSearchDirs);
112 if (Found)
113 return *Found;
114
115 return createStringError(EC: std::errc::invalid_argument,
116 Fmt: "cannot locate file '%s'", Vals: FileName.str().c_str());
117}
118
119static Error processCommandLineLibraries() {
120 for (StringRef BaseName : Libraries) {
121 Expected<std::string> FullPath = searchForFile(
122 FileName: BaseName.ends_with(Suffix: ".o") ? BaseName.str() : "lib" + BaseName + ".a");
123 if (!FullPath)
124 return FullPath.takeError();
125 InputFiles.push_back(x: FullPath.get());
126 }
127
128 return Error::success();
129}
130
131static Error processFileList() {
132 StringRef FileName, DirName;
133 std::tie(args&: FileName, args&: DirName) = StringRef(FileList).rsplit(Separator: ",");
134
135 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
136 MemoryBuffer::getFileOrSTDIN(Filename: FileName, /*IsText=*/false,
137 /*RequiresNullTerminator=*/true);
138 if (std::error_code EC = FileOrErr.getError())
139 return createFileError(F: FileName, E: errorCodeToError(EC));
140 const MemoryBuffer &Ref = *FileOrErr.get();
141
142 line_iterator I(Ref, /*SkipBlanks=*/false);
143 if (I.is_at_eof())
144 return createStringError(EC: std::errc::invalid_argument,
145 Fmt: "file list file: '%s' is empty",
146 Vals: FileName.str().c_str());
147 for (; !I.is_at_eof(); ++I) {
148 StringRef Line = *I;
149 if (Line.empty())
150 return createStringError(EC: std::errc::invalid_argument,
151 Fmt: "file list file: '%s': filename cannot be empty",
152 Vals: FileName.str().c_str());
153
154 SmallString<128> Path;
155 if (!DirName.empty())
156 sys::path::append(path&: Path, a: DirName, b: Line);
157 else
158 sys::path::append(path&: Path, a: Line);
159 InputFiles.push_back(x: static_cast<std::string>(Path));
160 }
161 return Error::success();
162}
163
164static Error validateArchitectureName(StringRef ArchitectureName) {
165 if (!MachOObjectFile::isValidArch(ArchFlag: ArchitectureName)) {
166 std::string Buf;
167 raw_string_ostream OS(Buf);
168 for (StringRef Arch : MachOObjectFile::getValidArchs())
169 OS << Arch << " ";
170
171 return createStringError(
172 EC: std::errc::invalid_argument,
173 Fmt: "invalid architecture '%s': valid architecture names are %s",
174 Vals: ArchitectureName.str().c_str(), Vals: Buf.c_str());
175 }
176 return Error::success();
177}
178
179static uint64_t getCPUID(uint32_t CPUType, uint32_t CPUSubtype) {
180 switch (CPUType) {
181 case MachO::CPU_TYPE_ARM:
182 case MachO::CPU_TYPE_ARM64:
183 case MachO::CPU_TYPE_ARM64_32:
184 case MachO::CPU_TYPE_X86_64:
185 // We consider CPUSubtype only for the above 4 CPUTypes to match cctools'
186 // libtool behavior.
187 return static_cast<uint64_t>(CPUType) << 32 | CPUSubtype;
188 default:
189 return CPUType;
190 }
191}
192
193// MembersData is an organized collection of members.
194struct MembersData {
195 // MembersPerArchitectureMap is a mapping from CPU architecture to a list of
196 // members.
197 MembersPerArchitectureMap MembersPerArchitecture;
198 std::vector<std::unique_ptr<MemoryBuffer>> FileBuffers;
199};
200
201// NewArchiveMemberList instances serve as collections of archive members and
202// information about those members.
203class NewArchiveMemberList {
204 std::vector<NewArchiveMember> Members;
205 // This vector contains the file that each NewArchiveMember from Members came
206 // from. Therefore, it has the same size as Members.
207 std::vector<StringRef> Files;
208
209public:
210 // Add a NewArchiveMember and the file it came from to the list.
211 void push_back(NewArchiveMember &&Member, StringRef File) {
212 Members.push_back(x: std::move(Member));
213 Files.push_back(x: File);
214 }
215
216 ArrayRef<NewArchiveMember> getMembers() const { return Members; }
217
218 ArrayRef<StringRef> getFiles() const { return Files; }
219
220 static_assert(
221 std::is_same<decltype(MembersData::MembersPerArchitecture)::mapped_type,
222 NewArchiveMemberList>(),
223 "This test makes sure NewArchiveMemberList is used by MembersData since "
224 "the following asserts test invariants required for MembersData.");
225 static_assert(
226 !std::is_copy_constructible_v<
227 decltype(NewArchiveMemberList::Members)::value_type>,
228 "MembersData::MembersPerArchitecture has a dependency on "
229 "MembersData::FileBuffers so it should not be able to "
230 "be copied on its own without FileBuffers. Unfortunately, "
231 "is_copy_constructible does not detect whether the container (ie vector) "
232 "of a non-copyable type is itself non-copyable so we have to test the "
233 "actual type of the stored data (ie, value_type).");
234 static_assert(
235 !std::is_copy_assignable_v<
236 decltype(NewArchiveMemberList::Members)::value_type>,
237 "MembersData::MembersPerArchitecture has a dependency on "
238 "MembersData::FileBuffers so it should not be able to "
239 "be copied on its own without FileBuffers. Unfortunately, "
240 "is_copy_constructible does not detect whether the container (ie vector) "
241 "of a non-copyable type is itself non-copyable so we have to test the "
242 "actual type of the stored data (ie, value_type).");
243};
244
245// MembersBuilder collects and organizes all members from the files provided by
246// the user.
247class MembersBuilder {
248public:
249 MembersBuilder(LLVMContext &LLVMCtx, const Config &C)
250 : LLVMCtx(LLVMCtx), C(C) {}
251
252 Expected<MembersData> build() {
253 for (StringRef FileName : InputFiles)
254 if (Error E = AddMember(*this, FileName)())
255 return std::move(E);
256
257 std::string Arch = ArchType.value_or(u: "");
258 if (!Arch.empty()) {
259 uint64_t ArchCPUID = getCPUID(CPUType: C.ArchCPUType, CPUSubtype: C.ArchCPUSubtype);
260 if (Data.MembersPerArchitecture.find(x: ArchCPUID) ==
261 Data.MembersPerArchitecture.end())
262 return createStringError(EC: std::errc::invalid_argument,
263 Fmt: "no library created (no object files in input "
264 "files matching -arch_only %s)",
265 Vals: Arch.c_str());
266 }
267 return std::move(Data);
268 }
269
270private:
271 class AddMember {
272 MembersBuilder &Builder;
273 StringRef FileName;
274
275 public:
276 AddMember(MembersBuilder &Builder, StringRef FileName)
277 : Builder(Builder), FileName(FileName) {}
278
279 Error operator()() {
280 Expected<NewArchiveMember> NewMemberOrErr =
281 NewArchiveMember::getFile(FileName, Deterministic: Builder.C.Deterministic);
282 if (!NewMemberOrErr)
283 return createFileError(F: FileName, E: NewMemberOrErr.takeError());
284 auto &NewMember = *NewMemberOrErr;
285
286 // For regular archives, use the basename of the object path for the
287 // member name.
288 NewMember.MemberName = sys::path::filename(path: NewMember.MemberName);
289 file_magic Magic = identify_magic(magic: NewMember.Buf->getBuffer());
290
291 // Flatten archives.
292 if (Magic == file_magic::archive)
293 return addArchiveMembers(NewMember: std::move(NewMember));
294
295 // Flatten universal files.
296 if (Magic == file_magic::macho_universal_binary)
297 return addUniversalMembers(NewMember: std::move(NewMember));
298
299 // Bitcode files.
300 if (Magic == file_magic::bitcode)
301 return verifyAndAddIRObject(Member: std::move(NewMember));
302
303 return verifyAndAddMachOObject(Member: std::move(NewMember));
304 }
305
306 private:
307 // Check that a file's architecture [FileCPUType, FileCPUSubtype]
308 // matches the architecture specified under -arch_only flag.
309 bool acceptFileArch(uint32_t FileCPUType, uint32_t FileCPUSubtype) {
310 if (Builder.C.ArchCPUType != FileCPUType)
311 return false;
312
313 switch (Builder.C.ArchCPUType) {
314 case MachO::CPU_TYPE_ARM:
315 case MachO::CPU_TYPE_ARM64_32:
316 case MachO::CPU_TYPE_X86_64:
317 return Builder.C.ArchCPUSubtype == FileCPUSubtype;
318
319 case MachO::CPU_TYPE_ARM64:
320 if (Builder.C.ArchCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL)
321 return FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL ||
322 FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_V8;
323 else
324 return Builder.C.ArchCPUSubtype == FileCPUSubtype;
325
326 default:
327 return true;
328 }
329 }
330
331 Error verifyAndAddMachOObject(NewArchiveMember Member) {
332 auto MBRef = Member.Buf->getMemBufferRef();
333 Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr =
334 object::ObjectFile::createObjectFile(Object: MBRef);
335
336 // Throw error if not a valid object file.
337 if (!ObjOrErr)
338 return createFileError(F: Member.MemberName, E: ObjOrErr.takeError());
339
340 // Throw error if not in Mach-O format.
341 if (!isa<object::MachOObjectFile>(Val: **ObjOrErr))
342 return createStringError(EC: std::errc::invalid_argument,
343 Fmt: "'%s': format not supported",
344 Vals: Member.MemberName.data());
345
346 auto *O = cast<MachOObjectFile>(Val: ObjOrErr->get());
347 uint32_t FileCPUType, FileCPUSubtype;
348 std::tie(args&: FileCPUType, args&: FileCPUSubtype) = MachO::getCPUTypeFromArchitecture(
349 Arch: MachO::getArchitectureFromName(Name: O->getArchTriple().getArchName()));
350
351 // If -arch_only is specified then skip this file if it doesn't match
352 // the architecture specified.
353 if (ArchType && !acceptFileArch(FileCPUType, FileCPUSubtype)) {
354 return Error::success();
355 }
356
357 if (!NoWarningForNoSymbols && O->symbols().empty()) {
358 Error E = createFileError(
359 F: Member.MemberName,
360 E: createStringError(EC: std::errc::invalid_argument,
361 Fmt: "has no symbols for architecture %s",
362 Vals: O->getArchTriple().getArchName().str().c_str()));
363
364 if (WarningsAsErrors)
365 return E;
366 WithColor::defaultWarningHandler(Warning: std::move(E));
367 }
368
369 uint64_t FileCPUID = getCPUID(CPUType: FileCPUType, CPUSubtype: FileCPUSubtype);
370 Builder.Data.MembersPerArchitecture[FileCPUID].push_back(
371 Member: std::move(Member), File: FileName);
372 return Error::success();
373 }
374
375 Error verifyAndAddIRObject(NewArchiveMember Member) {
376 auto MBRef = Member.Buf->getMemBufferRef();
377 Expected<std::unique_ptr<object::IRObjectFile>> IROrErr =
378 object::IRObjectFile::create(Object: MBRef, Context&: Builder.LLVMCtx);
379
380 // Throw error if not a valid IR object file.
381 if (!IROrErr)
382 return createFileError(F: Member.MemberName, E: IROrErr.takeError());
383
384 Triple TT = Triple(IROrErr->get()->getTargetTriple());
385
386 Expected<uint32_t> FileCPUTypeOrErr = MachO::getCPUType(T: TT);
387 if (!FileCPUTypeOrErr)
388 return FileCPUTypeOrErr.takeError();
389
390 Expected<uint32_t> FileCPUSubTypeOrErr = MachO::getCPUSubType(T: TT);
391 if (!FileCPUSubTypeOrErr)
392 return FileCPUSubTypeOrErr.takeError();
393
394 // If -arch_only is specified then skip this file if it doesn't match
395 // the architecture specified.
396 if (ArchType &&
397 !acceptFileArch(FileCPUType: *FileCPUTypeOrErr, FileCPUSubtype: *FileCPUSubTypeOrErr)) {
398 return Error::success();
399 }
400
401 uint64_t FileCPUID = getCPUID(CPUType: *FileCPUTypeOrErr, CPUSubtype: *FileCPUSubTypeOrErr);
402 Builder.Data.MembersPerArchitecture[FileCPUID].push_back(
403 Member: std::move(Member), File: FileName);
404 return Error::success();
405 }
406
407 Error addChildMember(const object::Archive::Child &M) {
408 Expected<NewArchiveMember> NewMemberOrErr =
409 NewArchiveMember::getOldMember(OldMember: M, Deterministic: Builder.C.Deterministic);
410 if (!NewMemberOrErr)
411 return NewMemberOrErr.takeError();
412 auto &NewMember = *NewMemberOrErr;
413
414 file_magic Magic = identify_magic(magic: NewMember.Buf->getBuffer());
415
416 if (Magic == file_magic::bitcode)
417 return verifyAndAddIRObject(Member: std::move(NewMember));
418
419 return verifyAndAddMachOObject(Member: std::move(NewMember));
420 }
421
422 Error processArchive(object::Archive &Lib) {
423 Error Err = Error::success();
424 for (const object::Archive::Child &Child : Lib.children(Err))
425 if (Error E = addChildMember(M: Child))
426 return createFileError(F: FileName, E: std::move(E));
427 if (Err)
428 return createFileError(F: FileName, E: std::move(Err));
429
430 return Error::success();
431 }
432
433 Error addArchiveMembers(NewArchiveMember NewMember) {
434 Expected<std::unique_ptr<Archive>> LibOrErr =
435 object::Archive::create(Source: NewMember.Buf->getMemBufferRef());
436 if (!LibOrErr)
437 return createFileError(F: FileName, E: LibOrErr.takeError());
438
439 if (Error E = processArchive(Lib&: **LibOrErr))
440 return E;
441
442 // Update vector FileBuffers with the MemoryBuffers to transfer
443 // ownership.
444 Builder.Data.FileBuffers.push_back(x: std::move(NewMember.Buf));
445 return Error::success();
446 }
447
448 Error addUniversalMembers(NewArchiveMember NewMember) {
449 Expected<std::unique_ptr<MachOUniversalBinary>> BinaryOrErr =
450 MachOUniversalBinary::create(Source: NewMember.Buf->getMemBufferRef());
451 if (!BinaryOrErr)
452 return createFileError(F: FileName, E: BinaryOrErr.takeError());
453
454 auto *UO = BinaryOrErr->get();
455 for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) {
456
457 Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrErr =
458 O.getAsObjectFile();
459 if (MachOObjOrErr) {
460 NewArchiveMember NewMember =
461 NewArchiveMember(MachOObjOrErr->get()->getMemoryBufferRef());
462 NewMember.MemberName = sys::path::filename(path: NewMember.MemberName);
463
464 if (Error E = verifyAndAddMachOObject(Member: std::move(NewMember)))
465 return E;
466 continue;
467 }
468
469 Expected<std::unique_ptr<IRObjectFile>> IRObjectOrError =
470 O.getAsIRObject(Ctx&: Builder.LLVMCtx);
471 if (IRObjectOrError) {
472 // A universal file member can be a MachOObjectFile, an IRObject or an
473 // Archive. In case we can successfully cast the member as an
474 // IRObject, it is safe to throw away the error generated due to
475 // casting the object as a MachOObjectFile.
476 consumeError(Err: MachOObjOrErr.takeError());
477
478 NewArchiveMember NewMember =
479 NewArchiveMember(IRObjectOrError->get()->getMemoryBufferRef());
480 NewMember.MemberName = sys::path::filename(path: NewMember.MemberName);
481
482 if (Error E = verifyAndAddIRObject(Member: std::move(NewMember)))
483 return E;
484 continue;
485 }
486
487 Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive();
488 if (ArchiveOrError) {
489 // A universal file member can be a MachOObjectFile, an IRObject or an
490 // Archive. In case we can successfully cast the member as an Archive,
491 // it is safe to throw away the error generated due to casting the
492 // object as a MachOObjectFile.
493 consumeError(Err: MachOObjOrErr.takeError());
494 consumeError(Err: IRObjectOrError.takeError());
495
496 if (Error E = processArchive(Lib&: **ArchiveOrError))
497 return E;
498 continue;
499 }
500
501 Error CombinedError = joinErrors(
502 E1: ArchiveOrError.takeError(),
503 E2: joinErrors(E1: IRObjectOrError.takeError(), E2: MachOObjOrErr.takeError()));
504 return createFileError(F: FileName, E: std::move(CombinedError));
505 }
506
507 // Update vector FileBuffers with the MemoryBuffers to transfer
508 // ownership.
509 Builder.Data.FileBuffers.push_back(x: std::move(NewMember.Buf));
510 return Error::success();
511 }
512 };
513
514 MembersData Data;
515 LLVMContext &LLVMCtx;
516 const Config &C;
517};
518
519static Expected<SmallVector<Slice, 2>>
520buildSlices(LLVMContext &LLVMCtx,
521 ArrayRef<OwningBinary<Archive>> OutputBinaries) {
522 SmallVector<Slice, 2> Slices;
523
524 for (const auto &OB : OutputBinaries) {
525 const Archive &A = *OB.getBinary();
526 Expected<Slice> ArchiveSlice = Slice::create(A, LLVMCtx: &LLVMCtx);
527 if (!ArchiveSlice)
528 return ArchiveSlice.takeError();
529 Slices.push_back(Elt: *ArchiveSlice);
530 }
531 return Slices;
532}
533
534static Error
535checkForDuplicates(const MembersPerArchitectureMap &MembersPerArch) {
536 for (const auto &M : MembersPerArch) {
537 ArrayRef<NewArchiveMember> Members = M.second.getMembers();
538 ArrayRef<StringRef> Files = M.second.getFiles();
539 MapVector<StringRef, SmallVector<StringRef, 1>> MembersToFiles;
540 for (auto Iterators = std::make_pair(x: Members.begin(), y: Files.begin());
541 Iterators.first != Members.end();
542 ++Iterators.first, ++Iterators.second) {
543 assert(Iterators.second != Files.end() &&
544 "Files should be the same size as Members.");
545 MembersToFiles[Iterators.first->MemberName].push_back(Elt: *Iterators.second);
546 }
547
548 std::string ErrorData;
549 raw_string_ostream ErrorStream(ErrorData);
550 for (const auto &[Key, Value] : MembersToFiles) {
551 if (Value.size() > 1) {
552 ErrorStream << "file '" << Key << "' was specified multiple times.\n";
553
554 for (StringRef OriginalFile : Value)
555 ErrorStream << "in: " << OriginalFile.str() << '\n';
556
557 ErrorStream << '\n';
558 }
559 }
560
561 if (ErrorData.size() > 0)
562 return createStringError(EC: std::errc::invalid_argument, Fmt: ErrorData.c_str());
563 }
564 return Error::success();
565}
566
567static Error createStaticLibrary(LLVMContext &LLVMCtx, const Config &C) {
568 MembersBuilder Builder(LLVMCtx, C);
569 auto DataOrError = Builder.build();
570 if (auto Error = DataOrError.takeError())
571 return Error;
572
573 const auto &NewMembers = DataOrError->MembersPerArchitecture;
574
575 if (Error E = checkForDuplicates(MembersPerArch: NewMembers)) {
576 if (WarningsAsErrors)
577 return E;
578 WithColor::defaultWarningHandler(Warning: std::move(E));
579 }
580
581 if (NewMembers.size() == 1)
582 return writeArchive(ArcName: OutputFile, NewMembers: NewMembers.begin()->second.getMembers(),
583 WriteSymtab: SymtabWritingMode::NormalSymtab,
584 /*Kind=*/object::Archive::K_DARWIN, Deterministic: C.Deterministic,
585 /*Thin=*/false);
586
587 SmallVector<OwningBinary<Archive>, 2> OutputBinaries;
588 for (const std::pair<const uint64_t, NewArchiveMemberList> &M : NewMembers) {
589 Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr =
590 writeArchiveToBuffer(
591 NewMembers: M.second.getMembers(), WriteSymtab: SymtabWritingMode::NormalSymtab,
592 /*Kind=*/object::Archive::K_DARWIN, Deterministic: C.Deterministic,
593 /*Thin=*/false);
594 if (!OutputBufferOrErr)
595 return OutputBufferOrErr.takeError();
596 std::unique_ptr<MemoryBuffer> &OutputBuffer = OutputBufferOrErr.get();
597
598 Expected<std::unique_ptr<Archive>> ArchiveOrError =
599 Archive::create(Source: OutputBuffer->getMemBufferRef());
600 if (!ArchiveOrError)
601 return ArchiveOrError.takeError();
602 std::unique_ptr<Archive> &A = ArchiveOrError.get();
603
604 OutputBinaries.push_back(
605 Elt: OwningBinary<Archive>(std::move(A), std::move(OutputBuffer)));
606 }
607
608 Expected<SmallVector<Slice, 2>> Slices = buildSlices(LLVMCtx, OutputBinaries);
609 if (!Slices)
610 return Slices.takeError();
611
612 llvm::stable_sort(Range&: *Slices);
613 return writeUniversalBinary(Slices: *Slices, OutputFileName: OutputFile);
614}
615
616static void parseRawArgs(int Argc, char **Argv) {
617 LibtoolDarwinOptTable Tbl;
618 llvm::BumpPtrAllocator A;
619 llvm::StringSaver Saver{A};
620 opt::InputArgList Args =
621 Tbl.parseArgs(Argc, Argv, Unknown: OPT_UNKNOWN, Saver, ErrorFn: [&](StringRef Msg) {
622 llvm::errs() << Msg << '\n';
623 std::exit(status: 1);
624 });
625
626 if (Args.hasArg(Ids: OPT_help)) {
627 Tbl.printHelp(OS&: llvm::outs(), Usage: "llvm-libtool-darwin [options] <input files>",
628 Title: "llvm-libtool-darwin");
629 std::exit(status: 0);
630 }
631
632 InputFiles = Args.getAllArgValues(Id: OPT_INPUT);
633 Libraries = Args.getAllArgValues(Id: OPT_libraries);
634 LibrarySearchDirs = Args.getAllArgValues(Id: OPT_librarySearchDirs);
635
636 if (const opt::Arg *A = Args.getLastArg(Ids: OPT_outputFile))
637 OutputFile = A->getValue();
638
639 if (const opt::Arg *A = Args.getLastArg(Ids: OPT_archType))
640 ArchType = std::make_optional(t: A->getValue());
641
642 if (const opt::Arg *A = Args.getLastArg(Ids: OPT_fileList))
643 FileList = A->getValue();
644
645 if (const opt::Arg *A = Args.getLastArg(Ids: OPT_dependencyInfoPath))
646 DependencyInfoPath = A->getValue();
647
648 LibraryOperation =
649 Args.hasArg(Ids: OPT_static) ? Operation::Static : Operation::None;
650 DeterministicOption = Args.hasArg(Ids: OPT_deterministicOption);
651 NonDeterministicOption = Args.hasArg(Ids: OPT_nonDeterministicOption);
652 VersionOption = Args.hasArg(Ids: OPT_version);
653 NoWarningForNoSymbols = Args.hasArg(Ids: OPT_noWarningForNoSymbols);
654 WarningsAsErrors = Args.hasArg(Ids: OPT_warningsAsErrors);
655}
656
657static Expected<Config> parseCommandLine(int Argc, char **Argv) {
658 Config C;
659 parseRawArgs(Argc, Argv);
660
661 if (LibraryOperation == Operation::None) {
662 if (!VersionOption) {
663 return createStringError(EC: std::errc::invalid_argument,
664 Fmt: "-static option: must be specified");
665 }
666 return C;
667 }
668
669 GlobalDependencyInfo =
670 DependencyInfoPath.empty()
671 ? std::make_unique<DummyDependencyInfo>()
672 : std::make_unique<DependencyInfo>(args&: DependencyInfoPath);
673
674 if (OutputFile.empty()) {
675 return createStringError(EC: std::errc::invalid_argument,
676 Fmt: "-o option: must be specified");
677 }
678
679 if (DeterministicOption && NonDeterministicOption)
680 return createStringError(EC: std::errc::invalid_argument,
681 Fmt: "cannot specify both -D and -U flags");
682 else if (NonDeterministicOption)
683 C.Deterministic = false;
684
685 if (!Libraries.empty())
686 if (Error E = processCommandLineLibraries())
687 return std::move(E);
688
689 if (!FileList.empty())
690 if (Error E = processFileList())
691 return std::move(E);
692
693 if (InputFiles.empty())
694 return createStringError(EC: std::errc::invalid_argument,
695 Fmt: "no input files specified");
696
697 if (ArchType) {
698 if (Error E = validateArchitectureName(ArchitectureName: ArchType.value()))
699 return std::move(E);
700
701 std::tie(args&: C.ArchCPUType, args&: C.ArchCPUSubtype) =
702 MachO::getCPUTypeFromArchitecture(
703 Arch: MachO::getArchitectureFromName(Name: ArchType.value()));
704 }
705
706 GlobalDependencyInfo->write(Version: "llvm-libtool-darwin " LLVM_VERSION_STRING,
707 Inputs: InputFiles, Output: OutputFile);
708
709 return C;
710}
711
712int llvm_libtool_darwin_main(int Argc, char **Argv, const llvm::ToolContext &) {
713 Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
714 if (!ConfigOrErr) {
715 WithColor::defaultErrorHandler(Err: ConfigOrErr.takeError());
716 return EXIT_FAILURE;
717 }
718
719 if (VersionOption)
720 cl::PrintVersionMessage();
721
722 llvm::InitializeAllTargetInfos();
723 llvm::InitializeAllTargetMCs();
724 llvm::InitializeAllAsmParsers();
725
726 LLVMContext LLVMCtx;
727 Config C = *ConfigOrErr;
728 switch (LibraryOperation) {
729 case Operation::None:
730 break;
731 case Operation::Static:
732 if (Error E = createStaticLibrary(LLVMCtx, C)) {
733 WithColor::defaultErrorHandler(Err: std::move(E));
734 return EXIT_FAILURE;
735 }
736 break;
737 }
738 return EXIT_SUCCESS;
739}
740