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