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