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