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/Driver/Compilation.h" 15 #include "clang/Driver/Driver.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 netbsd::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 35 // GNU as needs different flags for creating the correct output format 36 // on architectures with different ABIs or optional feature sets. 37 switch (getToolChain().getArch()) { 38 case llvm::Triple::x86: 39 CmdArgs.push_back("--32"); 40 break; 41 case llvm::Triple::arm: 42 case llvm::Triple::armeb: 43 case llvm::Triple::thumb: 44 case llvm::Triple::thumbeb: { 45 StringRef MArch, MCPU; 46 arm::getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true); 47 std::string Arch = 48 arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple()); 49 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch)); 50 break; 51 } 52 53 case llvm::Triple::mips: 54 case llvm::Triple::mipsel: 55 case llvm::Triple::mips64: 56 case llvm::Triple::mips64el: { 57 StringRef CPUName; 58 StringRef ABIName; 59 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 60 61 CmdArgs.push_back("-march"); 62 CmdArgs.push_back(CPUName.data()); 63 64 CmdArgs.push_back("-mabi"); 65 CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data()); 66 67 if (getToolChain().getTriple().isLittleEndian()) 68 CmdArgs.push_back("-EL"); 69 else 70 CmdArgs.push_back("-EB"); 71 72 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 73 break; 74 } 75 76 case llvm::Triple::sparc: 77 case llvm::Triple::sparcel: { 78 CmdArgs.push_back("-32"); 79 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 80 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 81 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 82 break; 83 } 84 85 case llvm::Triple::sparcv9: { 86 CmdArgs.push_back("-64"); 87 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 88 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 89 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 90 break; 91 } 92 93 default: 94 break; 95 } 96 97 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 98 99 CmdArgs.push_back("-o"); 100 CmdArgs.push_back(Output.getFilename()); 101 102 for (const auto &II : Inputs) 103 CmdArgs.push_back(II.getFilename()); 104 105 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as"))); 106 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 107 } 108 109 void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, 110 const InputInfo &Output, 111 const InputInfoList &Inputs, 112 const ArgList &Args, 113 const char *LinkingOutput) const { 114 const toolchains::NetBSD &ToolChain = 115 static_cast<const toolchains::NetBSD &>(getToolChain()); 116 const Driver &D = ToolChain.getDriver(); 117 ArgStringList CmdArgs; 118 119 if (!D.SysRoot.empty()) 120 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 121 122 CmdArgs.push_back("--eh-frame-hdr"); 123 if (Args.hasArg(options::OPT_static)) { 124 CmdArgs.push_back("-Bstatic"); 125 if (Args.hasArg(options::OPT_pie)) { 126 Args.AddAllArgs(CmdArgs, options::OPT_pie); 127 CmdArgs.push_back("--no-dynamic-linker"); 128 } 129 } else { 130 if (Args.hasArg(options::OPT_rdynamic)) 131 CmdArgs.push_back("-export-dynamic"); 132 if (Args.hasArg(options::OPT_shared)) { 133 CmdArgs.push_back("-Bshareable"); 134 } else { 135 Args.AddAllArgs(CmdArgs, options::OPT_pie); 136 CmdArgs.push_back("-dynamic-linker"); 137 CmdArgs.push_back("/libexec/ld.elf_so"); 138 } 139 } 140 141 // Many NetBSD architectures support more than one ABI. 142 // Determine the correct emulation for ld. 143 switch (ToolChain.getArch()) { 144 case llvm::Triple::x86: 145 CmdArgs.push_back("-m"); 146 CmdArgs.push_back("elf_i386"); 147 break; 148 case llvm::Triple::arm: 149 case llvm::Triple::thumb: 150 CmdArgs.push_back("-m"); 151 switch (ToolChain.getTriple().getEnvironment()) { 152 case llvm::Triple::EABI: 153 case llvm::Triple::GNUEABI: 154 CmdArgs.push_back("armelf_nbsd_eabi"); 155 break; 156 case llvm::Triple::EABIHF: 157 case llvm::Triple::GNUEABIHF: 158 CmdArgs.push_back("armelf_nbsd_eabihf"); 159 break; 160 default: 161 CmdArgs.push_back("armelf_nbsd"); 162 break; 163 } 164 break; 165 case llvm::Triple::armeb: 166 case llvm::Triple::thumbeb: 167 arm::appendBE8LinkFlag(Args, CmdArgs, ToolChain.getEffectiveTriple()); 168 CmdArgs.push_back("-m"); 169 switch (ToolChain.getTriple().getEnvironment()) { 170 case llvm::Triple::EABI: 171 case llvm::Triple::GNUEABI: 172 CmdArgs.push_back("armelfb_nbsd_eabi"); 173 break; 174 case llvm::Triple::EABIHF: 175 case llvm::Triple::GNUEABIHF: 176 CmdArgs.push_back("armelfb_nbsd_eabihf"); 177 break; 178 default: 179 CmdArgs.push_back("armelfb_nbsd"); 180 break; 181 } 182 break; 183 case llvm::Triple::mips64: 184 case llvm::Triple::mips64el: 185 if (mips::hasMipsAbiArg(Args, "32")) { 186 CmdArgs.push_back("-m"); 187 if (ToolChain.getArch() == llvm::Triple::mips64) 188 CmdArgs.push_back("elf32btsmip"); 189 else 190 CmdArgs.push_back("elf32ltsmip"); 191 } else if (mips::hasMipsAbiArg(Args, "64")) { 192 CmdArgs.push_back("-m"); 193 if (ToolChain.getArch() == llvm::Triple::mips64) 194 CmdArgs.push_back("elf64btsmip"); 195 else 196 CmdArgs.push_back("elf64ltsmip"); 197 } 198 break; 199 case llvm::Triple::ppc: 200 CmdArgs.push_back("-m"); 201 CmdArgs.push_back("elf32ppc_nbsd"); 202 break; 203 204 case llvm::Triple::ppc64: 205 case llvm::Triple::ppc64le: 206 CmdArgs.push_back("-m"); 207 CmdArgs.push_back("elf64ppc"); 208 break; 209 210 case llvm::Triple::sparc: 211 CmdArgs.push_back("-m"); 212 CmdArgs.push_back("elf32_sparc"); 213 break; 214 215 case llvm::Triple::sparcv9: 216 CmdArgs.push_back("-m"); 217 CmdArgs.push_back("elf64_sparc"); 218 break; 219 220 default: 221 break; 222 } 223 224 if (Output.isFilename()) { 225 CmdArgs.push_back("-o"); 226 CmdArgs.push_back(Output.getFilename()); 227 } else { 228 assert(Output.isNothing() && "Invalid output."); 229 } 230 231 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 232 if (!Args.hasArg(options::OPT_shared)) { 233 CmdArgs.push_back( 234 Args.MakeArgString(ToolChain.GetFilePath("crt0.o"))); 235 } 236 CmdArgs.push_back( 237 Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 238 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) { 239 CmdArgs.push_back( 240 Args.MakeArgString(ToolChain.GetFilePath("crtbeginS.o"))); 241 } else { 242 CmdArgs.push_back( 243 Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o"))); 244 } 245 } 246 247 Args.AddAllArgs(CmdArgs, options::OPT_L); 248 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 249 Args.AddAllArgs(CmdArgs, options::OPT_e); 250 Args.AddAllArgs(CmdArgs, options::OPT_s); 251 Args.AddAllArgs(CmdArgs, options::OPT_t); 252 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 253 Args.AddAllArgs(CmdArgs, options::OPT_r); 254 255 bool NeedsSanitizerDeps = addSanitizerRuntimes(getToolChain(), Args, CmdArgs); 256 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 257 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 258 259 const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs(); 260 if (SanArgs.needsSharedRt()) { 261 CmdArgs.push_back("-rpath"); 262 CmdArgs.push_back(Args.MakeArgString( 263 ToolChain.getCompilerRTPath().c_str())); 264 } 265 266 unsigned Major, Minor, Micro; 267 ToolChain.getTriple().getOSVersion(Major, Minor, Micro); 268 bool useLibgcc = true; 269 if (Major >= 7 || Major == 0) { 270 switch (ToolChain.getArch()) { 271 case llvm::Triple::aarch64: 272 case llvm::Triple::aarch64_be: 273 case llvm::Triple::arm: 274 case llvm::Triple::armeb: 275 case llvm::Triple::thumb: 276 case llvm::Triple::thumbeb: 277 case llvm::Triple::ppc: 278 case llvm::Triple::ppc64: 279 case llvm::Triple::ppc64le: 280 case llvm::Triple::sparc: 281 case llvm::Triple::sparcv9: 282 case llvm::Triple::x86: 283 case llvm::Triple::x86_64: 284 useLibgcc = false; 285 break; 286 default: 287 break; 288 } 289 } 290 291 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 292 addOpenMPRuntime(CmdArgs, getToolChain(), Args); 293 if (D.CCCIsCXX()) { 294 if (ToolChain.ShouldLinkCXXStdlib(Args)) 295 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 296 CmdArgs.push_back("-lm"); 297 } 298 if (NeedsSanitizerDeps) 299 linkSanitizerRuntimeDeps(getToolChain(), CmdArgs); 300 if (NeedsXRayDeps) 301 linkXRayRuntimeDeps(ToolChain, CmdArgs); 302 if (Args.hasArg(options::OPT_pthread)) 303 CmdArgs.push_back("-lpthread"); 304 CmdArgs.push_back("-lc"); 305 306 if (useLibgcc) { 307 if (Args.hasArg(options::OPT_static)) { 308 // libgcc_eh depends on libc, so resolve as much as possible, 309 // pull in any new requirements from libc and then get the rest 310 // of libgcc. 311 CmdArgs.push_back("-lgcc_eh"); 312 CmdArgs.push_back("-lc"); 313 CmdArgs.push_back("-lgcc"); 314 } else { 315 CmdArgs.push_back("-lgcc"); 316 CmdArgs.push_back("--as-needed"); 317 CmdArgs.push_back("-lgcc_s"); 318 CmdArgs.push_back("--no-as-needed"); 319 } 320 } 321 } 322 323 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 324 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 325 CmdArgs.push_back( 326 Args.MakeArgString(ToolChain.GetFilePath("crtendS.o"))); 327 else 328 CmdArgs.push_back( 329 Args.MakeArgString(ToolChain.GetFilePath("crtend.o"))); 330 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 331 } 332 333 ToolChain.addProfileRTLibs(Args, CmdArgs); 334 335 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 336 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 337 } 338 339 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 340 341 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 342 : Generic_ELF(D, Triple, Args) { 343 if (!Args.hasArg(options::OPT_nostdlib)) { 344 // When targeting a 32-bit platform, try the special directory used on 345 // 64-bit hosts, and only fall back to the main library directory if that 346 // doesn't work. 347 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure 348 // what all logic is needed to emulate the '=' prefix here. 349 switch (Triple.getArch()) { 350 case llvm::Triple::x86: 351 getFilePaths().push_back("=/usr/lib/i386"); 352 break; 353 case llvm::Triple::arm: 354 case llvm::Triple::armeb: 355 case llvm::Triple::thumb: 356 case llvm::Triple::thumbeb: 357 switch (Triple.getEnvironment()) { 358 case llvm::Triple::EABI: 359 case llvm::Triple::GNUEABI: 360 getFilePaths().push_back("=/usr/lib/eabi"); 361 break; 362 case llvm::Triple::EABIHF: 363 case llvm::Triple::GNUEABIHF: 364 getFilePaths().push_back("=/usr/lib/eabihf"); 365 break; 366 default: 367 getFilePaths().push_back("=/usr/lib/oabi"); 368 break; 369 } 370 break; 371 case llvm::Triple::mips64: 372 case llvm::Triple::mips64el: 373 if (tools::mips::hasMipsAbiArg(Args, "o32")) 374 getFilePaths().push_back("=/usr/lib/o32"); 375 else if (tools::mips::hasMipsAbiArg(Args, "64")) 376 getFilePaths().push_back("=/usr/lib/64"); 377 break; 378 case llvm::Triple::ppc: 379 getFilePaths().push_back("=/usr/lib/powerpc"); 380 break; 381 case llvm::Triple::sparc: 382 getFilePaths().push_back("=/usr/lib/sparc"); 383 break; 384 default: 385 break; 386 } 387 388 getFilePaths().push_back("=/usr/lib"); 389 } 390 } 391 392 Tool *NetBSD::buildAssembler() const { 393 return new tools::netbsd::Assembler(*this); 394 } 395 396 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); } 397 398 ToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const { 399 unsigned Major, Minor, Micro; 400 getTriple().getOSVersion(Major, Minor, Micro); 401 if (Major >= 7 || Major == 0) { 402 switch (getArch()) { 403 case llvm::Triple::aarch64: 404 case llvm::Triple::aarch64_be: 405 case llvm::Triple::arm: 406 case llvm::Triple::armeb: 407 case llvm::Triple::thumb: 408 case llvm::Triple::thumbeb: 409 case llvm::Triple::ppc: 410 case llvm::Triple::ppc64: 411 case llvm::Triple::ppc64le: 412 case llvm::Triple::sparc: 413 case llvm::Triple::sparcv9: 414 case llvm::Triple::x86: 415 case llvm::Triple::x86_64: 416 return ToolChain::CST_Libcxx; 417 default: 418 break; 419 } 420 } 421 return ToolChain::CST_Libstdcxx; 422 } 423 424 void NetBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 425 llvm::opt::ArgStringList &CC1Args) const { 426 const std::string Candidates[] = { 427 // directory relative to build tree 428 getDriver().Dir + "/../include/c++/v1", 429 // system install with full upstream path 430 getDriver().SysRoot + "/usr/include/c++/v1", 431 // system install from src 432 getDriver().SysRoot + "/usr/include/c++", 433 }; 434 435 for (const auto &IncludePath : Candidates) { 436 if (!getVFS().exists(IncludePath + "/__config")) 437 continue; 438 439 // Use the first candidate that looks valid. 440 addSystemInclude(DriverArgs, CC1Args, IncludePath); 441 return; 442 } 443 } 444 445 void NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 446 llvm::opt::ArgStringList &CC1Args) const { 447 addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/g++", "", "", "", 448 "", DriverArgs, CC1Args); 449 } 450 451 llvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const { 452 // NetBSD uses Dwarf exceptions on ARM. 453 llvm::Triple::ArchType TArch = getTriple().getArch(); 454 if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb || 455 TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb) 456 return llvm::ExceptionHandling::DwarfCFI; 457 return llvm::ExceptionHandling::None; 458 } 459 460 SanitizerMask NetBSD::getSupportedSanitizers() const { 461 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; 462 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; 463 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 464 if (IsX86 || IsX86_64) { 465 Res |= SanitizerKind::Address; 466 Res |= SanitizerKind::PointerCompare; 467 Res |= SanitizerKind::PointerSubtract; 468 Res |= SanitizerKind::Function; 469 Res |= SanitizerKind::Leak; 470 Res |= SanitizerKind::SafeStack; 471 Res |= SanitizerKind::Scudo; 472 Res |= SanitizerKind::Vptr; 473 } 474 if (IsX86_64) { 475 Res |= SanitizerKind::DataFlow; 476 Res |= SanitizerKind::Fuzzer; 477 Res |= SanitizerKind::FuzzerNoLink; 478 Res |= SanitizerKind::HWAddress; 479 Res |= SanitizerKind::KernelAddress; 480 Res |= SanitizerKind::KernelHWAddress; 481 Res |= SanitizerKind::KernelMemory; 482 Res |= SanitizerKind::Memory; 483 Res |= SanitizerKind::Thread; 484 } 485 return Res; 486 } 487 488 void NetBSD::addClangTargetOptions(const ArgList &, 489 ArgStringList &CC1Args, 490 Action::OffloadKind) const { 491 const SanitizerArgs &SanArgs = getSanitizerArgs(); 492 if (SanArgs.hasAnySanitizer()) 493 CC1Args.push_back("-D_REENTRANT"); 494 } 495