summaryrefslogtreecommitdiff
path: root/MinGW/Driver.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'MinGW/Driver.cpp')
-rw-r--r--MinGW/Driver.cpp247
1 files changed, 247 insertions, 0 deletions
diff --git a/MinGW/Driver.cpp b/MinGW/Driver.cpp
new file mode 100644
index 0000000000000..6d3bea5d90406
--- /dev/null
+++ b/MinGW/Driver.cpp
@@ -0,0 +1,247 @@
+//===- MinGW/Driver.cpp ---------------------------------------------------===//
+//
+// The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// GNU ld style linker driver for COFF currently supporting mingw-w64.
+///
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Driver.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
+using namespace lld;
+using namespace llvm;
+
+// Create OptTable
+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
+};
+
+// Create prefix string literals used in Options.td
+#define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE;
+#include "Options.inc"
+#undef PREFIX
+
+// Create table mapping all options defined in Options.td
+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
+};
+
+namespace {
+class MinGWOptTable : public opt::OptTable {
+public:
+ MinGWOptTable() : OptTable(InfoTable, false) {}
+ opt::InputArgList parse(ArrayRef<const char *> Argv);
+};
+} // namespace
+
+opt::InputArgList MinGWOptTable::parse(ArrayRef<const char *> Argv) {
+ unsigned MissingIndex;
+ unsigned MissingCount;
+
+ SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
+ opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
+
+ if (MissingCount)
+ fatal(StringRef(Args.getArgString(MissingIndex)) + ": missing argument");
+ for (auto *Arg : Args.filtered(OPT_UNKNOWN))
+ fatal("unknown argument: " + Arg->getSpelling());
+ if (!Args.hasArg(OPT_INPUT) && !Args.hasArg(OPT_l))
+ fatal("no input files");
+ return Args;
+}
+
+// Find a file by concatenating given paths.
+static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
+ SmallString<128> S;
+ sys::path::append(S, Path1, Path2);
+ if (sys::fs::exists(S))
+ return S.str().str();
+ return None;
+}
+
+// This is for -lfoo. We'll look for libfoo.dll.a or libfoo.a from search paths.
+static std::string
+searchLibrary(StringRef Name, ArrayRef<StringRef> SearchPaths, bool BStatic) {
+ if (Name.startswith(":")) {
+ for (StringRef Dir : SearchPaths)
+ if (Optional<std::string> S = findFile(Dir, Name.substr(1)))
+ return *S;
+ fatal("unable to find library -l" + Name);
+ }
+
+ for (StringRef Dir : SearchPaths) {
+ if (!BStatic)
+ if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".dll.a"))
+ return *S;
+ if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".a"))
+ return *S;
+ }
+ fatal("unable to find library -l" + Name);
+}
+
+// Convert Unix-ish command line arguments to Windows-ish ones and
+// then call coff::link.
+bool mingw::link(ArrayRef<const char *> ArgsArr, raw_ostream &Diag) {
+ MinGWOptTable Parser;
+ opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
+
+ std::vector<std::string> LinkArgs;
+ auto Add = [&](const Twine &S) { LinkArgs.push_back(S.str()); };
+
+ Add("lld-link");
+ Add("-lldmingw");
+
+ if (auto *A = Args.getLastArg(OPT_entry)) {
+ StringRef S = A->getValue();
+ if (Args.getLastArgValue(OPT_m) == "i386pe" && S.startswith("_"))
+ Add("-entry:" + S.substr(1));
+ else
+ Add("-entry:" + S);
+ }
+
+ if (auto *A = Args.getLastArg(OPT_subs))
+ Add("-subsystem:" + StringRef(A->getValue()));
+ if (auto *A = Args.getLastArg(OPT_out_implib))
+ Add("-implib:" + StringRef(A->getValue()));
+ if (auto *A = Args.getLastArg(OPT_stack))
+ Add("-stack:" + StringRef(A->getValue()));
+ if (auto *A = Args.getLastArg(OPT_output_def))
+ Add("-output-def:" + StringRef(A->getValue()));
+ if (auto *A = Args.getLastArg(OPT_image_base))
+ Add("-base:" + StringRef(A->getValue()));
+
+ if (auto *A = Args.getLastArg(OPT_o))
+ Add("-out:" + StringRef(A->getValue()));
+ else if (Args.hasArg(OPT_shared))
+ Add("-out:a.dll");
+ else
+ Add("-out:a.exe");
+
+ if (Args.hasArg(OPT_shared))
+ Add("-dll");
+ if (Args.hasArg(OPT_verbose))
+ Add("-verbose");
+ if (Args.hasArg(OPT_export_all_symbols))
+ Add("-export-all-symbols");
+ if (!Args.hasArg(OPT_strip_all))
+ Add("-debug:dwarf");
+ if (Args.hasArg(OPT_large_address_aware))
+ Add("-largeaddressaware");
+
+ if (Args.getLastArgValue(OPT_m) != "thumb2pe" &&
+ Args.getLastArgValue(OPT_m) != "arm64pe" && !Args.hasArg(OPT_dynamicbase))
+ Add("-dynamicbase:no");
+
+ if (Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false))
+ Add("-opt:ref");
+ else
+ Add("-opt:noref");
+
+ if (auto *A = Args.getLastArg(OPT_icf)) {
+ StringRef S = A->getValue();
+ if (S == "all")
+ Add("-opt:icf");
+ else if (S == "safe" || S == "none")
+ Add("-opt:noicf");
+ else
+ fatal("unknown parameter: --icf=" + S);
+ } else {
+ Add("-opt:noicf");
+ }
+
+ if (auto *A = Args.getLastArg(OPT_m)) {
+ StringRef S = A->getValue();
+ if (S == "i386pe")
+ Add("-machine:x86");
+ else if (S == "i386pep")
+ Add("-machine:x64");
+ else if (S == "thumb2pe")
+ Add("-machine:arm");
+ else if (S == "arm64pe")
+ Add("-machine:arm64");
+ else
+ fatal("unknown parameter: -m" + S);
+ }
+
+ for (auto *A : Args.filtered(OPT_mllvm))
+ Add("-mllvm:" + StringRef(A->getValue()));
+
+ for (auto *A : Args.filtered(OPT_Xlink))
+ Add(A->getValue());
+
+ if (Args.getLastArgValue(OPT_m) == "i386pe")
+ Add("-alternatename:__image_base__=___ImageBase");
+ else
+ Add("-alternatename:__image_base__=__ImageBase");
+
+ std::vector<StringRef> SearchPaths;
+ for (auto *A : Args.filtered(OPT_L))
+ SearchPaths.push_back(A->getValue());
+
+ StringRef Prefix = "";
+ bool Static = false;
+ for (auto *A : Args) {
+ switch (A->getOption().getUnaliasedOption().getID()) {
+ case OPT_INPUT:
+ if (StringRef(A->getValue()).endswith_lower(".def"))
+ Add("-def:" + StringRef(A->getValue()));
+ else
+ Add(Prefix + StringRef(A->getValue()));
+ break;
+ case OPT_l:
+ Add(Prefix + searchLibrary(A->getValue(), SearchPaths, Static));
+ break;
+ case OPT_whole_archive:
+ Prefix = "-wholearchive:";
+ break;
+ case OPT_no_whole_archive:
+ Prefix = "";
+ break;
+ case OPT_Bstatic:
+ Static = true;
+ break;
+ case OPT_Bdynamic:
+ Static = false;
+ break;
+ }
+ }
+
+ if (Args.hasArg(OPT_verbose) || Args.hasArg(OPT__HASH_HASH_HASH))
+ outs() << llvm::join(LinkArgs, " ") << "\n";
+
+ if (Args.hasArg(OPT__HASH_HASH_HASH))
+ return true;
+
+ // Repack vector of strings to vector of const char pointers for coff::link.
+ std::vector<const char *> Vec;
+ for (const std::string &S : LinkArgs)
+ Vec.push_back(S.c_str());
+ return coff::link(Vec, true);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-15 03:40:10 +0000