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/Object/ArchiveWriter.h"
15 #include "llvm/Object/MachO.h"
16 #include "llvm/Object/MachOUniversal.h"
17 #include "llvm/Object/MachOUniversalWriter.h"
18 #include "llvm/Object/ObjectFile.h"
19 #include "llvm/Support/CommandLine.h"
20 #include "llvm/Support/InitLLVM.h"
21 #include "llvm/Support/LineIterator.h"
22 #include "llvm/Support/WithColor.h"
23 #include "llvm/TextAPI/MachO/Architecture.h"
24 #include <map>
25 
26 using namespace llvm;
27 using namespace llvm::object;
28 
29 typedef std::map<uint64_t, std::vector<NewArchiveMember>>
30     MembersPerArchitectureMap;
31 
32 cl::OptionCategory LibtoolCategory("llvm-libtool-darwin Options");
33 
34 static cl::opt<std::string> OutputFile("o", cl::desc("Specify output filename"),
35                                        cl::value_desc("filename"),
36                                        cl::cat(LibtoolCategory));
37 
38 static cl::list<std::string> InputFiles(cl::Positional,
39                                         cl::desc("<input files>"),
40                                         cl::ZeroOrMore,
41                                         cl::cat(LibtoolCategory));
42 
43 static cl::opt<std::string> ArchType(
44     "arch_only", cl::desc("Specify architecture type for output library"),
45     cl::value_desc("arch_type"), cl::ZeroOrMore, cl::cat(LibtoolCategory));
46 
47 enum class Operation { None, Static };
48 
49 static cl::opt<Operation> LibraryOperation(
50     cl::desc("Library Type: "),
51     cl::values(
52         clEnumValN(Operation::Static, "static",
53                    "Produce a statically linked library from the input files")),
54     cl::init(Operation::None), cl::cat(LibtoolCategory));
55 
56 static cl::opt<bool> DeterministicOption(
57     "D", cl::desc("Use zero for timestamps and UIDs/GIDs (Default)"),
58     cl::init(false), cl::cat(LibtoolCategory));
59 
60 static cl::opt<bool>
61     NonDeterministicOption("U", cl::desc("Use actual timestamps and UIDs/GIDs"),
62                            cl::init(false), cl::cat(LibtoolCategory));
63 
64 static cl::opt<std::string>
65     FileList("filelist",
66              cl::desc("Pass in file containing a list of filenames"),
67              cl::value_desc("listfile[,dirname]"), cl::cat(LibtoolCategory));
68 
69 static cl::list<std::string> Libraries(
70     "l",
71     cl::desc(
72         "l<x> searches for the library libx.a in the library search path. If"
73         " the string 'x' ends with '.o', then the library 'x' is searched for"
74         " without prepending 'lib' or appending '.a'"),
75     cl::ZeroOrMore, cl::Prefix, cl::cat(LibtoolCategory));
76 
77 static cl::list<std::string> LibrarySearchDirs(
78     "L",
79     cl::desc(
80         "L<dir> adds <dir> to the list of directories in which to search for"
81         " libraries"),
82     cl::ZeroOrMore, cl::Prefix, cl::cat(LibtoolCategory));
83 
84 static cl::opt<bool>
85     VersionOption("V", cl::desc("Print the version number and exit"),
86                   cl::cat(LibtoolCategory));
87 
88 static const std::array<std::string, 3> StandardSearchDirs{
89     "/lib",
90     "/usr/lib",
91     "/usr/local/lib",
92 };
93 
94 struct Config {
95   bool Deterministic = true; // Updated by 'D' and 'U' modifiers.
96   uint32_t ArchCPUType;
97   uint32_t ArchCPUSubtype;
98 };
99 
100 static Expected<std::string> searchForFile(const Twine &FileName) {
101 
102   auto FindLib =
103       [FileName](ArrayRef<std::string> SearchDirs) -> Optional<std::string> {
104     for (StringRef Dir : SearchDirs) {
105       SmallString<128> Path;
106       sys::path::append(Path, Dir, FileName);
107 
108       if (sys::fs::exists(Path))
109         return std::string(Path);
110     }
111     return None;
112   };
113 
114   Optional<std::string> Found = FindLib(LibrarySearchDirs);
115   if (!Found)
116     Found = FindLib(StandardSearchDirs);
117   if (Found)
118     return *Found;
119 
120   return createStringError(std::errc::invalid_argument,
121                            "cannot locate file '%s'", FileName.str().c_str());
122 }
123 
124 static Error processCommandLineLibraries() {
125   for (StringRef BaseName : Libraries) {
126     Expected<std::string> FullPath = searchForFile(
127         BaseName.endswith(".o") ? BaseName.str() : "lib" + BaseName + ".a");
128     if (!FullPath)
129       return FullPath.takeError();
130     InputFiles.push_back(FullPath.get());
131   }
132 
133   return Error::success();
134 }
135 
136 static Error processFileList() {
137   StringRef FileName, DirName;
138   std::tie(FileName, DirName) = StringRef(FileList).rsplit(",");
139 
140   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
141       MemoryBuffer::getFileOrSTDIN(FileName, /*FileSize=*/-1,
142                                    /*RequiresNullTerminator=*/false);
143   if (std::error_code EC = FileOrErr.getError())
144     return createFileError(FileName, errorCodeToError(EC));
145   const MemoryBuffer &Ref = *FileOrErr.get();
146 
147   line_iterator I(Ref, /*SkipBlanks=*/false);
148   if (I.is_at_eof())
149     return createStringError(std::errc::invalid_argument,
150                              "file list file: '%s' is empty",
151                              FileName.str().c_str());
152   for (; !I.is_at_eof(); ++I) {
153     StringRef Line = *I;
154     if (Line.empty())
155       return createStringError(std::errc::invalid_argument,
156                                "file list file: '%s': filename cannot be empty",
157                                FileName.str().c_str());
158 
159     SmallString<128> Path;
160     if (!DirName.empty())
161       sys::path::append(Path, DirName, Line);
162     else
163       sys::path::append(Path, Line);
164     InputFiles.push_back(static_cast<std::string>(Path));
165   }
166   return Error::success();
167 }
168 
169 static Error validateArchitectureName(StringRef ArchitectureName) {
170   if (!MachOObjectFile::isValidArch(ArchitectureName)) {
171     std::string Buf;
172     raw_string_ostream OS(Buf);
173     for (StringRef Arch : MachOObjectFile::getValidArchs())
174       OS << Arch << " ";
175 
176     return createStringError(
177         std::errc::invalid_argument,
178         "invalid architecture '%s': valid architecture names are %s",
179         ArchitectureName.str().c_str(), OS.str().c_str());
180   }
181   return Error::success();
182 }
183 
184 static uint64_t getCPUID(uint32_t CPUType, uint32_t CPUSubtype) {
185   switch (CPUType) {
186   case MachO::CPU_TYPE_ARM:
187   case MachO::CPU_TYPE_ARM64:
188   case MachO::CPU_TYPE_ARM64_32:
189   case MachO::CPU_TYPE_X86_64:
190     // We consider CPUSubtype only for the above 4 CPUTypes to match cctools'
191     // libtool behavior.
192     return static_cast<uint64_t>(CPUType) << 32 | CPUSubtype;
193   default:
194     return CPUType;
195   }
196 }
197 
198 // Check that a file's architecture [FileCPUType, FileCPUSubtype]
199 // matches the architecture specified under -arch_only flag.
200 static bool acceptFileArch(uint32_t FileCPUType, uint32_t FileCPUSubtype,
201                            const Config &C) {
202   if (C.ArchCPUType != FileCPUType)
203     return false;
204 
205   switch (C.ArchCPUType) {
206   case MachO::CPU_TYPE_ARM:
207   case MachO::CPU_TYPE_ARM64_32:
208   case MachO::CPU_TYPE_X86_64:
209     return C.ArchCPUSubtype == FileCPUSubtype;
210 
211   case MachO::CPU_TYPE_ARM64:
212     if (C.ArchCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL)
213       return FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL ||
214              FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_V8;
215     else
216       return C.ArchCPUSubtype == FileCPUSubtype;
217 
218   default:
219     return true;
220   }
221 }
222 
223 static Error verifyAndAddMachOObject(MembersPerArchitectureMap &Members,
224                                      NewArchiveMember Member, const Config &C) {
225   auto MBRef = Member.Buf->getMemBufferRef();
226   Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr =
227       object::ObjectFile::createObjectFile(MBRef);
228 
229   // Throw error if not a valid object file.
230   if (!ObjOrErr)
231     return createFileError(Member.MemberName, ObjOrErr.takeError());
232 
233   // Throw error if not in Mach-O format.
234   if (!isa<object::MachOObjectFile>(**ObjOrErr))
235     return createStringError(std::errc::invalid_argument,
236                              "'%s': format not supported",
237                              Member.MemberName.data());
238 
239   auto *O = dyn_cast<MachOObjectFile>(ObjOrErr->get());
240   uint32_t FileCPUType, FileCPUSubtype;
241   std::tie(FileCPUType, FileCPUSubtype) = MachO::getCPUTypeFromArchitecture(
242       MachO::getArchitectureFromName(O->getArchTriple().getArchName()));
243 
244   // If -arch_only is specified then skip this file if it doesn't match
245   // the architecture specified.
246   if (!ArchType.empty() && !acceptFileArch(FileCPUType, FileCPUSubtype, C)) {
247     return Error::success();
248   }
249 
250   uint64_t FileCPUID = getCPUID(FileCPUType, FileCPUSubtype);
251   Members[FileCPUID].push_back(std::move(Member));
252   return Error::success();
253 }
254 
255 static Error addChildMember(MembersPerArchitectureMap &Members,
256                             const object::Archive::Child &M, const Config &C) {
257   Expected<NewArchiveMember> NMOrErr =
258       NewArchiveMember::getOldMember(M, C.Deterministic);
259   if (!NMOrErr)
260     return NMOrErr.takeError();
261 
262   if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C))
263     return E;
264 
265   return Error::success();
266 }
267 
268 static Error processArchive(MembersPerArchitectureMap &Members,
269                             object::Archive &Lib, StringRef FileName,
270                             const Config &C) {
271   Error Err = Error::success();
272   for (const object::Archive::Child &Child : Lib.children(Err))
273     if (Error E = addChildMember(Members, Child, C))
274       return createFileError(FileName, std::move(E));
275   if (Err)
276     return createFileError(FileName, std::move(Err));
277 
278   return Error::success();
279 }
280 
281 static Error
282 addArchiveMembers(MembersPerArchitectureMap &Members,
283                   std::vector<std::unique_ptr<MemoryBuffer>> &ArchiveBuffers,
284                   NewArchiveMember NM, StringRef FileName, const Config &C) {
285   Expected<std::unique_ptr<Archive>> LibOrErr =
286       object::Archive::create(NM.Buf->getMemBufferRef());
287   if (!LibOrErr)
288     return createFileError(FileName, LibOrErr.takeError());
289 
290   if (Error E = processArchive(Members, **LibOrErr, FileName, C))
291     return E;
292 
293   // Update vector ArchiveBuffers with the MemoryBuffers to transfer
294   // ownership.
295   ArchiveBuffers.push_back(std::move(NM.Buf));
296   return Error::success();
297 }
298 
299 static Error addUniversalMembers(
300     MembersPerArchitectureMap &Members,
301     std::vector<std::unique_ptr<MemoryBuffer>> &UniversalBuffers,
302     NewArchiveMember NM, StringRef FileName, const Config &C) {
303   Expected<std::unique_ptr<MachOUniversalBinary>> BinaryOrErr =
304       MachOUniversalBinary::create(NM.Buf->getMemBufferRef());
305   if (!BinaryOrErr)
306     return createFileError(FileName, BinaryOrErr.takeError());
307 
308   auto *UO = BinaryOrErr->get();
309   for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) {
310 
311     Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrErr =
312         O.getAsObjectFile();
313     if (MachOObjOrErr) {
314       NewArchiveMember NewMember =
315           NewArchiveMember(MachOObjOrErr->get()->getMemoryBufferRef());
316       NewMember.MemberName = sys::path::filename(NewMember.MemberName);
317 
318       if (Error E = verifyAndAddMachOObject(Members, std::move(NewMember), C))
319         return E;
320       continue;
321     }
322 
323     Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive();
324     if (ArchiveOrError) {
325       // A universal file member can either be a MachOObjectFile or an Archive.
326       // In case we can successfully cast the member as an Archive, it is safe
327       // to throw away the error generated due to casting the object as a
328       // MachOObjectFile.
329       consumeError(MachOObjOrErr.takeError());
330 
331       if (Error E = processArchive(Members, **ArchiveOrError, FileName, C))
332         return E;
333       continue;
334     }
335 
336     Error CombinedError =
337         joinErrors(ArchiveOrError.takeError(), MachOObjOrErr.takeError());
338     return createFileError(FileName, std::move(CombinedError));
339   }
340 
341   // Update vector UniversalBuffers with the MemoryBuffers to transfer
342   // ownership.
343   UniversalBuffers.push_back(std::move(NM.Buf));
344   return Error::success();
345 }
346 
347 static Error addMember(MembersPerArchitectureMap &Members,
348                        std::vector<std::unique_ptr<MemoryBuffer>> &FileBuffers,
349                        StringRef FileName, const Config &C) {
350   Expected<NewArchiveMember> NMOrErr =
351       NewArchiveMember::getFile(FileName, C.Deterministic);
352   if (!NMOrErr)
353     return createFileError(FileName, NMOrErr.takeError());
354 
355   // For regular archives, use the basename of the object path for the member
356   // name.
357   NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
358   file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer());
359 
360   // Flatten archives.
361   if (Magic == file_magic::archive)
362     return addArchiveMembers(Members, FileBuffers, std::move(*NMOrErr),
363                              FileName, C);
364 
365   // Flatten universal files.
366   if (Magic == file_magic::macho_universal_binary)
367     return addUniversalMembers(Members, FileBuffers, std::move(*NMOrErr),
368                                FileName, C);
369 
370   if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C))
371     return E;
372   return Error::success();
373 }
374 
375 static Expected<SmallVector<Slice, 2>>
376 buildSlices(ArrayRef<OwningBinary<Archive>> OutputBinaries) {
377   SmallVector<Slice, 2> Slices;
378 
379   for (const auto &OB : OutputBinaries) {
380     const Archive *A = OB.getBinary();
381     Expected<Slice> ArchiveSlice = Slice::create(A);
382     if (!ArchiveSlice)
383       return ArchiveSlice.takeError();
384     Slices.push_back(*ArchiveSlice);
385   }
386   return Slices;
387 }
388 
389 static Error createStaticLibrary(const Config &C) {
390   MembersPerArchitectureMap NewMembers;
391   std::vector<std::unique_ptr<MemoryBuffer>> FileBuffers;
392   for (StringRef FileName : InputFiles)
393     if (Error E = addMember(NewMembers, FileBuffers, FileName, C))
394       return E;
395 
396   if (!ArchType.empty()) {
397     uint64_t ArchCPUID = getCPUID(C.ArchCPUType, C.ArchCPUSubtype);
398     if (NewMembers.find(ArchCPUID) == NewMembers.end())
399       return createStringError(std::errc::invalid_argument,
400                                "no library created (no object files in input "
401                                "files matching -arch_only %s)",
402                                ArchType.c_str());
403   }
404 
405   if (NewMembers.size() == 1) {
406     if (Error E =
407             writeArchive(OutputFile, NewMembers.begin()->second,
408                          /*WriteSymtab=*/true,
409                          /*Kind=*/object::Archive::K_DARWIN, C.Deterministic,
410                          /*Thin=*/false))
411       return E;
412   } else {
413     SmallVector<OwningBinary<Archive>, 2> OutputBinaries;
414     for (const std::pair<const uint64_t, std::vector<NewArchiveMember>> &M :
415          NewMembers) {
416       Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr =
417           writeArchiveToBuffer(M.second,
418                                /*WriteSymtab=*/true,
419                                /*Kind=*/object::Archive::K_DARWIN,
420                                C.Deterministic,
421                                /*Thin=*/false);
422       if (!OutputBufferOrErr)
423         return OutputBufferOrErr.takeError();
424       std::unique_ptr<MemoryBuffer> &OutputBuffer = OutputBufferOrErr.get();
425 
426       Expected<std::unique_ptr<Archive>> ArchiveOrError =
427           Archive::create(OutputBuffer->getMemBufferRef());
428       if (!ArchiveOrError)
429         return ArchiveOrError.takeError();
430       std::unique_ptr<Archive> &A = ArchiveOrError.get();
431 
432       OutputBinaries.push_back(
433           OwningBinary<Archive>(std::move(A), std::move(OutputBuffer)));
434     }
435 
436     Expected<SmallVector<Slice, 2>> Slices = buildSlices(OutputBinaries);
437     if (!Slices)
438       return Slices.takeError();
439 
440     llvm::stable_sort(*Slices);
441     if (Error E = writeUniversalBinary(*Slices, OutputFile))
442       return E;
443   }
444   return Error::success();
445 }
446 
447 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
448   Config C;
449   cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
450 
451   if (LibraryOperation == Operation::None) {
452     if (!VersionOption) {
453       std::string Error;
454       raw_string_ostream Stream(Error);
455       LibraryOperation.error("must be specified", "", Stream);
456       return createStringError(std::errc::invalid_argument, Error.c_str());
457     }
458     return C;
459   }
460 
461   if (OutputFile.empty()) {
462     std::string Error;
463     raw_string_ostream Stream(Error);
464     OutputFile.error("must be specified", "o", Stream);
465     return createStringError(std::errc::invalid_argument, Error.c_str());
466   }
467 
468   if (DeterministicOption && NonDeterministicOption)
469     return createStringError(std::errc::invalid_argument,
470                              "cannot specify both -D and -U flags");
471   else if (NonDeterministicOption)
472     C.Deterministic = false;
473 
474   if (!Libraries.empty())
475     if (Error E = processCommandLineLibraries())
476       return std::move(E);
477 
478   if (!FileList.empty())
479     if (Error E = processFileList())
480       return std::move(E);
481 
482   if (InputFiles.empty())
483     return createStringError(std::errc::invalid_argument,
484                              "no input files specified");
485 
486   if (ArchType.getNumOccurrences()) {
487     if (Error E = validateArchitectureName(ArchType))
488       return std::move(E);
489 
490     std::tie(C.ArchCPUType, C.ArchCPUSubtype) =
491         MachO::getCPUTypeFromArchitecture(
492             MachO::getArchitectureFromName(ArchType));
493   }
494 
495   return C;
496 }
497 
498 int main(int Argc, char **Argv) {
499   InitLLVM X(Argc, Argv);
500   cl::HideUnrelatedOptions({&LibtoolCategory, &ColorCategory});
501   Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
502   if (!ConfigOrErr) {
503     WithColor::defaultErrorHandler(ConfigOrErr.takeError());
504     return EXIT_FAILURE;
505   }
506 
507   if (VersionOption)
508     cl::PrintVersionMessage();
509 
510   Config C = *ConfigOrErr;
511   switch (LibraryOperation) {
512   case Operation::None:
513     break;
514   case Operation::Static:
515     if (Error E = createStaticLibrary(C)) {
516       WithColor::defaultErrorHandler(std::move(E));
517       return EXIT_FAILURE;
518     }
519     break;
520   }
521 }
522