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