llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

   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/VirtualFileSystem.h"
  25 #include "llvm/Support/WithColor.h"
  26 #include "llvm/TextAPI/Architecture.h"
  27 #include <map>
  28 #include <type_traits>
  29
  30 using namespace llvm;
  31 using namespace llvm::object;
  32
  33 static LLVMContext LLVMCtx;
  34
  35 typedef std::map<uint64_t, std::vector<NewArchiveMember>>
  36     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::ZeroOrMore,
  47                                         cl::cat(LibtoolCategory));
  48
  49 static cl::opt<std::string> ArchType(
  50     "arch_only", cl::desc("Specify architecture type for output library"),
  51     cl::value_desc("arch_type"), cl::ZeroOrMore, 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::ZeroOrMore, 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::ZeroOrMore, 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 const std::array<std::string, 3> StandardSearchDirs{
 100     "/lib",
 101     "/usr/lib",
 102     "/usr/local/lib",
 103 };
 104
 105 struct Config {
 106   bool Deterministic = true; // Updated by 'D' and 'U' modifiers.
 107   uint32_t ArchCPUType;
 108   uint32_t ArchCPUSubtype;
 109 };
 110
 111 static Expected<std::string> searchForFile(const Twine &FileName) {
 112
 113   auto FindLib =
 114       [FileName](ArrayRef<std::string> SearchDirs) -> Optional<std::string> {
 115     for (StringRef Dir : SearchDirs) {
 116       SmallString<128> Path;
 117       sys::path::append(Path, Dir, FileName);
 118
 119       if (sys::fs::exists(Path))
 120         return std::string(Path);
 121     }
 122     return None;
 123   };
 124
 125   Optional<std::string> Found = FindLib(LibrarySearchDirs);
 126   if (!Found)
 127     Found = FindLib(StandardSearchDirs);
 128   if (Found)
 129     return *Found;
 130
 131   return createStringError(std::errc::invalid_argument,
 132                            "cannot locate file '%s'", FileName.str().c_str());
 133 }
 134
 135 static Error processCommandLineLibraries() {
 136   for (StringRef BaseName : Libraries) {
 137     Expected<std::string> FullPath = searchForFile(
 138         BaseName.endswith(".o") ? BaseName.str() : "lib" + BaseName + ".a");
 139     if (!FullPath)
 140       return FullPath.takeError();
 141     InputFiles.push_back(FullPath.get());
 142   }
 143
 144   return Error::success();
 145 }
 146
 147 static Error processFileList() {
 148   StringRef FileName, DirName;
 149   std::tie(FileName, DirName) = StringRef(FileList).rsplit(",");
 150
 151   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
 152       MemoryBuffer::getFileOrSTDIN(FileName, /*IsText=*/false,
 153                                    /*RequiresNullTerminator=*/false);
 154   if (std::error_code EC = FileOrErr.getError())
 155     return createFileError(FileName, errorCodeToError(EC));
 156   const MemoryBuffer &Ref = *FileOrErr.get();
 157
 158   line_iterator I(Ref, /*SkipBlanks=*/false);
 159   if (I.is_at_eof())
 160     return createStringError(std::errc::invalid_argument,
 161                              "file list file: '%s' is empty",
 162                              FileName.str().c_str());
 163   for (; !I.is_at_eof(); ++I) {
 164     StringRef Line = *I;
 165     if (Line.empty())
 166       return createStringError(std::errc::invalid_argument,
 167                                "file list file: '%s': filename cannot be empty",
 168                                FileName.str().c_str());
 169
 170     SmallString<128> Path;
 171     if (!DirName.empty())
 172       sys::path::append(Path, DirName, Line);
 173     else
 174       sys::path::append(Path, Line);
 175     InputFiles.push_back(static_cast<std::string>(Path));
 176   }
 177   return Error::success();
 178 }
 179
 180 static Error validateArchitectureName(StringRef ArchitectureName) {
 181   if (!MachOObjectFile::isValidArch(ArchitectureName)) {
 182     std::string Buf;
 183     raw_string_ostream OS(Buf);
 184     for (StringRef Arch : MachOObjectFile::getValidArchs())
 185       OS << Arch << " ";
 186
 187     return createStringError(
 188         std::errc::invalid_argument,
 189         "invalid architecture '%s': valid architecture names are %s",
 190         ArchitectureName.str().c_str(), OS.str().c_str());
 191   }
 192   return Error::success();
 193 }
 194
 195 static uint64_t getCPUID(uint32_t CPUType, uint32_t CPUSubtype) {
 196   switch (CPUType) {
 197   case MachO::CPU_TYPE_ARM:
 198   case MachO::CPU_TYPE_ARM64:
 199   case MachO::CPU_TYPE_ARM64_32:
 200   case MachO::CPU_TYPE_X86_64:
 201     // We consider CPUSubtype only for the above 4 CPUTypes to match cctools'
 202     // libtool behavior.
 203     return static_cast<uint64_t>(CPUType) << 32 | CPUSubtype;
 204   default:
 205     return CPUType;
 206   }
 207 }
 208
 209 // MembersData is an organized collection of members.
 210 struct MembersData {
 211   // MembersPerArchitectureMap is a mapping from CPU architecture to a list of
 212   // members.
 213   MembersPerArchitectureMap MembersPerArchitecture;
 214   std::vector<std::unique_ptr<MemoryBuffer>> FileBuffers;
 215
 216   static_assert(!std::is_copy_constructible<NewArchiveMember>::value,
 217                 "MembersPerArchitecture has a dependency on FileBuffers so it "
 218                 "should not be able to be copied on its own without "
 219                 "FileBuffers.");
 220   static_assert(!std::is_copy_assignable<NewArchiveMember>::value,
 221                 "MembersPerArchitecture has a dependency on FileBuffers so it "
 222                 "should not be able to be copied on its own without "
 223                 "FileBuffers.");
 224 };
 225
 226 // MembersBuilder collects and organizes all members from the files provided by
 227 // the user.
 228 class MembersBuilder {
 229 public:
 230   MembersBuilder(const Config &C) : C(C) {}
 231
 232   Expected<MembersData> build() {
 233     for (StringRef FileName : InputFiles)
 234       if (Error E = addMember(FileName))
 235         return std::move(E);
 236
 237     if (!ArchType.empty()) {
 238       uint64_t ArchCPUID = getCPUID(C.ArchCPUType, C.ArchCPUSubtype);
 239       if (Data.MembersPerArchitecture.find(ArchCPUID) ==
 240           Data.MembersPerArchitecture.end())
 241         return createStringError(std::errc::invalid_argument,
 242                                  "no library created (no object files in input "
 243                                  "files matching -arch_only %s)",
 244                                  ArchType.c_str());
 245     }
 246     return std::move(Data);
 247   }
 248
 249 private:
 250   // Check that a file's architecture [FileCPUType, FileCPUSubtype]
 251   // matches the architecture specified under -arch_only flag.
 252   bool acceptFileArch(uint32_t FileCPUType, uint32_t FileCPUSubtype) {
 253     if (C.ArchCPUType != FileCPUType)
 254       return false;
 255
 256     switch (C.ArchCPUType) {
 257     case MachO::CPU_TYPE_ARM:
 258     case MachO::CPU_TYPE_ARM64_32:
 259     case MachO::CPU_TYPE_X86_64:
 260       return C.ArchCPUSubtype == FileCPUSubtype;
 261
 262     case MachO::CPU_TYPE_ARM64:
 263       if (C.ArchCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL)
 264         return FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL ||
 265                FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_V8;
 266       else
 267         return C.ArchCPUSubtype == FileCPUSubtype;
 268
 269     default:
 270       return true;
 271     }
 272   }
 273
 274   Error verifyAndAddMachOObject(NewArchiveMember Member) {
 275     auto MBRef = Member.Buf->getMemBufferRef();
 276     Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr =
 277         object::ObjectFile::createObjectFile(MBRef);
 278
 279     // Throw error if not a valid object file.
 280     if (!ObjOrErr)
 281       return createFileError(Member.MemberName, ObjOrErr.takeError());
 282
 283     // Throw error if not in Mach-O format.
 284     if (!isa<object::MachOObjectFile>(**ObjOrErr))
 285       return createStringError(std::errc::invalid_argument,
 286                                "'%s': format not supported",
 287                                Member.MemberName.data());
 288
 289     auto *O = dyn_cast<MachOObjectFile>(ObjOrErr->get());
 290     uint32_t FileCPUType, FileCPUSubtype;
 291     std::tie(FileCPUType, FileCPUSubtype) = MachO::getCPUTypeFromArchitecture(
 292         MachO::getArchitectureFromName(O->getArchTriple().getArchName()));
 293
 294     // If -arch_only is specified then skip this file if it doesn't match
 295     // the architecture specified.
 296     if (!ArchType.empty() && !acceptFileArch(FileCPUType, FileCPUSubtype)) {
 297       return Error::success();
 298     }
 299
 300     if (!NoWarningForNoSymbols && O->symbols().empty())
 301       WithColor::warning() << Member.MemberName + " has no symbols\n";
 302
 303     uint64_t FileCPUID = getCPUID(FileCPUType, FileCPUSubtype);
 304     Data.MembersPerArchitecture[FileCPUID].push_back(std::move(Member));
 305     return Error::success();
 306   }
 307
 308   Error verifyAndAddIRObject(NewArchiveMember Member) {
 309     auto MBRef = Member.Buf->getMemBufferRef();
 310     Expected<std::unique_ptr<object::IRObjectFile>> IROrErr =
 311         object::IRObjectFile::create(MBRef, LLVMCtx);
 312
 313     // Throw error if not a valid IR object file.
 314     if (!IROrErr)
 315       return createFileError(Member.MemberName, IROrErr.takeError());
 316
 317     Triple TT = Triple(IROrErr->get()->getTargetTriple());
 318
 319     Expected<uint32_t> FileCPUTypeOrErr = MachO::getCPUType(TT);
 320     if (!FileCPUTypeOrErr)
 321       return FileCPUTypeOrErr.takeError();
 322
 323     Expected<uint32_t> FileCPUSubTypeOrErr = MachO::getCPUSubType(TT);
 324     if (!FileCPUSubTypeOrErr)
 325       return FileCPUSubTypeOrErr.takeError();
 326
 327     // If -arch_only is specified then skip this file if it doesn't match
 328     // the architecture specified.
 329     if (!ArchType.empty() &&
 330         !acceptFileArch(*FileCPUTypeOrErr, *FileCPUSubTypeOrErr)) {
 331       return Error::success();
 332     }
 333
 334     uint64_t FileCPUID = getCPUID(*FileCPUTypeOrErr, *FileCPUSubTypeOrErr);
 335     Data.MembersPerArchitecture[FileCPUID].push_back(std::move(Member));
 336     return Error::success();
 337   }
 338
 339   Error addChildMember(const object::Archive::Child &M) {
 340     Expected<NewArchiveMember> NewMemberOrErr =
 341         NewArchiveMember::getOldMember(M, C.Deterministic);
 342     if (!NewMemberOrErr)
 343       return NewMemberOrErr.takeError();
 344     auto &NewMember = *NewMemberOrErr;
 345
 346     file_magic Magic = identify_magic(NewMember.Buf->getBuffer());
 347
 348     if (Magic == file_magic::bitcode)
 349       return verifyAndAddIRObject(std::move(NewMember));
 350
 351     return verifyAndAddMachOObject(std::move(NewMember));
 352   }
 353
 354   Error processArchive(object::Archive &Lib, StringRef FileName) {
 355     Error Err = Error::success();
 356     for (const object::Archive::Child &Child : Lib.children(Err))
 357       if (Error E = addChildMember(Child))
 358         return createFileError(FileName, std::move(E));
 359     if (Err)
 360       return createFileError(FileName, std::move(Err));
 361
 362     return Error::success();
 363   }
 364
 365   Error addArchiveMembers(NewArchiveMember NewMember, StringRef FileName) {
 366     Expected<std::unique_ptr<Archive>> LibOrErr =
 367         object::Archive::create(NewMember.Buf->getMemBufferRef());
 368     if (!LibOrErr)
 369       return createFileError(FileName, LibOrErr.takeError());
 370
 371     if (Error E = processArchive(**LibOrErr, FileName))
 372       return E;
 373
 374     // Update vector FileBuffers with the MemoryBuffers to transfer
 375     // ownership.
 376     Data.FileBuffers.push_back(std::move(NewMember.Buf));
 377     return Error::success();
 378   }
 379
 380   Error addUniversalMembers(NewArchiveMember NewMember, StringRef FileName) {
 381     Expected<std::unique_ptr<MachOUniversalBinary>> BinaryOrErr =
 382         MachOUniversalBinary::create(NewMember.Buf->getMemBufferRef());
 383     if (!BinaryOrErr)
 384       return createFileError(FileName, BinaryOrErr.takeError());
 385
 386     auto *UO = BinaryOrErr->get();
 387     for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) {
 388
 389       Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrErr =
 390           O.getAsObjectFile();
 391       if (MachOObjOrErr) {
 392         NewArchiveMember NewMember =
 393             NewArchiveMember(MachOObjOrErr->get()->getMemoryBufferRef());
 394         NewMember.MemberName = sys::path::filename(NewMember.MemberName);
 395
 396         if (Error E = verifyAndAddMachOObject(std::move(NewMember)))
 397           return E;
 398         continue;
 399       }
 400
 401       Expected<std::unique_ptr<IRObjectFile>> IRObjectOrError =
 402           O.getAsIRObject(LLVMCtx);
 403       if (IRObjectOrError) {
 404         // A universal file member can be a MachOObjectFile, an IRObject or an
 405         // Archive. In case we can successfully cast the member as an IRObject,
 406         // it is safe to throw away the error generated due to casting the
 407         // object as a MachOObjectFile.
 408         consumeError(MachOObjOrErr.takeError());
 409
 410         NewArchiveMember NewMember =
 411             NewArchiveMember(IRObjectOrError->get()->getMemoryBufferRef());
 412         NewMember.MemberName = sys::path::filename(NewMember.MemberName);
 413
 414         if (Error E = verifyAndAddIRObject(std::move(NewMember)))
 415           return E;
 416         continue;
 417       }
 418
 419       Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive();
 420       if (ArchiveOrError) {
 421         // A universal file member can be a MachOObjectFile, an IRObject or an
 422         // Archive. In case we can successfully cast the member as an Archive,
 423         // it is safe to throw away the error generated due to casting the
 424         // object as a MachOObjectFile.
 425         consumeError(MachOObjOrErr.takeError());
 426         consumeError(IRObjectOrError.takeError());
 427
 428         if (Error E = processArchive(**ArchiveOrError, FileName))
 429           return E;
 430         continue;
 431       }
 432
 433       Error CombinedError = joinErrors(
 434           ArchiveOrError.takeError(),
 435           joinErrors(IRObjectOrError.takeError(), MachOObjOrErr.takeError()));
 436       return createFileError(FileName, std::move(CombinedError));
 437     }
 438
 439     // Update vector FileBuffers with the MemoryBuffers to transfer
 440     // ownership.
 441     Data.FileBuffers.push_back(std::move(NewMember.Buf));
 442     return Error::success();
 443   }
 444
 445   Error addMember(StringRef FileName) {
 446     Expected<NewArchiveMember> NewMemberOrErr =
 447         NewArchiveMember::getFile(FileName, C.Deterministic);
 448     if (!NewMemberOrErr)
 449       return createFileError(FileName, NewMemberOrErr.takeError());
 450     auto &NewMember = *NewMemberOrErr;
 451
 452     // For regular archives, use the basename of the object path for the member
 453     // name.
 454     NewMember.MemberName = sys::path::filename(NewMember.MemberName);
 455     file_magic Magic = identify_magic(NewMember.Buf->getBuffer());
 456
 457     // Flatten archives.
 458     if (Magic == file_magic::archive)
 459       return addArchiveMembers(std::move(NewMember), FileName);
 460
 461     // Flatten universal files.
 462     if (Magic == file_magic::macho_universal_binary)
 463       return addUniversalMembers(std::move(NewMember), FileName);
 464
 465     // Bitcode files.
 466     if (Magic == file_magic::bitcode)
 467       return verifyAndAddIRObject(std::move(NewMember));
 468
 469     return verifyAndAddMachOObject(std::move(NewMember));
 470   }
 471
 472   MembersData Data;
 473   const Config &C;
 474 };
 475
 476 static Expected<SmallVector<Slice, 2>>
 477 buildSlices(ArrayRef<OwningBinary<Archive>> OutputBinaries) {
 478   SmallVector<Slice, 2> Slices;
 479
 480   for (const auto &OB : OutputBinaries) {
 481     const Archive &A = *OB.getBinary();
 482     Expected<Slice> ArchiveSlice = Slice::create(A, &LLVMCtx);
 483     if (!ArchiveSlice)
 484       return ArchiveSlice.takeError();
 485     Slices.push_back(*ArchiveSlice);
 486   }
 487   return Slices;
 488 }
 489
 490 static Error createStaticLibrary(const Config &C) {
 491   MembersBuilder Builder(C);
 492   auto DataOrError = Builder.build();
 493   if (auto Error = DataOrError.takeError())
 494     return Error;
 495
 496   const auto &NewMembers = DataOrError->MembersPerArchitecture;
 497
 498   if (NewMembers.size() == 1) {
 499     return writeArchive(OutputFile, NewMembers.begin()->second,
 500                         /*WriteSymtab=*/true,
 501                         /*Kind=*/object::Archive::K_DARWIN, C.Deterministic,
 502                         /*Thin=*/false);
 503   }
 504
 505   SmallVector<OwningBinary<Archive>, 2> OutputBinaries;
 506   for (const std::pair<const uint64_t, std::vector<NewArchiveMember>> &M :
 507        NewMembers) {
 508     Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr =
 509         writeArchiveToBuffer(M.second,
 510                              /*WriteSymtab=*/true,
 511                              /*Kind=*/object::Archive::K_DARWIN,
 512                              C.Deterministic,
 513                              /*Thin=*/false);
 514     if (!OutputBufferOrErr)
 515       return OutputBufferOrErr.takeError();
 516     std::unique_ptr<MemoryBuffer> &OutputBuffer = OutputBufferOrErr.get();
 517
 518     Expected<std::unique_ptr<Archive>> ArchiveOrError =
 519         Archive::create(OutputBuffer->getMemBufferRef());
 520     if (!ArchiveOrError)
 521       return ArchiveOrError.takeError();
 522     std::unique_ptr<Archive> &A = ArchiveOrError.get();
 523
 524     OutputBinaries.push_back(
 525         OwningBinary<Archive>(std::move(A), std::move(OutputBuffer)));
 526   }
 527
 528   Expected<SmallVector<Slice, 2>> Slices = buildSlices(OutputBinaries);
 529   if (!Slices)
 530     return Slices.takeError();
 531
 532   llvm::stable_sort(*Slices);
 533   return writeUniversalBinary(*Slices, OutputFile);
 534 }
 535
 536 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
 537   Config C;
 538   cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
 539
 540   if (LibraryOperation == Operation::None) {
 541     if (!VersionOption) {
 542       std::string Error;
 543       raw_string_ostream Stream(Error);
 544       LibraryOperation.error("must be specified", "", Stream);
 545       return createStringError(std::errc::invalid_argument, Error.c_str());
 546     }
 547     return C;
 548   }
 549
 550   if (OutputFile.empty()) {
 551     std::string Error;
 552     raw_string_ostream Stream(Error);
 553     OutputFile.error("must be specified", "o", Stream);
 554     return createStringError(std::errc::invalid_argument, Error.c_str());
 555   }
 556
 557   if (DeterministicOption && NonDeterministicOption)
 558     return createStringError(std::errc::invalid_argument,
 559                              "cannot specify both -D and -U flags");
 560   else if (NonDeterministicOption)
 561     C.Deterministic = false;
 562
 563   if (!Libraries.empty())
 564     if (Error E = processCommandLineLibraries())
 565       return std::move(E);
 566
 567   if (!FileList.empty())
 568     if (Error E = processFileList())
 569       return std::move(E);
 570
 571   if (InputFiles.empty())
 572     return createStringError(std::errc::invalid_argument,
 573                              "no input files specified");
 574
 575   if (ArchType.getNumOccurrences()) {
 576     if (Error E = validateArchitectureName(ArchType))
 577       return std::move(E);
 578
 579     std::tie(C.ArchCPUType, C.ArchCPUSubtype) =
 580         MachO::getCPUTypeFromArchitecture(
 581             MachO::getArchitectureFromName(ArchType));
 582   }
 583
 584   return C;
 585 }
 586
 587 int main(int Argc, char **Argv) {
 588   InitLLVM X(Argc, Argv);
 589   cl::HideUnrelatedOptions({&LibtoolCategory, &getColorCategory()});
 590   Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
 591   if (!ConfigOrErr) {
 592     WithColor::defaultErrorHandler(ConfigOrErr.takeError());
 593     return EXIT_FAILURE;
 594   }
 595
 596   if (VersionOption)
 597     cl::PrintVersionMessage();
 598
 599   Config C = *ConfigOrErr;
 600   switch (LibraryOperation) {
 601   case Operation::None:
 602     break;
 603   case Operation::Static:
 604     if (Error E = createStaticLibrary(C)) {
 605       WithColor::defaultErrorHandler(std::move(E));
 606       return EXIT_FAILURE;
 607     }
 608     break;
 609   }
 610 }