1 //===--- OpenBSD.cpp - OpenBSD 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 "OpenBSD.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/Options.h" 17 #include "clang/Driver/SanitizerArgs.h" 18 #include "llvm/Option/ArgList.h" 19 #include "llvm/Support/Path.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 openbsd::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 OpenBSD &>(getToolChain()); 34 const Driver &D = ToolChain.getDriver(); 35 const llvm::Triple &Triple = ToolChain.getTriple(); 36 ArgStringList CmdArgs; 37 38 claimNoWarnArgs(Args); 39 40 switch (ToolChain.getArch()) { 41 case llvm::Triple::x86: 42 // When building 32-bit code on OpenBSD/amd64, we have to explicitly 43 // instruct as in the base system to assemble 32-bit code. 44 CmdArgs.push_back("--32"); 45 break; 46 47 case llvm::Triple::arm: { 48 StringRef MArch, MCPU; 49 arm::getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true); 50 std::string Arch = arm::getARMTargetCPU(MCPU, MArch, Triple); 51 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch)); 52 break; 53 } 54 55 case llvm::Triple::ppc: 56 CmdArgs.push_back("-mppc"); 57 CmdArgs.push_back("-many"); 58 break; 59 60 case llvm::Triple::sparcv9: { 61 CmdArgs.push_back("-64"); 62 std::string CPU = getCPUName(D, Args, Triple); 63 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, Triple)); 64 AddAssemblerKPIC(ToolChain, Args, CmdArgs); 65 break; 66 } 67 68 case llvm::Triple::mips64: 69 case llvm::Triple::mips64el: { 70 StringRef CPUName; 71 StringRef ABIName; 72 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 73 74 CmdArgs.push_back("-march"); 75 CmdArgs.push_back(CPUName.data()); 76 77 CmdArgs.push_back("-mabi"); 78 CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data()); 79 80 if (Triple.isLittleEndian()) 81 CmdArgs.push_back("-EL"); 82 else 83 CmdArgs.push_back("-EB"); 84 85 AddAssemblerKPIC(ToolChain, Args, CmdArgs); 86 break; 87 } 88 89 default: 90 break; 91 } 92 93 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 94 95 CmdArgs.push_back("-o"); 96 CmdArgs.push_back(Output.getFilename()); 97 98 for (const auto &II : Inputs) 99 CmdArgs.push_back(II.getFilename()); 100 101 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("as")); 102 C.addCommand(std::make_unique<Command>(JA, *this, 103 ResponseFileSupport::AtFileCurCP(), 104 Exec, CmdArgs, Inputs, Output)); 105 } 106 107 void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, 108 const InputInfo &Output, 109 const InputInfoList &Inputs, 110 const ArgList &Args, 111 const char *LinkingOutput) const { 112 const auto &ToolChain = static_cast<const OpenBSD &>(getToolChain()); 113 const Driver &D = ToolChain.getDriver(); 114 const llvm::Triple &Triple = ToolChain.getTriple(); 115 const llvm::Triple::ArchType Arch = ToolChain.getArch(); 116 const bool Static = Args.hasArg(options::OPT_static); 117 const bool Shared = Args.hasArg(options::OPT_shared); 118 const bool Profiling = Args.hasArg(options::OPT_pg); 119 const bool Pie = Args.hasArg(options::OPT_pie); 120 const bool Nopie = Args.hasArg(options::OPT_no_pie, options::OPT_nopie); 121 const bool Relocatable = Args.hasArg(options::OPT_r); 122 ArgStringList CmdArgs; 123 124 // Silence warning for "clang -g foo.o -o foo" 125 Args.ClaimAllArgs(options::OPT_g_Group); 126 // and "clang -emit-llvm foo.o -o foo" 127 Args.ClaimAllArgs(options::OPT_emit_llvm); 128 // and for "clang -w foo.o -o foo". Other warning options are already 129 // handled somewhere else. 130 Args.ClaimAllArgs(options::OPT_w); 131 132 if (!D.SysRoot.empty()) 133 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 134 135 if (Arch == llvm::Triple::mips64) 136 CmdArgs.push_back("-EB"); 137 else if (Arch == llvm::Triple::mips64el) 138 CmdArgs.push_back("-EL"); 139 140 if (!Args.hasArg(options::OPT_nostdlib) && !Shared && !Relocatable) { 141 CmdArgs.push_back("-e"); 142 CmdArgs.push_back("__start"); 143 } 144 145 CmdArgs.push_back("--eh-frame-hdr"); 146 if (Static) { 147 CmdArgs.push_back("-Bstatic"); 148 } else { 149 if (Args.hasArg(options::OPT_rdynamic)) 150 CmdArgs.push_back("-export-dynamic"); 151 if (Shared) { 152 CmdArgs.push_back("-shared"); 153 } else if (!Relocatable) { 154 CmdArgs.push_back("-dynamic-linker"); 155 CmdArgs.push_back("/usr/libexec/ld.so"); 156 } 157 } 158 159 if (Pie) 160 CmdArgs.push_back("-pie"); 161 if (Nopie || Profiling) 162 CmdArgs.push_back("-nopie"); 163 164 if (Triple.isRISCV64()) { 165 CmdArgs.push_back("-X"); 166 if (Args.hasArg(options::OPT_mno_relax)) 167 CmdArgs.push_back("--no-relax"); 168 } 169 170 assert((Output.isFilename() || Output.isNothing()) && "Invalid output."); 171 if (Output.isFilename()) { 172 CmdArgs.push_back("-o"); 173 CmdArgs.push_back(Output.getFilename()); 174 } 175 176 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, 177 options::OPT_r)) { 178 const char *crt0 = nullptr; 179 const char *crtbegin = nullptr; 180 if (!Shared) { 181 if (Profiling) 182 crt0 = "gcrt0.o"; 183 else if (Static && !Nopie) 184 crt0 = "rcrt0.o"; 185 else 186 crt0 = "crt0.o"; 187 crtbegin = "crtbegin.o"; 188 } else { 189 crtbegin = "crtbeginS.o"; 190 } 191 192 if (crt0) 193 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt0))); 194 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 195 } 196 197 Args.AddAllArgs(CmdArgs, options::OPT_L); 198 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 199 Args.addAllArgs(CmdArgs, 200 {options::OPT_T_Group, options::OPT_s, options::OPT_t}); 201 202 if (D.isUsingLTO()) { 203 assert(!Inputs.empty() && "Must have at least one input."); 204 // Find the first filename InputInfo object. 205 auto Input = llvm::find_if( 206 Inputs, [](const InputInfo &II) -> bool { return II.isFilename(); }); 207 if (Input == Inputs.end()) 208 // For a very rare case, all of the inputs to the linker are 209 // InputArg. If that happens, just use the first InputInfo. 210 Input = Inputs.begin(); 211 212 addLTOOptions(ToolChain, Args, CmdArgs, Output, *Input, 213 D.getLTOMode() == LTOK_Thin); 214 } 215 216 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); 217 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 218 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 219 220 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, 221 options::OPT_r)) { 222 // Use the static OpenMP runtime with -static-openmp 223 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && !Static; 224 addOpenMPRuntime(C, CmdArgs, ToolChain, Args, StaticOpenMP); 225 226 if (D.CCCIsCXX()) { 227 if (ToolChain.ShouldLinkCXXStdlib(Args)) 228 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 229 if (Profiling) 230 CmdArgs.push_back("-lm_p"); 231 else 232 CmdArgs.push_back("-lm"); 233 } 234 235 // Silence warnings when linking C code with a C++ '-stdlib' argument. 236 Args.ClaimAllArgs(options::OPT_stdlib_EQ); 237 238 // Additional linker set-up and flags for Fortran. This is required in order 239 // to generate executables. As Fortran runtime depends on the C runtime, 240 // these dependencies need to be listed before the C runtime below (i.e. 241 // AddRunTimeLibs). 242 if (D.IsFlangMode() && 243 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 244 addFortranRuntimeLibraryPath(ToolChain, Args, CmdArgs); 245 addFortranRuntimeLibs(ToolChain, Args, CmdArgs); 246 if (Profiling) 247 CmdArgs.push_back("-lm_p"); 248 else 249 CmdArgs.push_back("-lm"); 250 } 251 252 if (NeedsSanitizerDeps) { 253 CmdArgs.push_back(ToolChain.getCompilerRTArgString(Args, "builtins")); 254 linkSanitizerRuntimeDeps(ToolChain, Args, CmdArgs); 255 } 256 if (NeedsXRayDeps) { 257 CmdArgs.push_back(ToolChain.getCompilerRTArgString(Args, "builtins")); 258 linkXRayRuntimeDeps(ToolChain, Args, CmdArgs); 259 } 260 // FIXME: For some reason GCC passes -lgcc before adding 261 // the default system libraries. Just mimic this for now. 262 CmdArgs.push_back("-lcompiler_rt"); 263 264 if (Args.hasArg(options::OPT_pthread)) { 265 if (!Shared && Profiling) 266 CmdArgs.push_back("-lpthread_p"); 267 else 268 CmdArgs.push_back("-lpthread"); 269 } 270 271 if (!Shared) { 272 if (Profiling) 273 CmdArgs.push_back("-lc_p"); 274 else 275 CmdArgs.push_back("-lc"); 276 } 277 278 CmdArgs.push_back("-lcompiler_rt"); 279 } 280 281 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, 282 options::OPT_r)) { 283 const char *crtend = nullptr; 284 if (!Shared) 285 crtend = "crtend.o"; 286 else 287 crtend = "crtendS.o"; 288 289 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 290 } 291 292 ToolChain.addProfileRTLibs(Args, CmdArgs); 293 294 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 295 C.addCommand(std::make_unique<Command>(JA, *this, 296 ResponseFileSupport::AtFileCurCP(), 297 Exec, CmdArgs, Inputs, Output)); 298 } 299 300 SanitizerMask OpenBSD::getSupportedSanitizers() const { 301 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; 302 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; 303 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 304 if (IsX86 || IsX86_64) { 305 Res |= SanitizerKind::Vptr; 306 Res |= SanitizerKind::Fuzzer; 307 Res |= SanitizerKind::FuzzerNoLink; 308 } 309 if (IsX86_64) { 310 Res |= SanitizerKind::KernelAddress; 311 } 312 return Res; 313 } 314 315 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. 316 317 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple, 318 const ArgList &Args) 319 : Generic_ELF(D, Triple, Args) { 320 getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib")); 321 } 322 323 void OpenBSD::AddClangSystemIncludeArgs( 324 const llvm::opt::ArgList &DriverArgs, 325 llvm::opt::ArgStringList &CC1Args) const { 326 const Driver &D = getDriver(); 327 328 if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc)) 329 return; 330 331 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 332 SmallString<128> Dir(D.ResourceDir); 333 llvm::sys::path::append(Dir, "include"); 334 addSystemInclude(DriverArgs, CC1Args, Dir.str()); 335 } 336 337 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 338 return; 339 340 // Check for configure-time C include directories. 341 StringRef CIncludeDirs(C_INCLUDE_DIRS); 342 if (CIncludeDirs != "") { 343 SmallVector<StringRef, 5> dirs; 344 CIncludeDirs.split(dirs, ":"); 345 for (StringRef dir : dirs) { 346 StringRef Prefix = 347 llvm::sys::path::is_absolute(dir) ? StringRef(D.SysRoot) : ""; 348 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); 349 } 350 return; 351 } 352 353 addExternCSystemInclude(DriverArgs, CC1Args, 354 concat(D.SysRoot, "/usr/include")); 355 } 356 357 void OpenBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 358 llvm::opt::ArgStringList &CC1Args) const { 359 addSystemInclude(DriverArgs, CC1Args, 360 concat(getDriver().SysRoot, "/usr/include/c++/v1")); 361 } 362 363 void OpenBSD::AddCXXStdlibLibArgs(const ArgList &Args, 364 ArgStringList &CmdArgs) const { 365 bool Profiling = Args.hasArg(options::OPT_pg); 366 367 CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++"); 368 if (Args.hasArg(options::OPT_fexperimental_library)) 369 CmdArgs.push_back("-lc++experimental"); 370 CmdArgs.push_back(Profiling ? "-lc++abi_p" : "-lc++abi"); 371 CmdArgs.push_back(Profiling ? "-lpthread_p" : "-lpthread"); 372 } 373 374 std::string OpenBSD::getCompilerRT(const ArgList &Args, StringRef Component, 375 FileType Type) const { 376 if (Component == "builtins") { 377 SmallString<128> Path(getDriver().SysRoot); 378 llvm::sys::path::append(Path, "/usr/lib/libcompiler_rt.a"); 379 if (getVFS().exists(Path)) 380 return std::string(Path); 381 } 382 SmallString<128> P(getDriver().ResourceDir); 383 std::string CRTBasename = 384 buildCompilerRTBasename(Args, Component, Type, /*AddArch=*/false); 385 llvm::sys::path::append(P, "lib", CRTBasename); 386 // Checks if this is the base system case which uses a different location. 387 if (getVFS().exists(P)) 388 return std::string(P); 389 return ToolChain::getCompilerRT(Args, Component, Type); 390 } 391 392 Tool *OpenBSD::buildAssembler() const { 393 return new tools::openbsd::Assembler(*this); 394 } 395 396 Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); } 397 398 bool OpenBSD::HasNativeLLVMSupport() const { return true; } 399 400 ToolChain::UnwindTableLevel 401 OpenBSD::getDefaultUnwindTableLevel(const ArgList &Args) const { 402 switch (getArch()) { 403 case llvm::Triple::arm: 404 return UnwindTableLevel::None; 405 default: 406 return UnwindTableLevel::Asynchronous; 407 } 408 } 409