diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp')
-rw-r--r-- | contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp | 238 |
1 files changed, 185 insertions, 53 deletions
diff --git a/contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp b/contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp index 24f18b92dd66..200ac46aa534 100644 --- a/contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp +++ b/contrib/llvm-project/clang/lib/Driver/ToolChains/Solaris.cpp @@ -8,12 +8,16 @@ #include "Solaris.h" #include "CommonArgs.h" +#include "Gnu.h" #include "clang/Basic/LangStandard.h" #include "clang/Config/config.h" #include "clang/Driver/Compilation.h" #include "clang/Driver/Driver.h" #include "clang/Driver/DriverDiagnostic.h" #include "clang/Driver/Options.h" +#include "clang/Driver/SanitizerArgs.h" +#include "clang/Driver/ToolChain.h" +#include "llvm/ADT/StringSwitch.h" #include "llvm/Option/ArgList.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" @@ -29,20 +33,50 @@ void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { - claimNoWarnArgs(Args); - ArgStringList CmdArgs; + // Just call the Gnu version, which enforces gas on Solaris. + gnutools::Assembler::ConstructJob(C, JA, Output, Inputs, Args, LinkingOutput); +} - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); +bool solaris::isLinkerGnuLd(const ToolChain &TC, const ArgList &Args) { + // Only used if targetting Solaris. + const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ); + StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER; + return UseLinker == "bfd" || UseLinker == "gld"; +} - CmdArgs.push_back("-o"); - CmdArgs.push_back(Output.getFilename()); +static bool getPIE(const ArgList &Args, const ToolChain &TC) { + if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) || + Args.hasArg(options::OPT_r)) + return false; - for (const auto &II : Inputs) - CmdArgs.push_back(II.getFilename()); + return Args.hasFlag(options::OPT_pie, options::OPT_no_pie, + TC.isPIEDefault(Args)); +} - const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); - C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), - Exec, CmdArgs, Inputs, Output)); +// FIXME: Need to handle CLANG_DEFAULT_LINKER here? +std::string solaris::Linker::getLinkerPath(const ArgList &Args) const { + const ToolChain &ToolChain = getToolChain(); + if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) { + StringRef UseLinker = A->getValue(); + if (!UseLinker.empty()) { + if (llvm::sys::path::is_absolute(UseLinker) && + llvm::sys::fs::can_execute(UseLinker)) + return std::string(UseLinker); + + // Accept 'bfd' and 'gld' as aliases for the GNU linker. + if (UseLinker == "bfd" || UseLinker == "gld") + // FIXME: Could also use /usr/bin/gld here. + return "/usr/gnu/bin/ld"; + + // Accept 'ld' as alias for the default linker + if (UseLinker != "ld") + ToolChain.getDriver().Diag(diag::err_drv_invalid_linker_name) + << A->getAsString(Args); + } + } + + // getDefaultLinker() always returns an absolute path. + return ToolChain.getDefaultLinker(); } void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, @@ -50,24 +84,38 @@ void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { + const auto &ToolChain = static_cast<const Solaris &>(getToolChain()); + const Driver &D = ToolChain.getDriver(); + const llvm::Triple::ArchType Arch = ToolChain.getArch(); + const bool IsPIE = getPIE(Args, ToolChain); + const bool LinkerIsGnuLd = isLinkerGnuLd(ToolChain, Args); ArgStringList CmdArgs; - // Demangle C++ names in errors - CmdArgs.push_back("-C"); + // Demangle C++ names in errors. GNU ld already defaults to --demangle. + if (!LinkerIsGnuLd) + CmdArgs.push_back("-C"); - if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) { + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared, + options::OPT_r)) { CmdArgs.push_back("-e"); CmdArgs.push_back("_start"); } + if (IsPIE) { + if (LinkerIsGnuLd) { + CmdArgs.push_back("-pie"); + } else { + CmdArgs.push_back("-z"); + CmdArgs.push_back("type=pie"); + } + } + if (Args.hasArg(options::OPT_static)) { CmdArgs.push_back("-Bstatic"); CmdArgs.push_back("-dn"); } else { - CmdArgs.push_back("-Bdynamic"); - if (Args.hasArg(options::OPT_shared)) { + if (!Args.hasArg(options::OPT_r) && Args.hasArg(options::OPT_shared)) CmdArgs.push_back("-shared"); - } // libpthread has been folded into libc since Solaris 10, no need to do // anything for pthreads. Claim argument to avoid warning. @@ -75,19 +123,50 @@ void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, Args.ClaimAllArgs(options::OPT_pthreads); } + if (LinkerIsGnuLd) { + // Set the correct linker emulation for 32- and 64-bit Solaris. + switch (Arch) { + case llvm::Triple::x86: + CmdArgs.push_back("-m"); + CmdArgs.push_back("elf_i386_sol2"); + break; + case llvm::Triple::x86_64: + CmdArgs.push_back("-m"); + CmdArgs.push_back("elf_x86_64_sol2"); + break; + case llvm::Triple::sparc: + CmdArgs.push_back("-m"); + CmdArgs.push_back("elf32_sparc_sol2"); + break; + case llvm::Triple::sparcv9: + CmdArgs.push_back("-m"); + CmdArgs.push_back("elf64_sparc_sol2"); + break; + default: + break; + } + + if (Args.hasArg(options::OPT_rdynamic)) + CmdArgs.push_back("-export-dynamic"); + + CmdArgs.push_back("--eh-frame-hdr"); + } else { + // -rdynamic is a no-op with Solaris ld. Claim argument to avoid warning. + Args.ClaimAllArgs(options::OPT_rdynamic); + } + + assert((Output.isFilename() || Output.isNothing()) && "Invalid output."); if (Output.isFilename()) { CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); - } else { - assert(Output.isNothing() && "Invalid output."); } - if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, + options::OPT_r)) { if (!Args.hasArg(options::OPT_shared)) - CmdArgs.push_back( - Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o"))); - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi); bool HaveAnsi = false; @@ -102,29 +181,54 @@ void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, // Use values-Xc.o for -ansi, -std=c*, -std=iso9899:199409. if (HaveAnsi || (LangStd && !LangStd->isGNUMode())) values_X = "values-Xc.o"; - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(values_X))); + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(values_X))); const char *values_xpg = "values-xpg6.o"; // Use values-xpg4.o for -std=c90, -std=gnu90, -std=iso9899:199409. if (LangStd && LangStd->getLanguage() == Language::C && !LangStd->isC99()) values_xpg = "values-xpg4.o"; - CmdArgs.push_back( - Args.MakeArgString(getToolChain().GetFilePath(values_xpg))); - CmdArgs.push_back( - Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(values_xpg))); + + const char *crtbegin = nullptr; + if (Args.hasArg(options::OPT_shared) || IsPIE) + crtbegin = "crtbeginS.o"; + else + crtbegin = "crtbegin.o"; + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); + // Add crtfastmath.o if available and fast math is enabled. + ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs); } - getToolChain().AddFilePathLibArgs(Args, CmdArgs); + ToolChain.AddFilePathLibArgs(Args, CmdArgs); - Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group, - options::OPT_e, options::OPT_r}); + Args.addAllArgs(CmdArgs, + {options::OPT_L, options::OPT_T_Group, options::OPT_r}); - bool NeedsSanitizerDeps = addSanitizerRuntimes(getToolChain(), Args, CmdArgs); - AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); + bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); + AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); - if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { - if (getToolChain().ShouldLinkCXXStdlib(Args)) - getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, + options::OPT_r)) { + // Use the static OpenMP runtime with -static-openmp + bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && + !Args.hasArg(options::OPT_static); + addOpenMPRuntime(CmdArgs, ToolChain, Args, StaticOpenMP); + + if (D.CCCIsCXX()) { + if (ToolChain.ShouldLinkCXXStdlib(Args)) + ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); + CmdArgs.push_back("-lm"); + } + // Silence warnings when linking C code with a C++ '-stdlib' argument. + Args.ClaimAllArgs(options::OPT_stdlib_EQ); + // Additional linker set-up and flags for Fortran. This is required in order + // to generate executables. As Fortran runtime depends on the C runtime, + // these dependencies need to be listed before the C runtime below. + if (D.IsFlangMode()) { + addFortranRuntimeLibraryPath(getToolChain(), Args, CmdArgs); + addFortranRuntimeLibs(getToolChain(), Args, CmdArgs); + CmdArgs.push_back("-lm"); + } if (Args.hasArg(options::OPT_fstack_protector) || Args.hasArg(options::OPT_fstack_protector_strong) || Args.hasArg(options::OPT_fstack_protector_all)) { @@ -134,30 +238,55 @@ void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, } // LLVM support for atomics on 32-bit SPARC V8+ is incomplete, so // forcibly link with libatomic as a workaround. - if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) { - CmdArgs.push_back(getAsNeededOption(getToolChain(), true)); + if (Arch == llvm::Triple::sparc) { + addAsNeededOption(ToolChain, Args, CmdArgs, true); CmdArgs.push_back("-latomic"); - CmdArgs.push_back(getAsNeededOption(getToolChain(), false)); + addAsNeededOption(ToolChain, Args, CmdArgs, false); } + addAsNeededOption(ToolChain, Args, CmdArgs, true); CmdArgs.push_back("-lgcc_s"); + addAsNeededOption(ToolChain, Args, CmdArgs, false); CmdArgs.push_back("-lc"); if (!Args.hasArg(options::OPT_shared)) { CmdArgs.push_back("-lgcc"); - CmdArgs.push_back("-lm"); } - if (NeedsSanitizerDeps) - linkSanitizerRuntimeDeps(getToolChain(), CmdArgs); + const SanitizerArgs &SA = ToolChain.getSanitizerArgs(Args); + if (NeedsSanitizerDeps) { + linkSanitizerRuntimeDeps(ToolChain, Args, CmdArgs); + + // Work around Solaris/amd64 ld bug when calling __tls_get_addr directly. + // However, ld -z relax=transtls is available since Solaris 11.2, but not + // in Illumos. + if (Arch == llvm::Triple::x86_64 && + (SA.needsAsanRt() || SA.needsStatsRt() || + (SA.needsUbsanRt() && !SA.requiresMinimalRuntime())) && + !LinkerIsGnuLd) { + CmdArgs.push_back("-z"); + CmdArgs.push_back("relax=transtls"); + } + } + // Avoid AsanInitInternal cycle, Issue #64126. + if (ToolChain.getTriple().isX86() && SA.needsSharedRt() && + SA.needsAsanRt()) { + CmdArgs.push_back("-z"); + CmdArgs.push_back("now"); + } } - if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { - CmdArgs.push_back( - Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, + options::OPT_r)) { + const char *crtend = nullptr; + if (Args.hasArg(options::OPT_shared) || IsPIE) + crtend = "crtendS.o"; + else + crtend = "crtend.o"; + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); } - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); - getToolChain().addProfileRTLibs(Args, CmdArgs); + ToolChain.addProfileRTLibs(Args, CmdArgs); - const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getLinkerPath(Args)); C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), Exec, CmdArgs, Inputs, Output)); } @@ -166,13 +295,12 @@ static StringRef getSolarisLibSuffix(const llvm::Triple &Triple) { switch (Triple.getArch()) { case llvm::Triple::x86: case llvm::Triple::sparc: + default: break; case llvm::Triple::x86_64: return "/amd64"; case llvm::Triple::sparcv9: return "/sparcv9"; - default: - llvm_unreachable("Unsupported architecture"); } return ""; } @@ -199,7 +327,7 @@ Solaris::Solaris(const Driver &D, const llvm::Triple &Triple, // If we are currently running Clang inside of the requested system root, // add its parent library path to those searched. - if (StringRef(D.Dir).startswith(D.SysRoot)) + if (StringRef(D.Dir).starts_with(D.SysRoot)) addPathIfExists(D, D.Dir + "/../lib", Paths); addPathIfExists(D, D.SysRoot + "/usr/lib" + LibSuffix, Paths); @@ -207,7 +335,6 @@ Solaris::Solaris(const Driver &D, const llvm::Triple &Triple, SanitizerMask Solaris::getSupportedSanitizers() const { const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; - const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; SanitizerMask Res = ToolChain::getSupportedSanitizers(); // FIXME: Omit X86_64 until 64-bit support is figured out. if (IsX86) { @@ -215,12 +342,17 @@ SanitizerMask Solaris::getSupportedSanitizers() const { Res |= SanitizerKind::PointerCompare; Res |= SanitizerKind::PointerSubtract; } - if (IsX86 || IsX86_64) - Res |= SanitizerKind::Function; Res |= SanitizerKind::Vptr; return Res; } +const char *Solaris::getDefaultLinker() const { + // FIXME: Only handle Solaris ld and GNU ld here. + return llvm::StringSwitch<const char *>(CLANG_DEFAULT_LINKER) + .Cases("bfd", "gld", "/usr/gnu/bin/ld") + .Default("/usr/bin/ld"); +} + Tool *Solaris::buildAssembler() const { return new tools::solaris::Assembler(*this); } |