lib/ToolDrivers/llvm-lib/LibDriver.cpp

   1 //===- LibDriver.cpp - lib.exe-compatible driver --------------------------===//
   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 // Defines an interface to a lib.exe-compatible driver that also understands
  10 // bitcode files. Used by llvm-lib and lld-link /lib.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/BinaryFormat/COFF.h"
  17 #include "llvm/BinaryFormat/Magic.h"
  18 #include "llvm/Bitcode/BitcodeReader.h"
  19 #include "llvm/Object/ArchiveWriter.h"
  20 #include "llvm/Object/COFF.h"
  21 #include "llvm/Object/WindowsMachineFlag.h"
  22 #include "llvm/Option/Arg.h"
  23 #include "llvm/Option/ArgList.h"
  24 #include "llvm/Option/Option.h"
  25 #include "llvm/Support/CommandLine.h"
  26 #include "llvm/Support/Path.h"
  27 #include "llvm/Support/Process.h"
  28 #include "llvm/Support/StringSaver.h"
  29 #include "llvm/Support/raw_ostream.h"
  30
  31 using namespace llvm;
  32
  33 namespace {
  34
  35 enum {
  36   OPT_INVALID = 0,
  37 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
  38 #include "Options.inc"
  39 #undef OPTION
  40 };
  41
  42 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  43 #include "Options.inc"
  44 #undef PREFIX
  45
  46 static const opt::OptTable::Info InfoTable[] = {
  47 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
  48   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
  49    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
  50 #include "Options.inc"
  51 #undef OPTION
  52 };
  53
  54 class LibOptTable : public opt::OptTable {
  55 public:
  56   LibOptTable() : OptTable(InfoTable, true) {}
  57 };
  58
  59 }
  60
  61 static std::string getOutputPath(opt::InputArgList *Args,
  62                                  const NewArchiveMember &FirstMember) {
  63   if (auto *Arg = Args->getLastArg(OPT_out))
  64     return Arg->getValue();
  65   SmallString<128> Val = StringRef(FirstMember.Buf->getBufferIdentifier());
  66   sys::path::replace_extension(Val, ".lib");
  67   return Val.str();
  68 }
  69
  70 static std::vector<StringRef> getSearchPaths(opt::InputArgList *Args,
  71                                              StringSaver &Saver) {
  72   std::vector<StringRef> Ret;
  73   // Add current directory as first item of the search path.
  74   Ret.push_back("");
  75
  76   // Add /libpath flags.
  77   for (auto *Arg : Args->filtered(OPT_libpath))
  78     Ret.push_back(Arg->getValue());
  79
  80   // Add $LIB.
  81   Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB");
  82   if (!EnvOpt.hasValue())
  83     return Ret;
  84   StringRef Env = Saver.save(*EnvOpt);
  85   while (!Env.empty()) {
  86     StringRef Path;
  87     std::tie(Path, Env) = Env.split(';');
  88     Ret.push_back(Path);
  89   }
  90   return Ret;
  91 }
  92
  93 static std::string findInputFile(StringRef File, ArrayRef<StringRef> Paths) {
  94   for (StringRef Dir : Paths) {
  95     SmallString<128> Path = Dir;
  96     sys::path::append(Path, File);
  97     if (sys::fs::exists(Path))
  98       return Path.str().str();
  99   }
 100   return "";
 101 }
 102
 103 static void fatalOpenError(llvm::Error E, Twine File) {
 104   if (!E)
 105     return;
 106   handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
 107     llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n';
 108     exit(1);
 109   });
 110 }
 111
 112 static void doList(opt::InputArgList& Args) {
 113   // lib.exe prints the contents of the first archive file.
 114   std::unique_ptr<MemoryBuffer> B;
 115   for (auto *Arg : Args.filtered(OPT_INPUT)) {
 116     // Create or open the archive object.
 117     ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf =
 118         MemoryBuffer::getFile(Arg->getValue(), -1, false);
 119     fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue());
 120
 121     if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) {
 122       B = std::move(MaybeBuf.get());
 123       break;
 124     }
 125   }
 126
 127   // lib.exe doesn't print an error if no .lib files are passed.
 128   if (!B)
 129     return;
 130
 131   Error Err = Error::success();
 132   object::Archive Archive(B.get()->getMemBufferRef(), Err);
 133   fatalOpenError(std::move(Err), B->getBufferIdentifier());
 134
 135   for (auto &C : Archive.children(Err)) {
 136     Expected<StringRef> NameOrErr = C.getName();
 137     fatalOpenError(NameOrErr.takeError(), B->getBufferIdentifier());
 138     StringRef Name = NameOrErr.get();
 139     llvm::outs() << Name << '\n';
 140   }
 141   fatalOpenError(std::move(Err), B->getBufferIdentifier());
 142 }
 143
 144 int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) {
 145   BumpPtrAllocator Alloc;
 146   StringSaver Saver(Alloc);
 147
 148   // Parse command line arguments.
 149   SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
 150   cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
 151   ArgsArr = NewArgs;
 152
 153   LibOptTable Table;
 154   unsigned MissingIndex;
 155   unsigned MissingCount;
 156   opt::InputArgList Args =
 157       Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
 158   if (MissingCount) {
 159     llvm::errs() << "missing arg value for \""
 160                  << Args.getArgString(MissingIndex) << "\", expected "
 161                  << MissingCount
 162                  << (MissingCount == 1 ? " argument.\n" : " arguments.\n");
 163     return 1;
 164   }
 165   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
 166     llvm::errs() << "ignoring unknown argument: " << Arg->getAsString(Args)
 167                  << "\n";
 168
 169   // Handle /help
 170   if (Args.hasArg(OPT_help)) {
 171     Table.PrintHelp(outs(), "llvm-lib [options] file...", "LLVM Lib");
 172     return 0;
 173   }
 174
 175   // If no input files, silently do nothing to match lib.exe.
 176   if (!Args.hasArgNoClaim(OPT_INPUT))
 177     return 0;
 178
 179   if (Args.hasArg(OPT_lst)) {
 180     doList(Args);
 181     return 0;
 182   }
 183
 184   std::vector<StringRef> SearchPaths = getSearchPaths(&Args, Saver);
 185
 186   COFF::MachineTypes LibMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 187   std::string LibMachineSource;
 188   if (auto *Arg = Args.getLastArg(OPT_machine)) {
 189     LibMachine = getMachineType(Arg->getValue());
 190     if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
 191       llvm::errs() << "unknown /machine: arg " << Arg->getValue() << '\n';
 192       return 1;
 193     }
 194     LibMachineSource =
 195         std::string(" (from '/machine:") + Arg->getValue() + "' flag)";
 196   }
 197
 198   // Create a NewArchiveMember for each input file.
 199   std::vector<NewArchiveMember> Members;
 200   for (auto *Arg : Args.filtered(OPT_INPUT)) {
 201     std::string Path = findInputFile(Arg->getValue(), SearchPaths);
 202     if (Path.empty()) {
 203       llvm::errs() << Arg->getValue() << ": no such file or directory\n";
 204       return 1;
 205     }
 206
 207     Expected<NewArchiveMember> MOrErr =
 208         NewArchiveMember::getFile(Saver.save(Path), /*Deterministic=*/true);
 209     if (!MOrErr) {
 210       handleAllErrors(MOrErr.takeError(), [&](const ErrorInfoBase &EIB) {
 211         llvm::errs() << Arg->getValue() << ": " << EIB.message() << "\n";
 212       });
 213       return 1;
 214     }
 215
 216     file_magic Magic = identify_magic(MOrErr->Buf->getBuffer());
 217     if (Magic != file_magic::coff_object && Magic != file_magic::bitcode &&
 218         Magic != file_magic::windows_resource) {
 219       llvm::errs() << Arg->getValue()
 220                    << ": not a COFF object, bitcode or resource file\n";
 221       return 1;
 222     }
 223
 224     // Check that all input files have the same machine type.
 225     // Mixing normal objects and LTO bitcode files is fine as long as they
 226     // have the same machine type.
 227     // Doing this here duplicates the header parsing work that writeArchive()
 228     // below does, but it's not a lot of work and it's a bit awkward to do
 229     // in writeArchive() which needs to support many tools, can't assume the
 230     // input is COFF, and doesn't have a good way to report errors.
 231     COFF::MachineTypes FileMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 232     if (Magic == file_magic::coff_object) {
 233       std::error_code EC;
 234       object::COFFObjectFile Obj(*MOrErr->Buf, EC);
 235       if (EC) {
 236         llvm::errs() << Arg->getValue() << ": failed to open: " << EC.message()
 237                      << '\n';
 238         return 1;
 239       }
 240       uint16_t Machine = Obj.getMachine();
 241       if (Machine != COFF::IMAGE_FILE_MACHINE_I386 &&
 242           Machine != COFF::IMAGE_FILE_MACHINE_AMD64 &&
 243           Machine != COFF::IMAGE_FILE_MACHINE_ARMNT &&
 244           Machine != COFF::IMAGE_FILE_MACHINE_ARM64) {
 245         llvm::errs() << Arg->getValue() << ": unknown machine: " << Machine
 246                      << '\n';
 247         return 1;
 248       }
 249       FileMachine = static_cast<COFF::MachineTypes>(Machine);
 250     } else if (Magic == file_magic::bitcode) {
 251       Expected<std::string> TripleStr = getBitcodeTargetTriple(*MOrErr->Buf);
 252       if (!TripleStr) {
 253         llvm::errs() << Arg->getValue()
 254                      << ": failed to get target triple from bitcode\n";
 255         return 1;
 256       }
 257       switch (Triple(*TripleStr).getArch()) {
 258       case Triple::x86:
 259         FileMachine = COFF::IMAGE_FILE_MACHINE_I386;
 260         break;
 261       case Triple::x86_64:
 262         FileMachine = COFF::IMAGE_FILE_MACHINE_AMD64;
 263         break;
 264       case Triple::arm:
 265         FileMachine = COFF::IMAGE_FILE_MACHINE_ARMNT;
 266         break;
 267       case Triple::aarch64:
 268         FileMachine = COFF::IMAGE_FILE_MACHINE_ARM64;
 269         break;
 270       default:
 271         llvm::errs() << Arg->getValue() << ": unknown arch in target triple "
 272                      << *TripleStr << '\n';
 273         return 1;
 274       }
 275     }
 276
 277     // FIXME: Once lld-link rejects multiple resource .obj files:
 278     // Call convertResToCOFF() on .res files and add the resulting
 279     // COFF file to the .lib output instead of adding the .res file, and remove
 280     // this check. See PR42180.
 281     if (FileMachine != COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
 282       if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
 283         LibMachine = FileMachine;
 284         LibMachineSource = std::string(" (inferred from earlier file '") +
 285                            Arg->getValue() + "')";
 286       } else if (LibMachine != FileMachine) {
 287         llvm::errs() << Arg->getValue() << ": file machine type "
 288                      << machineToStr(FileMachine)
 289                      << " conflicts with library machine type "
 290                      << machineToStr(LibMachine) << LibMachineSource << '\n';
 291         return 1;
 292       }
 293     }
 294
 295     Members.emplace_back(std::move(*MOrErr));
 296   }
 297
 298   // Create an archive file.
 299   std::string OutputPath = getOutputPath(&Args, Members[0]);
 300   // llvm-lib uses relative paths for both regular and thin archives, unlike
 301   // standard GNU ar, which only uses relative paths for thin archives and
 302   // basenames for regular archives.
 303   for (NewArchiveMember &Member : Members) {
 304     if (sys::path::is_relative(Member.MemberName)) {
 305       Expected<std::string> PathOrErr =
 306           computeArchiveRelativePath(OutputPath, Member.MemberName);
 307       if (PathOrErr)
 308         Member.MemberName = Saver.save(*PathOrErr);
 309     }
 310   }
 311
 312   if (Error E =
 313           writeArchive(OutputPath, Members,
 314                        /*WriteSymtab=*/true, object::Archive::K_GNU,
 315                        /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin))) {
 316     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
 317       llvm::errs() << OutputPath << ": " << EI.message() << "\n";
 318     });
 319     return 1;
 320   }
 321
 322   return 0;
 323 }