1317019Sdim//===--- NetBSD.cpp - NetBSD ToolChain Implementations ----------*- C++ -*-===// 2317019Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6317019Sdim// 7317019Sdim//===----------------------------------------------------------------------===// 8317019Sdim 9317019Sdim#include "NetBSD.h" 10317019Sdim#include "Arch/ARM.h" 11317019Sdim#include "Arch/Mips.h" 12317019Sdim#include "Arch/Sparc.h" 13317019Sdim#include "CommonArgs.h" 14317019Sdim#include "clang/Driver/Compilation.h" 15317019Sdim#include "clang/Driver/Driver.h" 16317019Sdim#include "clang/Driver/Options.h" 17320970Sdim#include "clang/Driver/SanitizerArgs.h" 18317019Sdim#include "llvm/Option/ArgList.h" 19353358Sdim#include "llvm/Support/VirtualFileSystem.h" 20317019Sdim 21317019Sdimusing namespace clang::driver; 22317019Sdimusing namespace clang::driver::tools; 23317019Sdimusing namespace clang::driver::toolchains; 24317019Sdimusing namespace clang; 25317019Sdimusing namespace llvm::opt; 26317019Sdim 27317019Sdimvoid netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 28317019Sdim const InputInfo &Output, 29317019Sdim const InputInfoList &Inputs, 30317019Sdim const ArgList &Args, 31317019Sdim const char *LinkingOutput) const { 32317019Sdim claimNoWarnArgs(Args); 33317019Sdim ArgStringList CmdArgs; 34317019Sdim 35317019Sdim // GNU as needs different flags for creating the correct output format 36317019Sdim // on architectures with different ABIs or optional feature sets. 37317019Sdim switch (getToolChain().getArch()) { 38317019Sdim case llvm::Triple::x86: 39317019Sdim CmdArgs.push_back("--32"); 40317019Sdim break; 41317019Sdim case llvm::Triple::arm: 42317019Sdim case llvm::Triple::armeb: 43317019Sdim case llvm::Triple::thumb: 44317019Sdim case llvm::Triple::thumbeb: { 45317019Sdim StringRef MArch, MCPU; 46317019Sdim arm::getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true); 47317019Sdim std::string Arch = 48317019Sdim arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple()); 49317019Sdim CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch)); 50317019Sdim break; 51317019Sdim } 52317019Sdim 53317019Sdim case llvm::Triple::mips: 54317019Sdim case llvm::Triple::mipsel: 55317019Sdim case llvm::Triple::mips64: 56317019Sdim case llvm::Triple::mips64el: { 57317019Sdim StringRef CPUName; 58317019Sdim StringRef ABIName; 59317019Sdim mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 60317019Sdim 61317019Sdim CmdArgs.push_back("-march"); 62317019Sdim CmdArgs.push_back(CPUName.data()); 63317019Sdim 64317019Sdim CmdArgs.push_back("-mabi"); 65317019Sdim CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data()); 66317019Sdim 67341825Sdim if (getToolChain().getTriple().isLittleEndian()) 68341825Sdim CmdArgs.push_back("-EL"); 69341825Sdim else 70317019Sdim CmdArgs.push_back("-EB"); 71317019Sdim 72317019Sdim AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 73317019Sdim break; 74317019Sdim } 75317019Sdim 76317019Sdim case llvm::Triple::sparc: 77317019Sdim case llvm::Triple::sparcel: { 78317019Sdim CmdArgs.push_back("-32"); 79317019Sdim std::string CPU = getCPUName(Args, getToolChain().getTriple()); 80317019Sdim CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 81317019Sdim AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 82317019Sdim break; 83317019Sdim } 84317019Sdim 85317019Sdim case llvm::Triple::sparcv9: { 86317019Sdim CmdArgs.push_back("-64"); 87317019Sdim std::string CPU = getCPUName(Args, getToolChain().getTriple()); 88317019Sdim CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 89317019Sdim AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 90317019Sdim break; 91317019Sdim } 92317019Sdim 93317019Sdim default: 94317019Sdim break; 95317019Sdim } 96317019Sdim 97317019Sdim Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 98317019Sdim 99317019Sdim CmdArgs.push_back("-o"); 100317019Sdim CmdArgs.push_back(Output.getFilename()); 101317019Sdim 102317019Sdim for (const auto &II : Inputs) 103317019Sdim CmdArgs.push_back(II.getFilename()); 104317019Sdim 105317019Sdim const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as"))); 106360784Sdim C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 107317019Sdim} 108317019Sdim 109317019Sdimvoid netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, 110317019Sdim const InputInfo &Output, 111317019Sdim const InputInfoList &Inputs, 112317019Sdim const ArgList &Args, 113317019Sdim const char *LinkingOutput) const { 114341825Sdim const toolchains::NetBSD &ToolChain = 115341825Sdim static_cast<const toolchains::NetBSD &>(getToolChain()); 116341825Sdim const Driver &D = ToolChain.getDriver(); 117317019Sdim ArgStringList CmdArgs; 118317019Sdim 119317019Sdim if (!D.SysRoot.empty()) 120317019Sdim CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 121317019Sdim 122317019Sdim CmdArgs.push_back("--eh-frame-hdr"); 123317019Sdim if (Args.hasArg(options::OPT_static)) { 124317019Sdim CmdArgs.push_back("-Bstatic"); 125341825Sdim if (Args.hasArg(options::OPT_pie)) { 126341825Sdim Args.AddAllArgs(CmdArgs, options::OPT_pie); 127341825Sdim CmdArgs.push_back("--no-dynamic-linker"); 128341825Sdim } 129317019Sdim } else { 130317019Sdim if (Args.hasArg(options::OPT_rdynamic)) 131317019Sdim CmdArgs.push_back("-export-dynamic"); 132317019Sdim if (Args.hasArg(options::OPT_shared)) { 133317019Sdim CmdArgs.push_back("-Bshareable"); 134317019Sdim } else { 135317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_pie); 136317019Sdim CmdArgs.push_back("-dynamic-linker"); 137317019Sdim CmdArgs.push_back("/libexec/ld.elf_so"); 138317019Sdim } 139317019Sdim } 140317019Sdim 141317019Sdim // Many NetBSD architectures support more than one ABI. 142317019Sdim // Determine the correct emulation for ld. 143341825Sdim switch (ToolChain.getArch()) { 144317019Sdim case llvm::Triple::x86: 145317019Sdim CmdArgs.push_back("-m"); 146317019Sdim CmdArgs.push_back("elf_i386"); 147317019Sdim break; 148317019Sdim case llvm::Triple::arm: 149317019Sdim case llvm::Triple::thumb: 150317019Sdim CmdArgs.push_back("-m"); 151341825Sdim switch (ToolChain.getTriple().getEnvironment()) { 152317019Sdim case llvm::Triple::EABI: 153317019Sdim case llvm::Triple::GNUEABI: 154317019Sdim CmdArgs.push_back("armelf_nbsd_eabi"); 155317019Sdim break; 156317019Sdim case llvm::Triple::EABIHF: 157317019Sdim case llvm::Triple::GNUEABIHF: 158317019Sdim CmdArgs.push_back("armelf_nbsd_eabihf"); 159317019Sdim break; 160317019Sdim default: 161317019Sdim CmdArgs.push_back("armelf_nbsd"); 162317019Sdim break; 163317019Sdim } 164317019Sdim break; 165317019Sdim case llvm::Triple::armeb: 166317019Sdim case llvm::Triple::thumbeb: 167344779Sdim arm::appendBE8LinkFlag(Args, CmdArgs, ToolChain.getEffectiveTriple()); 168317019Sdim CmdArgs.push_back("-m"); 169341825Sdim switch (ToolChain.getTriple().getEnvironment()) { 170317019Sdim case llvm::Triple::EABI: 171317019Sdim case llvm::Triple::GNUEABI: 172317019Sdim CmdArgs.push_back("armelfb_nbsd_eabi"); 173317019Sdim break; 174317019Sdim case llvm::Triple::EABIHF: 175317019Sdim case llvm::Triple::GNUEABIHF: 176317019Sdim CmdArgs.push_back("armelfb_nbsd_eabihf"); 177317019Sdim break; 178317019Sdim default: 179317019Sdim CmdArgs.push_back("armelfb_nbsd"); 180317019Sdim break; 181317019Sdim } 182317019Sdim break; 183317019Sdim case llvm::Triple::mips64: 184317019Sdim case llvm::Triple::mips64el: 185317019Sdim if (mips::hasMipsAbiArg(Args, "32")) { 186317019Sdim CmdArgs.push_back("-m"); 187341825Sdim if (ToolChain.getArch() == llvm::Triple::mips64) 188317019Sdim CmdArgs.push_back("elf32btsmip"); 189317019Sdim else 190317019Sdim CmdArgs.push_back("elf32ltsmip"); 191317019Sdim } else if (mips::hasMipsAbiArg(Args, "64")) { 192317019Sdim CmdArgs.push_back("-m"); 193341825Sdim if (ToolChain.getArch() == llvm::Triple::mips64) 194317019Sdim CmdArgs.push_back("elf64btsmip"); 195317019Sdim else 196317019Sdim CmdArgs.push_back("elf64ltsmip"); 197317019Sdim } 198317019Sdim break; 199317019Sdim case llvm::Triple::ppc: 200317019Sdim CmdArgs.push_back("-m"); 201317019Sdim CmdArgs.push_back("elf32ppc_nbsd"); 202317019Sdim break; 203317019Sdim 204317019Sdim case llvm::Triple::ppc64: 205317019Sdim case llvm::Triple::ppc64le: 206317019Sdim CmdArgs.push_back("-m"); 207317019Sdim CmdArgs.push_back("elf64ppc"); 208317019Sdim break; 209317019Sdim 210317019Sdim case llvm::Triple::sparc: 211317019Sdim CmdArgs.push_back("-m"); 212317019Sdim CmdArgs.push_back("elf32_sparc"); 213317019Sdim break; 214317019Sdim 215317019Sdim case llvm::Triple::sparcv9: 216317019Sdim CmdArgs.push_back("-m"); 217317019Sdim CmdArgs.push_back("elf64_sparc"); 218317019Sdim break; 219317019Sdim 220317019Sdim default: 221317019Sdim break; 222317019Sdim } 223317019Sdim 224317019Sdim if (Output.isFilename()) { 225317019Sdim CmdArgs.push_back("-o"); 226317019Sdim CmdArgs.push_back(Output.getFilename()); 227317019Sdim } else { 228317019Sdim assert(Output.isNothing() && "Invalid output."); 229317019Sdim } 230317019Sdim 231317019Sdim if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 232317019Sdim if (!Args.hasArg(options::OPT_shared)) { 233317019Sdim CmdArgs.push_back( 234341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crt0.o"))); 235317019Sdim } 236317019Sdim CmdArgs.push_back( 237341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 238317019Sdim if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) { 239317019Sdim CmdArgs.push_back( 240341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crtbeginS.o"))); 241317019Sdim } else { 242317019Sdim CmdArgs.push_back( 243341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o"))); 244317019Sdim } 245317019Sdim } 246317019Sdim 247317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_L); 248317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 249317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_e); 250317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_s); 251317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_t); 252317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 253317019Sdim Args.AddAllArgs(CmdArgs, options::OPT_r); 254317019Sdim 255320970Sdim bool NeedsSanitizerDeps = addSanitizerRuntimes(getToolChain(), Args, CmdArgs); 256341825Sdim bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 257317019Sdim AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 258317019Sdim 259344779Sdim const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs(); 260344779Sdim if (SanArgs.needsSharedRt()) { 261344779Sdim CmdArgs.push_back("-rpath"); 262344779Sdim CmdArgs.push_back(Args.MakeArgString( 263344779Sdim ToolChain.getCompilerRTPath().c_str())); 264344779Sdim } 265344779Sdim 266317019Sdim unsigned Major, Minor, Micro; 267341825Sdim ToolChain.getTriple().getOSVersion(Major, Minor, Micro); 268317019Sdim bool useLibgcc = true; 269317019Sdim if (Major >= 7 || Major == 0) { 270341825Sdim switch (ToolChain.getArch()) { 271317019Sdim case llvm::Triple::aarch64: 272317019Sdim case llvm::Triple::aarch64_be: 273317019Sdim case llvm::Triple::arm: 274317019Sdim case llvm::Triple::armeb: 275317019Sdim case llvm::Triple::thumb: 276317019Sdim case llvm::Triple::thumbeb: 277317019Sdim case llvm::Triple::ppc: 278317019Sdim case llvm::Triple::ppc64: 279317019Sdim case llvm::Triple::ppc64le: 280317019Sdim case llvm::Triple::sparc: 281317019Sdim case llvm::Triple::sparcv9: 282317019Sdim case llvm::Triple::x86: 283317019Sdim case llvm::Triple::x86_64: 284317019Sdim useLibgcc = false; 285317019Sdim break; 286317019Sdim default: 287317019Sdim break; 288317019Sdim } 289317019Sdim } 290317019Sdim 291317019Sdim if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 292360784Sdim // Use the static OpenMP runtime with -static-openmp 293360784Sdim bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && 294360784Sdim !Args.hasArg(options::OPT_static); 295360784Sdim addOpenMPRuntime(CmdArgs, getToolChain(), Args, StaticOpenMP); 296360784Sdim 297317019Sdim if (D.CCCIsCXX()) { 298341825Sdim if (ToolChain.ShouldLinkCXXStdlib(Args)) 299341825Sdim ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 300317019Sdim CmdArgs.push_back("-lm"); 301317019Sdim } 302320970Sdim if (NeedsSanitizerDeps) 303320970Sdim linkSanitizerRuntimeDeps(getToolChain(), CmdArgs); 304341825Sdim if (NeedsXRayDeps) 305341825Sdim linkXRayRuntimeDeps(ToolChain, CmdArgs); 306317019Sdim if (Args.hasArg(options::OPT_pthread)) 307317019Sdim CmdArgs.push_back("-lpthread"); 308317019Sdim CmdArgs.push_back("-lc"); 309317019Sdim 310317019Sdim if (useLibgcc) { 311317019Sdim if (Args.hasArg(options::OPT_static)) { 312317019Sdim // libgcc_eh depends on libc, so resolve as much as possible, 313317019Sdim // pull in any new requirements from libc and then get the rest 314317019Sdim // of libgcc. 315317019Sdim CmdArgs.push_back("-lgcc_eh"); 316317019Sdim CmdArgs.push_back("-lc"); 317317019Sdim CmdArgs.push_back("-lgcc"); 318317019Sdim } else { 319317019Sdim CmdArgs.push_back("-lgcc"); 320317019Sdim CmdArgs.push_back("--as-needed"); 321317019Sdim CmdArgs.push_back("-lgcc_s"); 322317019Sdim CmdArgs.push_back("--no-as-needed"); 323317019Sdim } 324317019Sdim } 325317019Sdim } 326317019Sdim 327317019Sdim if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 328317019Sdim if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 329317019Sdim CmdArgs.push_back( 330341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crtendS.o"))); 331317019Sdim else 332317019Sdim CmdArgs.push_back( 333341825Sdim Args.MakeArgString(ToolChain.GetFilePath("crtend.o"))); 334341825Sdim CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 335317019Sdim } 336317019Sdim 337341825Sdim ToolChain.addProfileRTLibs(Args, CmdArgs); 338317019Sdim 339341825Sdim const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 340360784Sdim C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 341317019Sdim} 342317019Sdim 343317019Sdim/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 344317019Sdim 345317019SdimNetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 346317019Sdim : Generic_ELF(D, Triple, Args) { 347327952Sdim if (!Args.hasArg(options::OPT_nostdlib)) { 348317019Sdim // When targeting a 32-bit platform, try the special directory used on 349317019Sdim // 64-bit hosts, and only fall back to the main library directory if that 350317019Sdim // doesn't work. 351317019Sdim // FIXME: It'd be nicer to test if this directory exists, but I'm not sure 352317019Sdim // what all logic is needed to emulate the '=' prefix here. 353317019Sdim switch (Triple.getArch()) { 354317019Sdim case llvm::Triple::x86: 355317019Sdim getFilePaths().push_back("=/usr/lib/i386"); 356317019Sdim break; 357317019Sdim case llvm::Triple::arm: 358317019Sdim case llvm::Triple::armeb: 359317019Sdim case llvm::Triple::thumb: 360317019Sdim case llvm::Triple::thumbeb: 361317019Sdim switch (Triple.getEnvironment()) { 362317019Sdim case llvm::Triple::EABI: 363317019Sdim case llvm::Triple::GNUEABI: 364317019Sdim getFilePaths().push_back("=/usr/lib/eabi"); 365317019Sdim break; 366317019Sdim case llvm::Triple::EABIHF: 367317019Sdim case llvm::Triple::GNUEABIHF: 368317019Sdim getFilePaths().push_back("=/usr/lib/eabihf"); 369317019Sdim break; 370317019Sdim default: 371317019Sdim getFilePaths().push_back("=/usr/lib/oabi"); 372317019Sdim break; 373317019Sdim } 374317019Sdim break; 375317019Sdim case llvm::Triple::mips64: 376317019Sdim case llvm::Triple::mips64el: 377317019Sdim if (tools::mips::hasMipsAbiArg(Args, "o32")) 378317019Sdim getFilePaths().push_back("=/usr/lib/o32"); 379317019Sdim else if (tools::mips::hasMipsAbiArg(Args, "64")) 380317019Sdim getFilePaths().push_back("=/usr/lib/64"); 381317019Sdim break; 382317019Sdim case llvm::Triple::ppc: 383317019Sdim getFilePaths().push_back("=/usr/lib/powerpc"); 384317019Sdim break; 385317019Sdim case llvm::Triple::sparc: 386317019Sdim getFilePaths().push_back("=/usr/lib/sparc"); 387317019Sdim break; 388317019Sdim default: 389317019Sdim break; 390317019Sdim } 391317019Sdim 392317019Sdim getFilePaths().push_back("=/usr/lib"); 393317019Sdim } 394317019Sdim} 395317019Sdim 396317019SdimTool *NetBSD::buildAssembler() const { 397317019Sdim return new tools::netbsd::Assembler(*this); 398317019Sdim} 399317019Sdim 400317019SdimTool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); } 401317019Sdim 402317019SdimToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const { 403317019Sdim unsigned Major, Minor, Micro; 404317019Sdim getTriple().getOSVersion(Major, Minor, Micro); 405317019Sdim if (Major >= 7 || Major == 0) { 406317019Sdim switch (getArch()) { 407317019Sdim case llvm::Triple::aarch64: 408317019Sdim case llvm::Triple::aarch64_be: 409317019Sdim case llvm::Triple::arm: 410317019Sdim case llvm::Triple::armeb: 411317019Sdim case llvm::Triple::thumb: 412317019Sdim case llvm::Triple::thumbeb: 413317019Sdim case llvm::Triple::ppc: 414317019Sdim case llvm::Triple::ppc64: 415317019Sdim case llvm::Triple::ppc64le: 416317019Sdim case llvm::Triple::sparc: 417317019Sdim case llvm::Triple::sparcv9: 418317019Sdim case llvm::Triple::x86: 419317019Sdim case llvm::Triple::x86_64: 420317019Sdim return ToolChain::CST_Libcxx; 421317019Sdim default: 422317019Sdim break; 423317019Sdim } 424317019Sdim } 425317019Sdim return ToolChain::CST_Libstdcxx; 426317019Sdim} 427317019Sdim 428341825Sdimvoid NetBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 429341825Sdim llvm::opt::ArgStringList &CC1Args) const { 430353358Sdim const std::string Candidates[] = { 431353358Sdim // directory relative to build tree 432353358Sdim getDriver().Dir + "/../include/c++/v1", 433353358Sdim // system install with full upstream path 434353358Sdim getDriver().SysRoot + "/usr/include/c++/v1", 435353358Sdim // system install from src 436353358Sdim getDriver().SysRoot + "/usr/include/c++", 437353358Sdim }; 438353358Sdim 439353358Sdim for (const auto &IncludePath : Candidates) { 440353358Sdim if (!getVFS().exists(IncludePath + "/__config")) 441353358Sdim continue; 442353358Sdim 443353358Sdim // Use the first candidate that looks valid. 444353358Sdim addSystemInclude(DriverArgs, CC1Args, IncludePath); 445353358Sdim return; 446353358Sdim } 447317019Sdim} 448317019Sdim 449317019Sdimvoid NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 450317019Sdim llvm::opt::ArgStringList &CC1Args) const { 451317019Sdim addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/g++", "", "", "", 452317019Sdim "", DriverArgs, CC1Args); 453317019Sdim} 454320970Sdim 455327952Sdimllvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const { 456327952Sdim // NetBSD uses Dwarf exceptions on ARM. 457327952Sdim llvm::Triple::ArchType TArch = getTriple().getArch(); 458327952Sdim if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb || 459327952Sdim TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb) 460327952Sdim return llvm::ExceptionHandling::DwarfCFI; 461327952Sdim return llvm::ExceptionHandling::None; 462327952Sdim} 463327952Sdim 464320970SdimSanitizerMask NetBSD::getSupportedSanitizers() const { 465327952Sdim const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; 466320970Sdim const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; 467320970Sdim SanitizerMask Res = ToolChain::getSupportedSanitizers(); 468327952Sdim if (IsX86 || IsX86_64) { 469320970Sdim Res |= SanitizerKind::Address; 470353358Sdim Res |= SanitizerKind::PointerCompare; 471353358Sdim Res |= SanitizerKind::PointerSubtract; 472327952Sdim Res |= SanitizerKind::Function; 473327952Sdim Res |= SanitizerKind::Leak; 474327952Sdim Res |= SanitizerKind::SafeStack; 475327952Sdim Res |= SanitizerKind::Scudo; 476327952Sdim Res |= SanitizerKind::Vptr; 477320970Sdim } 478327952Sdim if (IsX86_64) { 479344779Sdim Res |= SanitizerKind::DataFlow; 480327952Sdim Res |= SanitizerKind::Fuzzer; 481327952Sdim Res |= SanitizerKind::FuzzerNoLink; 482344779Sdim Res |= SanitizerKind::HWAddress; 483327952Sdim Res |= SanitizerKind::KernelAddress; 484344779Sdim Res |= SanitizerKind::KernelHWAddress; 485344779Sdim Res |= SanitizerKind::KernelMemory; 486327952Sdim Res |= SanitizerKind::Memory; 487327952Sdim Res |= SanitizerKind::Thread; 488327952Sdim } 489320970Sdim return Res; 490320970Sdim} 491344779Sdim 492360784Sdimvoid NetBSD::addClangTargetOptions(const ArgList &DriverArgs, 493344779Sdim ArgStringList &CC1Args, 494344779Sdim Action::OffloadKind) const { 495344779Sdim const SanitizerArgs &SanArgs = getSanitizerArgs(); 496344779Sdim if (SanArgs.hasAnySanitizer()) 497344779Sdim CC1Args.push_back("-D_REENTRANT"); 498360784Sdim 499360784Sdim unsigned Major, Minor, Micro; 500360784Sdim getTriple().getOSVersion(Major, Minor, Micro); 501360784Sdim bool UseInitArrayDefault = 502360784Sdim Major >= 9 || Major == 0 || 503360784Sdim getTriple().getArch() == llvm::Triple::aarch64 || 504360784Sdim getTriple().getArch() == llvm::Triple::aarch64_be || 505360784Sdim getTriple().getArch() == llvm::Triple::arm || 506360784Sdim getTriple().getArch() == llvm::Triple::armeb; 507360784Sdim 508360784Sdim if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 509360784Sdim options::OPT_fno_use_init_array, UseInitArrayDefault)) 510360784Sdim CC1Args.push_back("-fno-use-init-array"); 511344779Sdim} 512