clang/lib/Driver/ToolChains/Solaris.cpp

   1 //===--- Solaris.cpp - Solaris ToolChain Implementations --------*- C++ -*-===//
   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 #include "Solaris.h"
  10 #include "CommonArgs.h"
  11 #include "Gnu.h"
  12 #include "clang/Basic/LangStandard.h"
  13 #include "clang/Config/config.h"
  14 #include "clang/Driver/Compilation.h"
  15 #include "clang/Driver/Driver.h"
  16 #include "clang/Driver/DriverDiagnostic.h"
  17 #include "clang/Driver/Options.h"
  18 #include "clang/Driver/SanitizerArgs.h"
  19 #include "clang/Driver/ToolChain.h"
  20 #include "llvm/ADT/StringSwitch.h"
  21 #include "llvm/Option/ArgList.h"
  22 #include "llvm/Support/FileSystem.h"
  23 #include "llvm/Support/Path.h"
  24
  25 using namespace clang::driver;
  26 using namespace clang::driver::tools;
  27 using namespace clang::driver::toolchains;
  28 using namespace clang;
  29 using namespace llvm::opt;
  30
  31 void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
  32                                       const InputInfo &Output,
  33                                       const InputInfoList &Inputs,
  34                                       const ArgList &Args,
  35                                       const char *LinkingOutput) const {
  36   // Just call the Gnu version, which enforces gas on Solaris.
  37   gnutools::Assembler::ConstructJob(C, JA, Output, Inputs, Args, LinkingOutput);
  38 }
  39
  40 bool solaris::isLinkerGnuLd(const ToolChain &TC, const ArgList &Args) {
  41   // Only used if targetting Solaris.
  42   const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ);
  43   StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
  44   return UseLinker == "bfd" || UseLinker == "gld";
  45 }
  46
  47 static bool getPIE(const ArgList &Args, const ToolChain &TC) {
  48   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
  49       Args.hasArg(options::OPT_r))
  50     return false;
  51
  52   Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
  53                            options::OPT_nopie);
  54   if (!A)
  55     return TC.isPIEDefault(Args);
  56   return A->getOption().matches(options::OPT_pie);
  57 }
  58
  59 // FIXME: Need to handle CLANG_DEFAULT_LINKER here?
  60 std::string solaris::Linker::getLinkerPath(const ArgList &Args) const {
  61   const ToolChain &ToolChain = getToolChain();
  62   if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
  63     StringRef UseLinker = A->getValue();
  64     if (!UseLinker.empty()) {
  65       if (llvm::sys::path::is_absolute(UseLinker) &&
  66           llvm::sys::fs::can_execute(UseLinker))
  67         return std::string(UseLinker);
  68
  69       // Accept 'bfd' and 'gld' as aliases for the GNU linker.
  70       if (UseLinker == "bfd" || UseLinker == "gld")
  71         // FIXME: Could also use /usr/bin/gld here.
  72         return "/usr/gnu/bin/ld";
  73
  74       // Accept 'ld' as alias for the default linker
  75       if (UseLinker != "ld")
  76         ToolChain.getDriver().Diag(diag::err_drv_invalid_linker_name)
  77             << A->getAsString(Args);
  78     }
  79   }
  80
  81   // getDefaultLinker() always returns an absolute path.
  82   return ToolChain.getDefaultLinker();
  83 }
  84
  85 void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
  86                                    const InputInfo &Output,
  87                                    const InputInfoList &Inputs,
  88                                    const ArgList &Args,
  89                                    const char *LinkingOutput) const {
  90   const Driver &D = getToolChain().getDriver();
  91   const bool IsPIE = getPIE(Args, getToolChain());
  92   ArgStringList CmdArgs;
  93   bool LinkerIsGnuLd = isLinkerGnuLd(getToolChain(), Args);
  94
  95   // Demangle C++ names in errors.  GNU ld already defaults to --demangle.
  96   if (!LinkerIsGnuLd)
  97     CmdArgs.push_back("-C");
  98
  99   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared,
 100                    options::OPT_r)) {
 101     CmdArgs.push_back("-e");
 102     CmdArgs.push_back("_start");
 103   }
 104
 105   if (IsPIE) {
 106     if (LinkerIsGnuLd) {
 107       CmdArgs.push_back("-pie");
 108     } else {
 109       CmdArgs.push_back("-z");
 110       CmdArgs.push_back("type=pie");
 111     }
 112   }
 113
 114   if (Args.hasArg(options::OPT_static)) {
 115     CmdArgs.push_back("-Bstatic");
 116     CmdArgs.push_back("-dn");
 117   } else {
 118     if (!Args.hasArg(options::OPT_r) && Args.hasArg(options::OPT_shared))
 119       CmdArgs.push_back("-shared");
 120
 121     // libpthread has been folded into libc since Solaris 10, no need to do
 122     // anything for pthreads. Claim argument to avoid warning.
 123     Args.ClaimAllArgs(options::OPT_pthread);
 124     Args.ClaimAllArgs(options::OPT_pthreads);
 125   }
 126
 127   if (LinkerIsGnuLd) {
 128     // Set the correct linker emulation for 32- and 64-bit Solaris.
 129     const auto &ToolChain = static_cast<const Solaris &>(getToolChain());
 130     const llvm::Triple::ArchType Arch = ToolChain.getArch();
 131
 132     switch (Arch) {
 133     case llvm::Triple::x86:
 134       CmdArgs.push_back("-m");
 135       CmdArgs.push_back("elf_i386_sol2");
 136       break;
 137     case llvm::Triple::x86_64:
 138       CmdArgs.push_back("-m");
 139       CmdArgs.push_back("elf_x86_64_sol2");
 140       break;
 141     case llvm::Triple::sparc:
 142       CmdArgs.push_back("-m");
 143       CmdArgs.push_back("elf32_sparc_sol2");
 144       break;
 145     case llvm::Triple::sparcv9:
 146       CmdArgs.push_back("-m");
 147       CmdArgs.push_back("elf64_sparc_sol2");
 148       break;
 149     default:
 150       break;
 151     }
 152
 153     if (Args.hasArg(options::OPT_rdynamic))
 154       CmdArgs.push_back("-export-dynamic");
 155
 156     CmdArgs.push_back("--eh-frame-hdr");
 157   } else {
 158     // -rdynamic is a no-op with Solaris ld.  Claim argument to avoid warning.
 159     Args.ClaimAllArgs(options::OPT_rdynamic);
 160   }
 161
 162   assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
 163   if (Output.isFilename()) {
 164     CmdArgs.push_back("-o");
 165     CmdArgs.push_back(Output.getFilename());
 166   }
 167
 168   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
 169                    options::OPT_r)) {
 170     if (!Args.hasArg(options::OPT_shared))
 171       CmdArgs.push_back(
 172           Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
 173
 174     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
 175
 176     const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
 177     bool HaveAnsi = false;
 178     const LangStandard *LangStd = nullptr;
 179     if (Std) {
 180       HaveAnsi = Std->getOption().matches(options::OPT_ansi);
 181       if (!HaveAnsi)
 182         LangStd = LangStandard::getLangStandardForName(Std->getValue());
 183     }
 184
 185     const char *values_X = "values-Xa.o";
 186     // Use values-Xc.o for -ansi, -std=c*, -std=iso9899:199409.
 187     if (HaveAnsi || (LangStd && !LangStd->isGNUMode()))
 188       values_X = "values-Xc.o";
 189     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(values_X)));
 190
 191     const char *values_xpg = "values-xpg6.o";
 192     // Use values-xpg4.o for -std=c90, -std=gnu90, -std=iso9899:199409.
 193     if (LangStd && LangStd->getLanguage() == Language::C && !LangStd->isC99())
 194       values_xpg = "values-xpg4.o";
 195     CmdArgs.push_back(
 196         Args.MakeArgString(getToolChain().GetFilePath(values_xpg)));
 197
 198     const char *crtbegin = nullptr;
 199     if (Args.hasArg(options::OPT_shared) || IsPIE)
 200       crtbegin = "crtbeginS.o";
 201     else
 202       crtbegin = "crtbegin.o";
 203     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(crtbegin)));
 204     // Add crtfastmath.o if available and fast math is enabled.
 205     getToolChain().addFastMathRuntimeIfAvailable(Args, CmdArgs);
 206   }
 207
 208   getToolChain().AddFilePathLibArgs(Args, CmdArgs);
 209
 210   Args.addAllArgs(CmdArgs,
 211                   {options::OPT_L, options::OPT_T_Group, options::OPT_r});
 212
 213   bool NeedsSanitizerDeps = addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
 214   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
 215
 216   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
 217                    options::OPT_r)) {
 218     // Use the static OpenMP runtime with -static-openmp
 219     bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
 220                         !Args.hasArg(options::OPT_static);
 221     addOpenMPRuntime(CmdArgs, getToolChain(), Args, StaticOpenMP);
 222
 223     if (D.CCCIsCXX()) {
 224       if (getToolChain().ShouldLinkCXXStdlib(Args))
 225         getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
 226       CmdArgs.push_back("-lm");
 227     }
 228     // Silence warnings when linking C code with a C++ '-stdlib' argument.
 229     Args.ClaimAllArgs(options::OPT_stdlib_EQ);
 230     // Additional linker set-up and flags for Fortran. This is required in order
 231     // to generate executables. As Fortran runtime depends on the C runtime,
 232     // these dependencies need to be listed before the C runtime below.
 233     if (D.IsFlangMode()) {
 234       addFortranRuntimeLibraryPath(getToolChain(), Args, CmdArgs);
 235       addFortranRuntimeLibs(getToolChain(), CmdArgs);
 236       CmdArgs.push_back("-lm");
 237     }
 238     if (Args.hasArg(options::OPT_fstack_protector) ||
 239         Args.hasArg(options::OPT_fstack_protector_strong) ||
 240         Args.hasArg(options::OPT_fstack_protector_all)) {
 241       // Explicitly link ssp libraries, not folded into Solaris libc.
 242       CmdArgs.push_back("-lssp_nonshared");
 243       CmdArgs.push_back("-lssp");
 244     }
 245     // LLVM support for atomics on 32-bit SPARC V8+ is incomplete, so
 246     // forcibly link with libatomic as a workaround.
 247     if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
 248       addAsNeededOption(getToolChain(), Args, CmdArgs, true);
 249       CmdArgs.push_back("-latomic");
 250       addAsNeededOption(getToolChain(), Args, CmdArgs, false);
 251     }
 252     addAsNeededOption(getToolChain(), Args, CmdArgs, true);
 253     CmdArgs.push_back("-lgcc_s");
 254     addAsNeededOption(getToolChain(), Args, CmdArgs, false);
 255     CmdArgs.push_back("-lc");
 256     if (!Args.hasArg(options::OPT_shared)) {
 257       CmdArgs.push_back("-lgcc");
 258     }
 259     const SanitizerArgs &SA = getToolChain().getSanitizerArgs(Args);
 260     if (NeedsSanitizerDeps) {
 261       linkSanitizerRuntimeDeps(getToolChain(), Args, CmdArgs);
 262
 263       // Work around Solaris/amd64 ld bug when calling __tls_get_addr directly.
 264       // However, ld -z relax=transtls is available since Solaris 11.2, but not
 265       // in Illumos.
 266       if (getToolChain().getTriple().getArch() == llvm::Triple::x86_64 &&
 267           (SA.needsAsanRt() || SA.needsStatsRt() ||
 268            (SA.needsUbsanRt() && !SA.requiresMinimalRuntime())) &&
 269           !LinkerIsGnuLd) {
 270         CmdArgs.push_back("-z");
 271         CmdArgs.push_back("relax=transtls");
 272       }
 273     }
 274     // Avoid AsanInitInternal cycle, Issue #64126.
 275     if (getToolChain().getTriple().isX86() && SA.needsSharedRt() &&
 276         SA.needsAsanRt()) {
 277       CmdArgs.push_back("-z");
 278       CmdArgs.push_back("now");
 279     }
 280   }
 281
 282   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
 283                    options::OPT_r)) {
 284     if (Args.hasArg(options::OPT_shared) || IsPIE)
 285       CmdArgs.push_back(
 286           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
 287     else
 288       CmdArgs.push_back(
 289           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
 290     CmdArgs.push_back(
 291         Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
 292   }
 293
 294   getToolChain().addProfileRTLibs(Args, CmdArgs);
 295
 296   const char *Exec = Args.MakeArgString(getLinkerPath(Args));
 297   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
 298                                          Exec, CmdArgs, Inputs, Output));
 299 }
 300
 301 static StringRef getSolarisLibSuffix(const llvm::Triple &Triple) {
 302   switch (Triple.getArch()) {
 303   case llvm::Triple::x86:
 304   case llvm::Triple::sparc:
 305     break;
 306   case llvm::Triple::x86_64:
 307     return "/amd64";
 308   case llvm::Triple::sparcv9:
 309     return "/sparcv9";
 310   default:
 311     llvm_unreachable("Unsupported architecture");
 312   }
 313   return "";
 314 }
 315
 316 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
 317
 318 Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
 319                  const ArgList &Args)
 320     : Generic_ELF(D, Triple, Args) {
 321
 322   GCCInstallation.init(Triple, Args);
 323
 324   StringRef LibSuffix = getSolarisLibSuffix(Triple);
 325   path_list &Paths = getFilePaths();
 326   if (GCCInstallation.isValid()) {
 327     // On Solaris gcc uses both an architecture-specific path with triple in it
 328     // as well as a more generic lib path (+arch suffix).
 329     addPathIfExists(D,
 330                     GCCInstallation.getInstallPath() +
 331                         GCCInstallation.getMultilib().gccSuffix(),
 332                     Paths);
 333     addPathIfExists(D, GCCInstallation.getParentLibPath() + LibSuffix, Paths);
 334   }
 335
 336   // If we are currently running Clang inside of the requested system root,
 337   // add its parent library path to those searched.
 338   if (StringRef(D.Dir).startswith(D.SysRoot))
 339     addPathIfExists(D, D.Dir + "/../lib", Paths);
 340
 341   addPathIfExists(D, D.SysRoot + "/usr/lib" + LibSuffix, Paths);
 342 }
 343
 344 SanitizerMask Solaris::getSupportedSanitizers() const {
 345   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
 346   SanitizerMask Res = ToolChain::getSupportedSanitizers();
 347   // FIXME: Omit X86_64 until 64-bit support is figured out.
 348   if (IsX86) {
 349     Res |= SanitizerKind::Address;
 350     Res |= SanitizerKind::PointerCompare;
 351     Res |= SanitizerKind::PointerSubtract;
 352   }
 353   Res |= SanitizerKind::Vptr;
 354   return Res;
 355 }
 356
 357 const char *Solaris::getDefaultLinker() const {
 358   // FIXME: Only handle Solaris ld and GNU ld here.
 359   return llvm::StringSwitch<const char *>(CLANG_DEFAULT_LINKER)
 360       .Cases("bfd", "gld", "/usr/gnu/bin/ld")
 361       .Default("/usr/bin/ld");
 362 }
 363
 364 Tool *Solaris::buildAssembler() const {
 365   return new tools::solaris::Assembler(*this);
 366 }
 367
 368 Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
 369
 370 void Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 371                                         ArgStringList &CC1Args) const {
 372   const Driver &D = getDriver();
 373
 374   if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
 375     return;
 376
 377   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
 378     addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
 379
 380   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
 381     SmallString<128> P(D.ResourceDir);
 382     llvm::sys::path::append(P, "include");
 383     addSystemInclude(DriverArgs, CC1Args, P);
 384   }
 385
 386   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
 387     return;
 388
 389   // Check for configure-time C include directories.
 390   StringRef CIncludeDirs(C_INCLUDE_DIRS);
 391   if (CIncludeDirs != "") {
 392     SmallVector<StringRef, 5> dirs;
 393     CIncludeDirs.split(dirs, ":");
 394     for (StringRef dir : dirs) {
 395       StringRef Prefix =
 396           llvm::sys::path::is_absolute(dir) ? "" : StringRef(D.SysRoot);
 397       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
 398     }
 399     return;
 400   }
 401
 402   // Add include directories specific to the selected multilib set and multilib.
 403   if (GCCInstallation.isValid()) {
 404     const MultilibSet::IncludeDirsFunc &Callback =
 405         Multilibs.includeDirsCallback();
 406     if (Callback) {
 407       for (const auto &Path : Callback(GCCInstallation.getMultilib()))
 408         addExternCSystemIncludeIfExists(
 409             DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
 410     }
 411   }
 412
 413   addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
 414 }
 415
 416 void Solaris::addLibStdCxxIncludePaths(
 417     const llvm::opt::ArgList &DriverArgs,
 418     llvm::opt::ArgStringList &CC1Args) const {
 419   // We need a detected GCC installation on Solaris (similar to Linux)
 420   // to provide libstdc++'s headers.
 421   if (!GCCInstallation.isValid())
 422     return;
 423
 424   // By default, look for the C++ headers in an include directory adjacent to
 425   // the lib directory of the GCC installation.
 426   // On Solaris this usually looks like /usr/gcc/X.Y/include/c++/X.Y.Z
 427   StringRef LibDir = GCCInstallation.getParentLibPath();
 428   StringRef TripleStr = GCCInstallation.getTriple().str();
 429   const Multilib &Multilib = GCCInstallation.getMultilib();
 430   const GCCVersion &Version = GCCInstallation.getVersion();
 431
 432   // The primary search for libstdc++ supports multiarch variants.
 433   addLibStdCXXIncludePaths(LibDir.str() + "/../include/c++/" + Version.Text,
 434                            TripleStr, Multilib.includeSuffix(), DriverArgs,
 435                            CC1Args);
 436 }