1 //===--- NetBSD.cpp - NetBSD 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 "NetBSD.h" 10 #include "Arch/ARM.h" 11 #include "Arch/Mips.h" 12 #include "Arch/Sparc.h" 13 #include "CommonArgs.h" 14 #include "clang/Config/config.h" 15 #include "clang/Driver/Compilation.h" 16 #include "clang/Driver/Driver.h" 17 #include "clang/Driver/Options.h" 18 #include "clang/Driver/SanitizerArgs.h" 19 #include "llvm/Option/ArgList.h" 20 #include "llvm/Support/VirtualFileSystem.h" 21 22 using namespace clang::driver; 23 using namespace clang::driver::tools; 24 using namespace clang::driver::toolchains; 25 using namespace clang; 26 using namespace llvm::opt; 27 28 void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 29 const InputInfo &Output, 30 const InputInfoList &Inputs, 31 const ArgList &Args, 32 const char *LinkingOutput) const { 33 const auto &ToolChain = static_cast<const NetBSD &>(getToolChain()); 34 const Driver &D = ToolChain.getDriver(); 35 const llvm::Triple &Triple = ToolChain.getTriple(); 36 ArgStringList CmdArgs; 37 38 claimNoWarnArgs(Args); 39 40 // GNU as needs different flags for creating the correct output format 41 // on architectures with different ABIs or optional feature sets. 42 switch (ToolChain.getArch()) { 43 case llvm::Triple::x86: 44 CmdArgs.push_back("--32"); 45 break; 46 case llvm::Triple::arm: 47 case llvm::Triple::armeb: 48 case llvm::Triple::thumb: 49 case llvm::Triple::thumbeb: { 50 StringRef MArch, MCPU; 51 arm::getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true); 52 std::string Arch = arm::getARMTargetCPU(MCPU, MArch, Triple); 53 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch)); 54 break; 55 } 56 57 case llvm::Triple::mips: 58 case llvm::Triple::mipsel: 59 case llvm::Triple::mips64: 60 case llvm::Triple::mips64el: { 61 StringRef CPUName; 62 StringRef ABIName; 63 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 64 65 CmdArgs.push_back("-march"); 66 CmdArgs.push_back(CPUName.data()); 67 68 CmdArgs.push_back("-mabi"); 69 CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data()); 70 71 if (Triple.isLittleEndian()) 72 CmdArgs.push_back("-EL"); 73 else 74 CmdArgs.push_back("-EB"); 75 76 AddAssemblerKPIC(ToolChain, Args, CmdArgs); 77 break; 78 } 79 80 case llvm::Triple::sparc: { 81 CmdArgs.push_back("-32"); 82 std::string CPU = getCPUName(D, Args, Triple); 83 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, Triple)); 84 AddAssemblerKPIC(ToolChain, Args, CmdArgs); 85 break; 86 } 87 88 case llvm::Triple::sparcv9: { 89 CmdArgs.push_back("-64"); 90 std::string CPU = getCPUName(D, Args, Triple); 91 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, Triple)); 92 AddAssemblerKPIC(ToolChain, Args, CmdArgs); 93 break; 94 } 95 96 default: 97 break; 98 } 99 100 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 101 102 CmdArgs.push_back("-o"); 103 CmdArgs.push_back(Output.getFilename()); 104 105 for (const auto &II : Inputs) 106 CmdArgs.push_back(II.getFilename()); 107 108 const char *Exec = Args.MakeArgString((ToolChain.GetProgramPath("as"))); 109 C.addCommand(std::make_unique<Command>(JA, *this, 110 ResponseFileSupport::AtFileCurCP(), 111 Exec, CmdArgs, Inputs, Output)); 112 } 113 114 void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, 115 const InputInfo &Output, 116 const InputInfoList &Inputs, 117 const ArgList &Args, 118 const char *LinkingOutput) const { 119 const auto &ToolChain = static_cast<const NetBSD &>(getToolChain()); 120 const Driver &D = ToolChain.getDriver(); 121 const llvm::Triple &Triple = ToolChain.getTriple(); 122 const llvm::Triple::ArchType Arch = ToolChain.getArch(); 123 const bool Static = Args.hasArg(options::OPT_static); 124 const bool Shared = Args.hasArg(options::OPT_shared); 125 const bool Pie = Args.hasArg(options::OPT_pie); 126 ArgStringList CmdArgs; 127 128 if (!D.SysRoot.empty()) 129 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 130 131 CmdArgs.push_back("--eh-frame-hdr"); 132 if (Static) { 133 CmdArgs.push_back("-Bstatic"); 134 if (Pie) { 135 Args.AddAllArgs(CmdArgs, options::OPT_pie); 136 CmdArgs.push_back("--no-dynamic-linker"); 137 } 138 } else { 139 if (Args.hasArg(options::OPT_rdynamic)) 140 CmdArgs.push_back("-export-dynamic"); 141 if (Shared) { 142 CmdArgs.push_back("-shared"); 143 } else if (!Args.hasArg(options::OPT_r)) { 144 Args.AddAllArgs(CmdArgs, options::OPT_pie); 145 CmdArgs.push_back("-dynamic-linker"); 146 CmdArgs.push_back("/libexec/ld.elf_so"); 147 } 148 } 149 150 // Many NetBSD architectures support more than one ABI. 151 // Determine the correct emulation for ld. 152 switch (Arch) { 153 case llvm::Triple::x86: 154 CmdArgs.push_back("-m"); 155 CmdArgs.push_back("elf_i386"); 156 break; 157 case llvm::Triple::arm: 158 case llvm::Triple::thumb: 159 CmdArgs.push_back("-m"); 160 switch (Triple.getEnvironment()) { 161 case llvm::Triple::EABI: 162 case llvm::Triple::GNUEABI: 163 CmdArgs.push_back("armelf_nbsd_eabi"); 164 break; 165 case llvm::Triple::EABIHF: 166 case llvm::Triple::GNUEABIHF: 167 CmdArgs.push_back("armelf_nbsd_eabihf"); 168 break; 169 default: 170 CmdArgs.push_back("armelf_nbsd"); 171 break; 172 } 173 break; 174 case llvm::Triple::armeb: 175 case llvm::Triple::thumbeb: 176 arm::appendBE8LinkFlag(Args, CmdArgs, ToolChain.getEffectiveTriple()); 177 CmdArgs.push_back("-m"); 178 switch (Triple.getEnvironment()) { 179 case llvm::Triple::EABI: 180 case llvm::Triple::GNUEABI: 181 CmdArgs.push_back("armelfb_nbsd_eabi"); 182 break; 183 case llvm::Triple::EABIHF: 184 case llvm::Triple::GNUEABIHF: 185 CmdArgs.push_back("armelfb_nbsd_eabihf"); 186 break; 187 default: 188 CmdArgs.push_back("armelfb_nbsd"); 189 break; 190 } 191 break; 192 case llvm::Triple::mips64: 193 case llvm::Triple::mips64el: 194 if (mips::hasMipsAbiArg(Args, "32")) { 195 CmdArgs.push_back("-m"); 196 if (Arch == llvm::Triple::mips64) 197 CmdArgs.push_back("elf32btsmip"); 198 else 199 CmdArgs.push_back("elf32ltsmip"); 200 } else if (mips::hasMipsAbiArg(Args, "64")) { 201 CmdArgs.push_back("-m"); 202 if (Arch == llvm::Triple::mips64) 203 CmdArgs.push_back("elf64btsmip"); 204 else 205 CmdArgs.push_back("elf64ltsmip"); 206 } 207 break; 208 case llvm::Triple::ppc: 209 CmdArgs.push_back("-m"); 210 CmdArgs.push_back("elf32ppc_nbsd"); 211 break; 212 213 case llvm::Triple::ppc64: 214 case llvm::Triple::ppc64le: 215 CmdArgs.push_back("-m"); 216 CmdArgs.push_back("elf64ppc"); 217 break; 218 219 case llvm::Triple::riscv32: 220 CmdArgs.push_back("-m"); 221 CmdArgs.push_back("elf32lriscv"); 222 break; 223 224 case llvm::Triple::riscv64: 225 CmdArgs.push_back("-m"); 226 CmdArgs.push_back("elf64lriscv"); 227 break; 228 229 case llvm::Triple::sparc: 230 CmdArgs.push_back("-m"); 231 CmdArgs.push_back("elf32_sparc"); 232 break; 233 234 case llvm::Triple::sparcv9: 235 CmdArgs.push_back("-m"); 236 CmdArgs.push_back("elf64_sparc"); 237 break; 238 239 default: 240 break; 241 } 242 243 if (Triple.isRISCV()) { 244 CmdArgs.push_back("-X"); 245 if (Args.hasArg(options::OPT_mno_relax)) 246 CmdArgs.push_back("--no-relax"); 247 } 248 249 assert((Output.isFilename() || Output.isNothing()) && "Invalid output."); 250 if (Output.isFilename()) { 251 CmdArgs.push_back("-o"); 252 CmdArgs.push_back(Output.getFilename()); 253 } 254 255 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, 256 options::OPT_r)) { 257 const char *crt0 = nullptr; 258 const char *crtbegin = nullptr; 259 if (!Shared) 260 crt0 = "crt0.o"; 261 262 if (Shared || Pie) 263 crtbegin = "crtbeginS.o"; 264 else 265 crtbegin = "crtbegin.o"; 266 267 if (crt0) 268 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt0))); 269 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 270 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 271 } 272 273 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group, 274 options::OPT_s, options::OPT_t}); 275 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 276 277 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); 278 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 279 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 280 281 const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs(Args); 282 if (SanArgs.needsSharedRt()) { 283 CmdArgs.push_back("-rpath"); 284 CmdArgs.push_back(Args.MakeArgString(ToolChain.getCompilerRTPath())); 285 } 286 287 bool useLibgcc = true; 288 switch (ToolChain.getArch()) { 289 case llvm::Triple::aarch64: 290 case llvm::Triple::aarch64_be: 291 case llvm::Triple::arm: 292 case llvm::Triple::armeb: 293 case llvm::Triple::thumb: 294 case llvm::Triple::thumbeb: 295 case llvm::Triple::ppc: 296 case llvm::Triple::ppc64: 297 case llvm::Triple::ppc64le: 298 case llvm::Triple::riscv32: 299 case llvm::Triple::riscv64: 300 case llvm::Triple::sparc: 301 case llvm::Triple::sparcv9: 302 case llvm::Triple::x86: 303 case llvm::Triple::x86_64: 304 useLibgcc = false; 305 break; 306 default: 307 break; 308 } 309 310 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, 311 options::OPT_r)) { 312 // Use the static OpenMP runtime with -static-openmp 313 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && !Static; 314 addOpenMPRuntime(C, CmdArgs, ToolChain, Args, StaticOpenMP); 315 316 if (D.CCCIsCXX()) { 317 if (ToolChain.ShouldLinkCXXStdlib(Args)) 318 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 319 CmdArgs.push_back("-lm"); 320 } 321 322 // Silence warnings when linking C code with a C++ '-stdlib' argument. 323 Args.ClaimAllArgs(options::OPT_stdlib_EQ); 324 325 // Additional linker set-up and flags for Fortran. This is required in order 326 // to generate executables. As Fortran runtime depends on the C runtime, 327 // these dependencies need to be listed before the C runtime below (i.e. 328 // AddRunTimeLibs). 329 if (D.IsFlangMode()) { 330 addFortranRuntimeLibraryPath(ToolChain, Args, CmdArgs); 331 addFortranRuntimeLibs(ToolChain, Args, CmdArgs); 332 CmdArgs.push_back("-lm"); 333 } 334 335 if (NeedsSanitizerDeps) 336 linkSanitizerRuntimeDeps(ToolChain, Args, CmdArgs); 337 if (NeedsXRayDeps) 338 linkXRayRuntimeDeps(ToolChain, Args, CmdArgs); 339 if (Args.hasArg(options::OPT_pthread)) 340 CmdArgs.push_back("-lpthread"); 341 CmdArgs.push_back("-lc"); 342 343 if (useLibgcc) { 344 if (Static) { 345 // libgcc_eh depends on libc, so resolve as much as possible, 346 // pull in any new requirements from libc and then get the rest 347 // of libgcc. 348 CmdArgs.push_back("-lgcc_eh"); 349 CmdArgs.push_back("-lc"); 350 CmdArgs.push_back("-lgcc"); 351 } else { 352 CmdArgs.push_back("-lgcc"); 353 CmdArgs.push_back("--as-needed"); 354 CmdArgs.push_back("-lgcc_s"); 355 CmdArgs.push_back("--no-as-needed"); 356 } 357 } 358 } 359 360 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, 361 options::OPT_r)) { 362 const char *crtend = nullptr; 363 if (Shared || Pie) 364 crtend = "crtendS.o"; 365 else 366 crtend = "crtend.o"; 367 368 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 369 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 370 } 371 372 ToolChain.addProfileRTLibs(Args, CmdArgs); 373 374 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 375 C.addCommand(std::make_unique<Command>(JA, *this, 376 ResponseFileSupport::AtFileCurCP(), 377 Exec, CmdArgs, Inputs, Output)); 378 } 379 380 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 381 382 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 383 : Generic_ELF(D, Triple, Args) { 384 if (!Args.hasArg(options::OPT_nostdlib)) { 385 // When targeting a 32-bit platform, try the special directory used on 386 // 64-bit hosts, and only fall back to the main library directory if that 387 // doesn't work. 388 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure 389 // what all logic is needed to emulate the '=' prefix here. 390 switch (Triple.getArch()) { 391 case llvm::Triple::x86: 392 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/i386")); 393 break; 394 case llvm::Triple::arm: 395 case llvm::Triple::armeb: 396 case llvm::Triple::thumb: 397 case llvm::Triple::thumbeb: 398 switch (Triple.getEnvironment()) { 399 case llvm::Triple::EABI: 400 case llvm::Triple::GNUEABI: 401 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/eabi")); 402 break; 403 case llvm::Triple::EABIHF: 404 case llvm::Triple::GNUEABIHF: 405 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/eabihf")); 406 break; 407 default: 408 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/oabi")); 409 break; 410 } 411 break; 412 case llvm::Triple::mips64: 413 case llvm::Triple::mips64el: 414 if (tools::mips::hasMipsAbiArg(Args, "o32")) 415 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/o32")); 416 else if (tools::mips::hasMipsAbiArg(Args, "64")) 417 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/64")); 418 break; 419 case llvm::Triple::ppc: 420 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/powerpc")); 421 break; 422 case llvm::Triple::sparc: 423 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib/sparc")); 424 break; 425 default: 426 break; 427 } 428 429 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib")); 430 } 431 } 432 433 Tool *NetBSD::buildAssembler() const { 434 return new tools::netbsd::Assembler(*this); 435 } 436 437 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); } 438 439 ToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const { 440 switch (getArch()) { 441 case llvm::Triple::aarch64: 442 case llvm::Triple::aarch64_be: 443 case llvm::Triple::arm: 444 case llvm::Triple::armeb: 445 case llvm::Triple::thumb: 446 case llvm::Triple::thumbeb: 447 case llvm::Triple::ppc: 448 case llvm::Triple::ppc64: 449 case llvm::Triple::ppc64le: 450 case llvm::Triple::riscv32: 451 case llvm::Triple::riscv64: 452 case llvm::Triple::sparc: 453 case llvm::Triple::sparcv9: 454 case llvm::Triple::x86: 455 case llvm::Triple::x86_64: 456 return ToolChain::CST_Libcxx; 457 default: 458 break; 459 } 460 return ToolChain::CST_Libstdcxx; 461 } 462 463 void NetBSD::AddClangSystemIncludeArgs( 464 const llvm::opt::ArgList &DriverArgs, 465 llvm::opt::ArgStringList &CC1Args) const { 466 const Driver &D = getDriver(); 467 468 if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc)) 469 return; 470 471 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 472 SmallString<128> Dir(D.ResourceDir); 473 llvm::sys::path::append(Dir, "include"); 474 addSystemInclude(DriverArgs, CC1Args, Dir.str()); 475 } 476 477 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 478 return; 479 480 // Check for configure-time C include directories. 481 StringRef CIncludeDirs(C_INCLUDE_DIRS); 482 if (CIncludeDirs != "") { 483 SmallVector<StringRef, 5> dirs; 484 CIncludeDirs.split(dirs, ":"); 485 for (StringRef dir : dirs) { 486 StringRef Prefix = 487 llvm::sys::path::is_absolute(dir) ? StringRef(D.SysRoot) : ""; 488 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); 489 } 490 return; 491 } 492 493 addExternCSystemInclude(DriverArgs, CC1Args, 494 concat(D.SysRoot, "/usr/include")); 495 } 496 497 void NetBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 498 llvm::opt::ArgStringList &CC1Args) const { 499 const std::string Candidates[] = { 500 // directory relative to build tree 501 concat(getDriver().Dir, "/../include/c++/v1"), 502 // system install with full upstream path 503 concat(getDriver().SysRoot, "/usr/include/c++/v1"), 504 // system install from src 505 concat(getDriver().SysRoot, "/usr/include/c++"), 506 }; 507 508 for (const auto &IncludePath : Candidates) { 509 if (!getVFS().exists(IncludePath + "/__config")) 510 continue; 511 512 // Use the first candidate that looks valid. 513 addSystemInclude(DriverArgs, CC1Args, IncludePath); 514 return; 515 } 516 } 517 518 void NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 519 llvm::opt::ArgStringList &CC1Args) const { 520 addLibStdCXXIncludePaths(concat(getDriver().SysRoot, "/usr/include/g++"), "", "", 521 DriverArgs, CC1Args); 522 } 523 524 llvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const { 525 // NetBSD uses Dwarf exceptions on ARM. 526 llvm::Triple::ArchType TArch = getTriple().getArch(); 527 if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb || 528 TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb) 529 return llvm::ExceptionHandling::DwarfCFI; 530 return llvm::ExceptionHandling::None; 531 } 532 533 SanitizerMask NetBSD::getSupportedSanitizers() const { 534 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; 535 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; 536 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 537 if (IsX86 || IsX86_64) { 538 Res |= SanitizerKind::Address; 539 Res |= SanitizerKind::PointerCompare; 540 Res |= SanitizerKind::PointerSubtract; 541 Res |= SanitizerKind::Leak; 542 Res |= SanitizerKind::SafeStack; 543 Res |= SanitizerKind::Scudo; 544 Res |= SanitizerKind::Vptr; 545 } 546 if (IsX86_64) { 547 Res |= SanitizerKind::DataFlow; 548 Res |= SanitizerKind::Fuzzer; 549 Res |= SanitizerKind::FuzzerNoLink; 550 Res |= SanitizerKind::HWAddress; 551 Res |= SanitizerKind::KernelAddress; 552 Res |= SanitizerKind::KernelHWAddress; 553 Res |= SanitizerKind::KernelMemory; 554 Res |= SanitizerKind::Memory; 555 Res |= SanitizerKind::Thread; 556 } 557 return Res; 558 } 559 560 void NetBSD::addClangTargetOptions(const ArgList &DriverArgs, 561 ArgStringList &CC1Args, 562 Action::OffloadKind) const { 563 const SanitizerArgs &SanArgs = getSanitizerArgs(DriverArgs); 564 if (SanArgs.hasAnySanitizer()) 565 CC1Args.push_back("-D_REENTRANT"); 566 567 VersionTuple OsVersion = getTriple().getOSVersion(); 568 bool UseInitArrayDefault = 569 OsVersion >= VersionTuple(9) || OsVersion.getMajor() == 0 || 570 getTriple().getArch() == llvm::Triple::aarch64 || 571 getTriple().getArch() == llvm::Triple::aarch64_be || 572 getTriple().getArch() == llvm::Triple::arm || 573 getTriple().getArch() == llvm::Triple::armeb || 574 getTriple().getArch() == llvm::Triple::riscv32 || 575 getTriple().getArch() == llvm::Triple::riscv64; 576 577 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 578 options::OPT_fno_use_init_array, UseInitArrayDefault)) 579 CC1Args.push_back("-fno-use-init-array"); 580 } 581