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