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