1 //===--- FreeBSD.cpp - FreeBSD 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 "FreeBSD.h"
10 #include "Arch/ARM.h"
11 #include "Arch/Mips.h"
12 #include "Arch/Sparc.h"
13 #include "CommonArgs.h"
14 #include "clang/Driver/Compilation.h"
15 #include "clang/Driver/Options.h"
16 #include "clang/Driver/SanitizerArgs.h"
17 #include "llvm/Option/ArgList.h"
18 #include "llvm/Support/VirtualFileSystem.h"
19
20 using namespace clang::driver;
21 using namespace clang::driver::tools;
22 using namespace clang::driver::toolchains;
23 using namespace clang;
24 using namespace llvm::opt;
25
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const26 void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
27 const InputInfo &Output,
28 const InputInfoList &Inputs,
29 const ArgList &Args,
30 const char *LinkingOutput) const {
31 claimNoWarnArgs(Args);
32 ArgStringList CmdArgs;
33
34 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
35 // instruct as in the base system to assemble 32-bit code.
36 switch (getToolChain().getArch()) {
37 default:
38 break;
39 case llvm::Triple::x86:
40 CmdArgs.push_back("--32");
41 break;
42 case llvm::Triple::ppc:
43 CmdArgs.push_back("-a32");
44 break;
45 case llvm::Triple::mips:
46 case llvm::Triple::mipsel:
47 case llvm::Triple::mips64:
48 case llvm::Triple::mips64el: {
49 StringRef CPUName;
50 StringRef ABIName;
51 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
52
53 CmdArgs.push_back("-march");
54 CmdArgs.push_back(CPUName.data());
55
56 CmdArgs.push_back("-mabi");
57 CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data());
58
59 if (getToolChain().getTriple().isLittleEndian())
60 CmdArgs.push_back("-EL");
61 else
62 CmdArgs.push_back("-EB");
63
64 if (Arg *A = Args.getLastArg(options::OPT_G)) {
65 StringRef v = A->getValue();
66 CmdArgs.push_back(Args.MakeArgString("-G" + v));
67 A->claim();
68 }
69
70 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
71 break;
72 }
73 case llvm::Triple::arm:
74 case llvm::Triple::armeb:
75 case llvm::Triple::thumb:
76 case llvm::Triple::thumbeb: {
77 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
78
79 if (ABI == arm::FloatABI::Hard)
80 CmdArgs.push_back("-mfpu=vfp");
81 else
82 CmdArgs.push_back("-mfpu=softvfp");
83
84 switch (getToolChain().getTriple().getEnvironment()) {
85 case llvm::Triple::GNUEABIHF:
86 case llvm::Triple::GNUEABI:
87 case llvm::Triple::EABI:
88 CmdArgs.push_back("-meabi=5");
89 break;
90
91 default:
92 CmdArgs.push_back("-matpcs");
93 }
94 break;
95 }
96 case llvm::Triple::sparc:
97 case llvm::Triple::sparcel:
98 case llvm::Triple::sparcv9: {
99 std::string CPU = getCPUName(Args, getToolChain().getTriple());
100 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
101 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
102 break;
103 }
104 }
105
106 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
107
108 CmdArgs.push_back("-o");
109 CmdArgs.push_back(Output.getFilename());
110
111 for (const auto &II : Inputs)
112 CmdArgs.push_back(II.getFilename());
113
114 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
115 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
116 }
117
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const118 void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
119 const InputInfo &Output,
120 const InputInfoList &Inputs,
121 const ArgList &Args,
122 const char *LinkingOutput) const {
123 const toolchains::FreeBSD &ToolChain =
124 static_cast<const toolchains::FreeBSD &>(getToolChain());
125 const Driver &D = ToolChain.getDriver();
126 const llvm::Triple::ArchType Arch = ToolChain.getArch();
127 const bool IsPIE =
128 !Args.hasArg(options::OPT_shared) &&
129 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
130 ArgStringList CmdArgs;
131
132 // Silence warning for "clang -g foo.o -o foo"
133 Args.ClaimAllArgs(options::OPT_g_Group);
134 // and "clang -emit-llvm foo.o -o foo"
135 Args.ClaimAllArgs(options::OPT_emit_llvm);
136 // and for "clang -w foo.o -o foo". Other warning options are already
137 // handled somewhere else.
138 Args.ClaimAllArgs(options::OPT_w);
139
140 if (!D.SysRoot.empty())
141 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
142
143 if (IsPIE)
144 CmdArgs.push_back("-pie");
145
146 CmdArgs.push_back("--eh-frame-hdr");
147 if (Args.hasArg(options::OPT_static)) {
148 CmdArgs.push_back("-Bstatic");
149 } else {
150 if (Args.hasArg(options::OPT_rdynamic))
151 CmdArgs.push_back("-export-dynamic");
152 if (Args.hasArg(options::OPT_shared)) {
153 CmdArgs.push_back("-Bshareable");
154 } else {
155 CmdArgs.push_back("-dynamic-linker");
156 CmdArgs.push_back("/libexec/ld-elf.so.1");
157 }
158 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
159 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
160 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
161 CmdArgs.push_back("--hash-style=both");
162 }
163 }
164 CmdArgs.push_back("--enable-new-dtags");
165 }
166
167 // Explicitly set the linker emulation for platforms that might not
168 // be the default emulation for the linker.
169 switch (Arch) {
170 case llvm::Triple::x86:
171 CmdArgs.push_back("-m");
172 CmdArgs.push_back("elf_i386_fbsd");
173 break;
174 case llvm::Triple::ppc:
175 CmdArgs.push_back("-m");
176 CmdArgs.push_back("elf32ppc_fbsd");
177 break;
178 case llvm::Triple::mips:
179 CmdArgs.push_back("-m");
180 CmdArgs.push_back("elf32btsmip_fbsd");
181 break;
182 case llvm::Triple::mipsel:
183 CmdArgs.push_back("-m");
184 CmdArgs.push_back("elf32ltsmip_fbsd");
185 break;
186 case llvm::Triple::mips64:
187 CmdArgs.push_back("-m");
188 if (tools::mips::hasMipsAbiArg(Args, "n32"))
189 CmdArgs.push_back("elf32btsmipn32_fbsd");
190 else
191 CmdArgs.push_back("elf64btsmip_fbsd");
192 break;
193 case llvm::Triple::mips64el:
194 CmdArgs.push_back("-m");
195 if (tools::mips::hasMipsAbiArg(Args, "n32"))
196 CmdArgs.push_back("elf32ltsmipn32_fbsd");
197 else
198 CmdArgs.push_back("elf64ltsmip_fbsd");
199 break;
200 default:
201 break;
202 }
203
204 if (Arg *A = Args.getLastArg(options::OPT_G)) {
205 if (ToolChain.getTriple().isMIPS()) {
206 StringRef v = A->getValue();
207 CmdArgs.push_back(Args.MakeArgString("-G" + v));
208 A->claim();
209 }
210 }
211
212 if (Output.isFilename()) {
213 CmdArgs.push_back("-o");
214 CmdArgs.push_back(Output.getFilename());
215 } else {
216 assert(Output.isNothing() && "Invalid output.");
217 }
218
219 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
220 const char *crt1 = nullptr;
221 if (!Args.hasArg(options::OPT_shared)) {
222 if (Args.hasArg(options::OPT_pg))
223 crt1 = "gcrt1.o";
224 else if (IsPIE)
225 crt1 = "Scrt1.o";
226 else
227 crt1 = "crt1.o";
228 }
229 if (crt1)
230 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
231
232 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
233
234 const char *crtbegin = nullptr;
235 if (Args.hasArg(options::OPT_static))
236 crtbegin = "crtbeginT.o";
237 else if (Args.hasArg(options::OPT_shared) || IsPIE)
238 crtbegin = "crtbeginS.o";
239 else
240 crtbegin = "crtbegin.o";
241
242 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
243 }
244
245 Args.AddAllArgs(CmdArgs, options::OPT_L);
246 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
247 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
248 Args.AddAllArgs(CmdArgs, options::OPT_e);
249 Args.AddAllArgs(CmdArgs, options::OPT_s);
250 Args.AddAllArgs(CmdArgs, options::OPT_t);
251 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
252 Args.AddAllArgs(CmdArgs, options::OPT_r);
253
254 if (D.isUsingLTO()) {
255 assert(!Inputs.empty() && "Must have at least one input.");
256 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
257 D.getLTOMode() == LTOK_Thin);
258 }
259
260 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
261 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
262 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
263
264 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
265 addOpenMPRuntime(CmdArgs, ToolChain, Args);
266 if (D.CCCIsCXX()) {
267 if (ToolChain.ShouldLinkCXXStdlib(Args))
268 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
269 if (Args.hasArg(options::OPT_pg))
270 CmdArgs.push_back("-lm_p");
271 else
272 CmdArgs.push_back("-lm");
273 }
274 if (NeedsSanitizerDeps)
275 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
276 if (NeedsXRayDeps)
277 linkXRayRuntimeDeps(ToolChain, CmdArgs);
278 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
279 // the default system libraries. Just mimic this for now.
280 if (Args.hasArg(options::OPT_pg))
281 CmdArgs.push_back("-lgcc_p");
282 else
283 CmdArgs.push_back("-lgcc");
284 if (Args.hasArg(options::OPT_static)) {
285 CmdArgs.push_back("-lgcc_eh");
286 } else if (Args.hasArg(options::OPT_pg)) {
287 CmdArgs.push_back("-lgcc_eh_p");
288 } else {
289 CmdArgs.push_back("--as-needed");
290 CmdArgs.push_back("-lgcc_s");
291 CmdArgs.push_back("--no-as-needed");
292 }
293
294 if (Args.hasArg(options::OPT_pthread)) {
295 if (Args.hasArg(options::OPT_pg))
296 CmdArgs.push_back("-lpthread_p");
297 else
298 CmdArgs.push_back("-lpthread");
299 }
300
301 if (Args.hasArg(options::OPT_pg)) {
302 if (Args.hasArg(options::OPT_shared))
303 CmdArgs.push_back("-lc");
304 else
305 CmdArgs.push_back("-lc_p");
306 CmdArgs.push_back("-lgcc_p");
307 } else {
308 CmdArgs.push_back("-lc");
309 CmdArgs.push_back("-lgcc");
310 }
311
312 if (Args.hasArg(options::OPT_static)) {
313 CmdArgs.push_back("-lgcc_eh");
314 } else if (Args.hasArg(options::OPT_pg)) {
315 CmdArgs.push_back("-lgcc_eh_p");
316 } else {
317 CmdArgs.push_back("--as-needed");
318 CmdArgs.push_back("-lgcc_s");
319 CmdArgs.push_back("--no-as-needed");
320 }
321 }
322
323 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
324 if (Args.hasArg(options::OPT_shared) || IsPIE)
325 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
326 else
327 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
328 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
329 }
330
331 ToolChain.addProfileRTLibs(Args, CmdArgs);
332
333 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
334 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
335 }
336
337 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
338
FreeBSD(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)339 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
340 const ArgList &Args)
341 : Generic_ELF(D, Triple, Args) {
342
343 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
344 // back to '/usr/lib' if it doesn't exist.
345 if ((Triple.getArch() == llvm::Triple::x86 || Triple.isMIPS32() ||
346 Triple.getArch() == llvm::Triple::ppc) &&
347 D.getVFS().exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
348 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
349 else
350 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
351 }
352
GetDefaultCXXStdlibType() const353 ToolChain::CXXStdlibType FreeBSD::GetDefaultCXXStdlibType() const {
354 unsigned Major = getTriple().getOSMajorVersion();
355 if (Major >= 10 || Major == 0)
356 return ToolChain::CST_Libcxx;
357 return ToolChain::CST_Libstdcxx;
358 }
359
addLibStdCxxIncludePaths(const llvm::opt::ArgList & DriverArgs,llvm::opt::ArgStringList & CC1Args) const360 void FreeBSD::addLibStdCxxIncludePaths(
361 const llvm::opt::ArgList &DriverArgs,
362 llvm::opt::ArgStringList &CC1Args) const {
363 addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/c++/4.2", "", "",
364 "", "", DriverArgs, CC1Args);
365 }
366
AddCXXStdlibLibArgs(const ArgList & Args,ArgStringList & CmdArgs) const367 void FreeBSD::AddCXXStdlibLibArgs(const ArgList &Args,
368 ArgStringList &CmdArgs) const {
369 CXXStdlibType Type = GetCXXStdlibType(Args);
370 bool Profiling = Args.hasArg(options::OPT_pg);
371
372 switch (Type) {
373 case ToolChain::CST_Libcxx:
374 CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");
375 break;
376
377 case ToolChain::CST_Libstdcxx:
378 CmdArgs.push_back(Profiling ? "-lstdc++_p" : "-lstdc++");
379 break;
380 }
381 }
382
buildAssembler() const383 Tool *FreeBSD::buildAssembler() const {
384 return new tools::freebsd::Assembler(*this);
385 }
386
buildLinker() const387 Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
388
GetExceptionModel(const ArgList & Args) const389 llvm::ExceptionHandling FreeBSD::GetExceptionModel(const ArgList &Args) const {
390 // FreeBSD uses SjLj exceptions on ARM oabi.
391 switch (getTriple().getEnvironment()) {
392 case llvm::Triple::GNUEABIHF:
393 case llvm::Triple::GNUEABI:
394 case llvm::Triple::EABI:
395 return llvm::ExceptionHandling::None;
396 default:
397 if (getTriple().getArch() == llvm::Triple::arm ||
398 getTriple().getArch() == llvm::Triple::thumb)
399 return llvm::ExceptionHandling::SjLj;
400 return llvm::ExceptionHandling::None;
401 }
402 }
403
HasNativeLLVMSupport() const404 bool FreeBSD::HasNativeLLVMSupport() const { return true; }
405
isPIEDefault() const406 bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
407
getSupportedSanitizers() const408 SanitizerMask FreeBSD::getSupportedSanitizers() const {
409 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
410 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
411 const bool IsMIPS64 = getTriple().isMIPS64();
412 SanitizerMask Res = ToolChain::getSupportedSanitizers();
413 Res |= SanitizerKind::Address;
414 Res |= SanitizerKind::PointerCompare;
415 Res |= SanitizerKind::PointerSubtract;
416 Res |= SanitizerKind::Vptr;
417 if (IsX86_64 || IsMIPS64) {
418 Res |= SanitizerKind::Leak;
419 Res |= SanitizerKind::Thread;
420 }
421 if (IsX86 || IsX86_64) {
422 Res |= SanitizerKind::Function;
423 Res |= SanitizerKind::SafeStack;
424 Res |= SanitizerKind::Fuzzer;
425 Res |= SanitizerKind::FuzzerNoLink;
426 }
427 if (IsX86_64)
428 Res |= SanitizerKind::Memory;
429 return Res;
430 }
431