aboutsummaryrefslogtreecommitdiff
path: root/contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2019-12-20 19:53:05 +0000
committerDimitry Andric <dim@FreeBSD.org>2019-12-20 19:53:05 +0000
commit0b57cec536236d46e3dba9bd041533462f33dbb7 (patch)
tree56229dbdbbf76d18580f72f789003db17246c8d9 /contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
parent718ef55ec7785aae63f98f8ca05dc07ed399c16d (diff)
Notes
Diffstat (limited to 'contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp')
-rw-r--r--contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp323
1 files changed, 323 insertions, 0 deletions
diff --git a/contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp b/contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
new file mode 100644
index 000000000000..18ab6637305e
--- /dev/null
+++ b/contrib/llvm-project/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
@@ -0,0 +1,323 @@
+//===- LibDriver.cpp - lib.exe-compatible driver --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines an interface to a lib.exe-compatible driver that also understands
+// bitcode files. Used by llvm-lib and lld-link /lib.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/BinaryFormat/COFF.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Object/ArchiveWriter.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/Object/WindowsMachineFlag.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/StringSaver.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+namespace {
+
+enum {
+ OPT_INVALID = 0,
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Options.inc"
+#undef PREFIX
+
+static const opt::OptTable::Info InfoTable[] = {
+#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
+ {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
+ X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
+#include "Options.inc"
+#undef OPTION
+};
+
+class LibOptTable : public opt::OptTable {
+public:
+ LibOptTable() : OptTable(InfoTable, true) {}
+};
+
+}
+
+static std::string getOutputPath(opt::InputArgList *Args,
+ const NewArchiveMember &FirstMember) {
+ if (auto *Arg = Args->getLastArg(OPT_out))
+ return Arg->getValue();
+ SmallString<128> Val = StringRef(FirstMember.Buf->getBufferIdentifier());
+ sys::path::replace_extension(Val, ".lib");
+ return Val.str();
+}
+
+static std::vector<StringRef> getSearchPaths(opt::InputArgList *Args,
+ StringSaver &Saver) {
+ std::vector<StringRef> Ret;
+ // Add current directory as first item of the search path.
+ Ret.push_back("");
+
+ // Add /libpath flags.
+ for (auto *Arg : Args->filtered(OPT_libpath))
+ Ret.push_back(Arg->getValue());
+
+ // Add $LIB.
+ Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB");
+ if (!EnvOpt.hasValue())
+ return Ret;
+ StringRef Env = Saver.save(*EnvOpt);
+ while (!Env.empty()) {
+ StringRef Path;
+ std::tie(Path, Env) = Env.split(';');
+ Ret.push_back(Path);
+ }
+ return Ret;
+}
+
+static std::string findInputFile(StringRef File, ArrayRef<StringRef> Paths) {
+ for (StringRef Dir : Paths) {
+ SmallString<128> Path = Dir;
+ sys::path::append(Path, File);
+ if (sys::fs::exists(Path))
+ return Path.str().str();
+ }
+ return "";
+}
+
+static void fatalOpenError(llvm::Error E, Twine File) {
+ if (!E)
+ return;
+ handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
+ llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n';
+ exit(1);
+ });
+}
+
+static void doList(opt::InputArgList& Args) {
+ // lib.exe prints the contents of the first archive file.
+ std::unique_ptr<MemoryBuffer> B;
+ for (auto *Arg : Args.filtered(OPT_INPUT)) {
+ // Create or open the archive object.
+ ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf =
+ MemoryBuffer::getFile(Arg->getValue(), -1, false);
+ fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue());
+
+ if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) {
+ B = std::move(MaybeBuf.get());
+ break;
+ }
+ }
+
+ // lib.exe doesn't print an error if no .lib files are passed.
+ if (!B)
+ return;
+
+ Error Err = Error::success();
+ object::Archive Archive(B.get()->getMemBufferRef(), Err);
+ fatalOpenError(std::move(Err), B->getBufferIdentifier());
+
+ for (auto &C : Archive.children(Err)) {
+ Expected<StringRef> NameOrErr = C.getName();
+ fatalOpenError(NameOrErr.takeError(), B->getBufferIdentifier());
+ StringRef Name = NameOrErr.get();
+ llvm::outs() << Name << '\n';
+ }
+ fatalOpenError(std::move(Err), B->getBufferIdentifier());
+}
+
+int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) {
+ BumpPtrAllocator Alloc;
+ StringSaver Saver(Alloc);
+
+ // Parse command line arguments.
+ SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
+ cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
+ ArgsArr = NewArgs;
+
+ LibOptTable Table;
+ unsigned MissingIndex;
+ unsigned MissingCount;
+ opt::InputArgList Args =
+ Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
+ if (MissingCount) {
+ llvm::errs() << "missing arg value for \""
+ << Args.getArgString(MissingIndex) << "\", expected "
+ << MissingCount
+ << (MissingCount == 1 ? " argument.\n" : " arguments.\n");
+ return 1;
+ }
+ for (auto *Arg : Args.filtered(OPT_UNKNOWN))
+ llvm::errs() << "ignoring unknown argument: " << Arg->getAsString(Args)
+ << "\n";
+
+ // Handle /help
+ if (Args.hasArg(OPT_help)) {
+ Table.PrintHelp(outs(), "llvm-lib [options] file...", "LLVM Lib");
+ return 0;
+ }
+
+ // If no input files, silently do nothing to match lib.exe.
+ if (!Args.hasArgNoClaim(OPT_INPUT))
+ return 0;
+
+ if (Args.hasArg(OPT_lst)) {
+ doList(Args);
+ return 0;
+ }
+
+ std::vector<StringRef> SearchPaths = getSearchPaths(&Args, Saver);
+
+ COFF::MachineTypes LibMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+ std::string LibMachineSource;
+ if (auto *Arg = Args.getLastArg(OPT_machine)) {
+ LibMachine = getMachineType(Arg->getValue());
+ if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
+ llvm::errs() << "unknown /machine: arg " << Arg->getValue() << '\n';
+ return 1;
+ }
+ LibMachineSource =
+ std::string(" (from '/machine:") + Arg->getValue() + "' flag)";
+ }
+
+ // Create a NewArchiveMember for each input file.
+ std::vector<NewArchiveMember> Members;
+ for (auto *Arg : Args.filtered(OPT_INPUT)) {
+ std::string Path = findInputFile(Arg->getValue(), SearchPaths);
+ if (Path.empty()) {
+ llvm::errs() << Arg->getValue() << ": no such file or directory\n";
+ return 1;
+ }
+
+ Expected<NewArchiveMember> MOrErr =
+ NewArchiveMember::getFile(Saver.save(Path), /*Deterministic=*/true);
+ if (!MOrErr) {
+ handleAllErrors(MOrErr.takeError(), [&](const ErrorInfoBase &EIB) {
+ llvm::errs() << Arg->getValue() << ": " << EIB.message() << "\n";
+ });
+ return 1;
+ }
+
+ file_magic Magic = identify_magic(MOrErr->Buf->getBuffer());
+ if (Magic != file_magic::coff_object && Magic != file_magic::bitcode &&
+ Magic != file_magic::windows_resource) {
+ llvm::errs() << Arg->getValue()
+ << ": not a COFF object, bitcode or resource file\n";
+ return 1;
+ }
+
+ // Check that all input files have the same machine type.
+ // Mixing normal objects and LTO bitcode files is fine as long as they
+ // have the same machine type.
+ // Doing this here duplicates the header parsing work that writeArchive()
+ // below does, but it's not a lot of work and it's a bit awkward to do
+ // in writeArchive() which needs to support many tools, can't assume the
+ // input is COFF, and doesn't have a good way to report errors.
+ COFF::MachineTypes FileMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+ if (Magic == file_magic::coff_object) {
+ std::error_code EC;
+ object::COFFObjectFile Obj(*MOrErr->Buf, EC);
+ if (EC) {
+ llvm::errs() << Arg->getValue() << ": failed to open: " << EC.message()
+ << '\n';
+ return 1;
+ }
+ uint16_t Machine = Obj.getMachine();
+ if (Machine != COFF::IMAGE_FILE_MACHINE_I386 &&
+ Machine != COFF::IMAGE_FILE_MACHINE_AMD64 &&
+ Machine != COFF::IMAGE_FILE_MACHINE_ARMNT &&
+ Machine != COFF::IMAGE_FILE_MACHINE_ARM64) {
+ llvm::errs() << Arg->getValue() << ": unknown machine: " << Machine
+ << '\n';
+ return 1;
+ }
+ FileMachine = static_cast<COFF::MachineTypes>(Machine);
+ } else if (Magic == file_magic::bitcode) {
+ Expected<std::string> TripleStr = getBitcodeTargetTriple(*MOrErr->Buf);
+ if (!TripleStr) {
+ llvm::errs() << Arg->getValue()
+ << ": failed to get target triple from bitcode\n";
+ return 1;
+ }
+ switch (Triple(*TripleStr).getArch()) {
+ case Triple::x86:
+ FileMachine = COFF::IMAGE_FILE_MACHINE_I386;
+ break;
+ case Triple::x86_64:
+ FileMachine = COFF::IMAGE_FILE_MACHINE_AMD64;
+ break;
+ case Triple::arm:
+ FileMachine = COFF::IMAGE_FILE_MACHINE_ARMNT;
+ break;
+ case Triple::aarch64:
+ FileMachine = COFF::IMAGE_FILE_MACHINE_ARM64;
+ break;
+ default:
+ llvm::errs() << Arg->getValue() << ": unknown arch in target triple "
+ << *TripleStr << '\n';
+ return 1;
+ }
+ }
+
+ // FIXME: Once lld-link rejects multiple resource .obj files:
+ // Call convertResToCOFF() on .res files and add the resulting
+ // COFF file to the .lib output instead of adding the .res file, and remove
+ // this check. See PR42180.
+ if (FileMachine != COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
+ if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
+ LibMachine = FileMachine;
+ LibMachineSource = std::string(" (inferred from earlier file '") +
+ Arg->getValue() + "')";
+ } else if (LibMachine != FileMachine) {
+ llvm::errs() << Arg->getValue() << ": file machine type "
+ << machineToStr(FileMachine)
+ << " conflicts with library machine type "
+ << machineToStr(LibMachine) << LibMachineSource << '\n';
+ return 1;
+ }
+ }
+
+ Members.emplace_back(std::move(*MOrErr));
+ }
+
+ // Create an archive file.
+ std::string OutputPath = getOutputPath(&Args, Members[0]);
+ // llvm-lib uses relative paths for both regular and thin archives, unlike
+ // standard GNU ar, which only uses relative paths for thin archives and
+ // basenames for regular archives.
+ for (NewArchiveMember &Member : Members) {
+ if (sys::path::is_relative(Member.MemberName)) {
+ Expected<std::string> PathOrErr =
+ computeArchiveRelativePath(OutputPath, Member.MemberName);
+ if (PathOrErr)
+ Member.MemberName = Saver.save(*PathOrErr);
+ }
+ }
+
+ if (Error E =
+ writeArchive(OutputPath, Members,
+ /*WriteSymtab=*/true, object::Archive::K_GNU,
+ /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin))) {
+ handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
+ llvm::errs() << OutputPath << ": " << EI.message() << "\n";
+ });
+ return 1;
+ }
+
+ return 0;
+}