mirror of
https://github.com/ldc-developers/ldc.git
synced 2025-05-05 17:43:35 +03:00
337 lines
11 KiB
C++
337 lines
11 KiB
C++
//===-- linker.cpp --------------------------------------------------------===//
|
||
//
|
||
// LDC – the LLVM D compiler
|
||
//
|
||
// This file is distributed under the BSD-style LDC license. See the LICENSE
|
||
// file for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include "driver/linker.h"
|
||
|
||
#include "dmd/errors.h"
|
||
#include "dmd/target.h"
|
||
#include "driver/cl_options.h"
|
||
#include "driver/timetrace.h"
|
||
#include "driver/tool.h"
|
||
#include "gen/llvm.h"
|
||
#include "gen/logger.h"
|
||
#include "llvm/IRReader/IRReader.h"
|
||
#include "llvm/Linker/Linker.h"
|
||
#include "llvm/Support/FileSystem.h"
|
||
#include "llvm/Support/SourceMgr.h"
|
||
#include <sstream>
|
||
|
||
namespace cl = llvm::cl;
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
#if LDC_WITH_LLD
|
||
static cl::opt<bool> linkInternally("link-internally", cl::ZeroOrMore,
|
||
cl::desc("Use internal LLD for linking"),
|
||
cl::cat(opts::linkingCategory));
|
||
#else
|
||
constexpr bool linkInternally = false;
|
||
#endif
|
||
|
||
static cl::opt<std::string> platformLib(
|
||
"platformlib", cl::ZeroOrMore, cl::value_desc("lib1,lib2,..."),
|
||
cl::desc("Platform libraries to link with (overrides previous)"),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static cl::opt<bool> noDefaultLib(
|
||
"nodefaultlib", cl::ZeroOrMore, cl::Hidden,
|
||
cl::desc("Don't add a default library for linking implicitly"));
|
||
|
||
static cl::opt<std::string>
|
||
defaultLib("defaultlib", cl::ZeroOrMore, cl::value_desc("lib1,lib2,..."),
|
||
cl::desc("Default libraries to link with (overrides previous)"),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static cl::opt<std::string> debugLib(
|
||
"debuglib", cl::ZeroOrMore, cl::Hidden, cl::value_desc("lib1,lib2,..."),
|
||
cl::desc("Debug versions of default libraries (overrides previous). If the "
|
||
"option is omitted, LDC will append -debug to the -defaultlib "
|
||
"names when linking with -link-defaultlib-debug"),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static cl::opt<bool> linkDefaultLibDebug(
|
||
"link-defaultlib-debug", cl::ZeroOrMore,
|
||
cl::desc("Link with debug versions of default libraries"),
|
||
cl::cat(opts::linkingCategory));
|
||
static cl::alias _linkDebugLib("link-debuglib", cl::Hidden,
|
||
cl::aliasopt(linkDefaultLibDebug),
|
||
cl::desc("Alias for -link-defaultlib-debug"),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static cl::opt<cl::boolOrDefault> linkDefaultLibShared(
|
||
"link-defaultlib-shared", cl::ZeroOrMore,
|
||
cl::desc("Link with shared versions of default libraries. Defaults to true "
|
||
"when generating a shared library (-shared)."),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static cl::opt<cl::boolOrDefault>
|
||
staticFlag("static", cl::ZeroOrMore,
|
||
cl::desc("Create a statically linked binary, including "
|
||
"all system dependencies"),
|
||
cl::cat(opts::linkingCategory));
|
||
|
||
static llvm::cl::opt<std::string>
|
||
mscrtlib("mscrtlib", llvm::cl::ZeroOrMore,
|
||
llvm::cl::desc("MS C runtime library to link with"),
|
||
llvm::cl::value_desc("libcmt[d]|msvcrt[d]"),
|
||
llvm::cl::cat(opts::linkingCategory));
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
// linker-gcc.cpp
|
||
int linkObjToBinaryGcc(llvm::StringRef outputPath,
|
||
const std::vector<std::string> &defaultLibNames);
|
||
|
||
// linker-msvc.cpp
|
||
int linkObjToBinaryMSVC(llvm::StringRef outputPath,
|
||
const std::vector<std::string> &defaultLibNames);
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
static std::string getOutputPath() {
|
||
const auto &triple = *global.params.targetTriple;
|
||
const bool sharedLib = global.params.dll;
|
||
|
||
const char *extension = nullptr;
|
||
if (sharedLib) {
|
||
extension = target.dll_ext.ptr;
|
||
} else if (triple.isOSWindows()) {
|
||
extension = "exe";
|
||
} else if (triple.getArch() == llvm::Triple::wasm32 ||
|
||
triple.getArch() == llvm::Triple::wasm64) {
|
||
extension = "wasm";
|
||
}
|
||
|
||
if (global.params.exefile.length) {
|
||
// DMD adds the default extension if there is none
|
||
return opts::invokedByLDMD && extension
|
||
? FileName::defaultExt(global.params.exefile.ptr, extension)
|
||
: global.params.exefile.ptr;
|
||
}
|
||
|
||
// Infer output name from first object file.
|
||
std::string result =
|
||
global.params.objfiles.length
|
||
? FileName::removeExt(FileName::name(global.params.objfiles[0]))
|
||
: "a.out";
|
||
|
||
if (sharedLib && !triple.isWindowsMSVCEnvironment())
|
||
result = "lib" + result;
|
||
|
||
if (global.params.run) {
|
||
// If `-run` is passed, the executable is temporary and is removed
|
||
// after execution. Make sure the name does not collide with other files
|
||
// from other processes by creating a unique filename.
|
||
llvm::SmallString<128> tempFilename;
|
||
auto EC = llvm::sys::fs::createTemporaryFile(
|
||
result, extension ? extension : "", tempFilename);
|
||
if (!EC)
|
||
result = {tempFilename.data(), tempFilename.size()};
|
||
} else if (extension) {
|
||
result += '.';
|
||
result += extension;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
static std::vector<std::string>
|
||
parseLibNames(llvm::StringRef commaSeparatedList, llvm::StringRef suffix = {}) {
|
||
std::vector<std::string> result;
|
||
|
||
std::stringstream list(commaSeparatedList.str());
|
||
while (list.good()) {
|
||
std::string lib;
|
||
std::getline(list, lib, ',');
|
||
if (lib.empty()) {
|
||
continue;
|
||
}
|
||
|
||
result.push_back(suffix.empty() ? std::move(lib) : (lib + suffix).str());
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
static std::vector<std::string> getDefaultLibNames() {
|
||
std::vector<std::string> result;
|
||
|
||
if (noDefaultLib) {
|
||
deprecation(Loc(), "-nodefaultlib is deprecated, as -defaultlib now "
|
||
"overrides the existing list instead of appending to "
|
||
"it. Please use the latter instead.");
|
||
} else if (!global.params.betterC) {
|
||
llvm::StringRef list = defaultLib;
|
||
std::string suffix;
|
||
|
||
if (linkDefaultLibDebug) {
|
||
if (debugLib.getNumOccurrences() == 0)
|
||
suffix = "-debug";
|
||
else
|
||
list = debugLib;
|
||
}
|
||
if (linkAgainstSharedDefaultLibs()) {
|
||
suffix += "-shared";
|
||
}
|
||
|
||
result = parseLibNames(list, suffix);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
llvm::Optional<std::vector<std::string>> getExplicitPlatformLibs() {
|
||
if (platformLib.getNumOccurrences() > 0)
|
||
return parseLibNames(platformLib);
|
||
return llvm::None;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
bool useInternalLLDForLinking() {
|
||
return linkInternally
|
||
#if LDC_WITH_LLD
|
||
||
|
||
// MSVC: DWARF debuginfos and LTO require LLD
|
||
(linkInternally.getNumOccurrences() == 0 && // not explicitly disabled
|
||
opts::linker.empty() && // no explicitly selected linker
|
||
global.params.targetTriple->isWindowsMSVCEnvironment() &&
|
||
(opts::emitDwarfDebugInfo || opts::isUsingLTO()))
|
||
#endif
|
||
;
|
||
}
|
||
|
||
cl::boolOrDefault linkFullyStatic() { return staticFlag; }
|
||
|
||
bool linkAgainstSharedDefaultLibs() {
|
||
// -static enforces static default libs.
|
||
// Default to shared default libs for DLLs.
|
||
return staticFlag != cl::BOU_TRUE &&
|
||
(linkDefaultLibShared == cl::BOU_TRUE ||
|
||
(linkDefaultLibShared == cl::BOU_UNSET && global.params.dll));
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
llvm::StringRef getExplicitMscrtLibName() { return mscrtlib; }
|
||
|
||
llvm::StringRef getMscrtLibName(const bool *useInternalToolchain) {
|
||
llvm::StringRef name = getExplicitMscrtLibName();
|
||
if (!name.empty())
|
||
return name;
|
||
|
||
bool useInternal = false;
|
||
if (useInternalToolchain) {
|
||
useInternal = *useInternalToolchain;
|
||
} else {
|
||
#ifdef _WIN32
|
||
static bool haveMSVC = windows::isMsvcAvailable();
|
||
useInternal = !haveMSVC;
|
||
#else
|
||
useInternal = true;
|
||
#endif
|
||
}
|
||
|
||
if (useInternal) {
|
||
return "vcruntime140";
|
||
} else {
|
||
return linkAgainstSharedDefaultLibs() ? "msvcrt" : "libcmt";
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
/// Insert an LLVM bitcode file into the module
|
||
static void insertBitcodeIntoModule(const char *bcFile, llvm::Module &M,
|
||
llvm::LLVMContext &Context) {
|
||
Logger::println("*** Linking-in bitcode file %s ***", bcFile);
|
||
|
||
llvm::SMDiagnostic Err;
|
||
std::unique_ptr<llvm::Module> loadedModule(
|
||
getLazyIRFileModule(bcFile, Err, Context));
|
||
if (!loadedModule) {
|
||
error(Loc(), "Error when loading LLVM bitcode file: %s", bcFile);
|
||
fatal();
|
||
}
|
||
llvm::Linker(M).linkInModule(std::move(loadedModule));
|
||
}
|
||
|
||
/// Insert LLVM bitcode files into the module
|
||
void insertBitcodeFiles(llvm::Module &M, llvm::LLVMContext &Ctx,
|
||
Array<const char *> &bitcodeFiles) {
|
||
for (const char *fname : bitcodeFiles) {
|
||
insertBitcodeIntoModule(fname, M, Ctx);
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
// path to the produced executable/shared library
|
||
static std::string gExePath;
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
int linkObjToBinary() {
|
||
Logger::println("*** Linking executable ***");
|
||
TimeTraceScope timeScope("Linking executable");
|
||
|
||
// remember output path for later
|
||
gExePath = getOutputPath();
|
||
|
||
createDirectoryForFileOrFail(gExePath);
|
||
|
||
const auto defaultLibNames = getDefaultLibNames();
|
||
|
||
if (global.params.targetTriple->isWindowsMSVCEnvironment()) {
|
||
return linkObjToBinaryMSVC(gExePath, defaultLibNames);
|
||
}
|
||
|
||
return linkObjToBinaryGcc(gExePath, defaultLibNames);
|
||
}
|
||
|
||
const char *getPathToProducedBinary() {
|
||
assert(!gExePath.empty());
|
||
return gExePath.c_str();
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
void deleteExeFile() {
|
||
if (!gExePath.empty() && !llvm::sys::fs::is_directory(gExePath)) {
|
||
llvm::sys::fs::remove(gExePath);
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
int runProgram() {
|
||
TimeTraceScope timeScope("Run user program");
|
||
|
||
assert(!gExePath.empty());
|
||
|
||
// Run executable
|
||
int status =
|
||
executeToolAndWait(Loc(), gExePath, opts::runargs, global.params.verbose);
|
||
if (status < 0) {
|
||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||
error(Loc(), "program received signal %d", -status);
|
||
#else
|
||
error(Loc(), "program received signal %d (%s)", -status,
|
||
strsignal(-status));
|
||
#endif
|
||
return -status;
|
||
}
|
||
return status;
|
||
}
|