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