contrib/llvm-project/clang/lib/Driver/ToolChains/FreeBSD.cpp

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