1 //===--- Fuchsia.cpp - Fuchsia 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 "Fuchsia.h" 10 #include "CommonArgs.h" 11 #include "clang/Config/config.h" 12 #include "clang/Driver/Compilation.h" 13 #include "clang/Driver/Driver.h" 14 #include "clang/Driver/DriverDiagnostic.h" 15 #include "clang/Driver/Options.h" 16 #include "clang/Driver/SanitizerArgs.h" 17 #include "llvm/Option/ArgList.h" 18 #include "llvm/ProfileData/InstrProf.h" 19 #include "llvm/Support/FileSystem.h" 20 #include "llvm/Support/Path.h" 21 #include "llvm/Support/VirtualFileSystem.h" 22 23 using namespace clang::driver; 24 using namespace clang::driver::toolchains; 25 using namespace clang::driver::tools; 26 using namespace clang; 27 using namespace llvm::opt; 28 29 using tools::addMultilibFlag; 30 31 void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA, 32 const InputInfo &Output, 33 const InputInfoList &Inputs, 34 const ArgList &Args, 35 const char *LinkingOutput) const { 36 const toolchains::Fuchsia &ToolChain = 37 static_cast<const toolchains::Fuchsia &>(getToolChain()); 38 const Driver &D = ToolChain.getDriver(); 39 40 ArgStringList CmdArgs; 41 42 // Silence warning for "clang -g foo.o -o foo" 43 Args.ClaimAllArgs(options::OPT_g_Group); 44 // and "clang -emit-llvm foo.o -o foo" 45 Args.ClaimAllArgs(options::OPT_emit_llvm); 46 // and for "clang -w foo.o -o foo". Other warning options are already 47 // handled somewhere else. 48 Args.ClaimAllArgs(options::OPT_w); 49 50 CmdArgs.push_back("-z"); 51 CmdArgs.push_back("max-page-size=4096"); 52 53 CmdArgs.push_back("-z"); 54 CmdArgs.push_back("now"); 55 56 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 57 if (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") || 58 llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")) { 59 CmdArgs.push_back("-z"); 60 CmdArgs.push_back("rodynamic"); 61 CmdArgs.push_back("-z"); 62 CmdArgs.push_back("separate-loadable-segments"); 63 CmdArgs.push_back("-z"); 64 CmdArgs.push_back("rel"); 65 CmdArgs.push_back("--pack-dyn-relocs=relr"); 66 } 67 68 if (!D.SysRoot.empty()) 69 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 70 71 if (!Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_r)) 72 CmdArgs.push_back("-pie"); 73 74 if (Args.hasArg(options::OPT_rdynamic)) 75 CmdArgs.push_back("-export-dynamic"); 76 77 if (Args.hasArg(options::OPT_s)) 78 CmdArgs.push_back("-s"); 79 80 if (Args.hasArg(options::OPT_r)) { 81 CmdArgs.push_back("-r"); 82 } else { 83 CmdArgs.push_back("--build-id"); 84 CmdArgs.push_back("--hash-style=gnu"); 85 } 86 87 CmdArgs.push_back("--eh-frame-hdr"); 88 89 if (Args.hasArg(options::OPT_static)) 90 CmdArgs.push_back("-Bstatic"); 91 else if (Args.hasArg(options::OPT_shared)) 92 CmdArgs.push_back("-shared"); 93 94 const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs(Args); 95 96 if (!Args.hasArg(options::OPT_shared)) { 97 std::string Dyld = D.DyldPrefix; 98 if (SanArgs.needsAsanRt() && SanArgs.needsSharedRt()) 99 Dyld += "asan/"; 100 if (SanArgs.needsHwasanRt() && SanArgs.needsSharedRt()) 101 Dyld += "hwasan/"; 102 if (SanArgs.needsTsanRt() && SanArgs.needsSharedRt()) 103 Dyld += "tsan/"; 104 Dyld += "ld.so.1"; 105 CmdArgs.push_back("-dynamic-linker"); 106 CmdArgs.push_back(Args.MakeArgString(Dyld)); 107 } 108 109 CmdArgs.push_back("-o"); 110 CmdArgs.push_back(Output.getFilename()); 111 112 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 113 if (!Args.hasArg(options::OPT_shared)) { 114 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("Scrt1.o"))); 115 } 116 } 117 118 Args.AddAllArgs(CmdArgs, options::OPT_L); 119 Args.AddAllArgs(CmdArgs, options::OPT_u); 120 121 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 122 123 if (D.isUsingLTO()) { 124 assert(!Inputs.empty() && "Must have at least one input."); 125 addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0], 126 D.getLTOMode() == LTOK_Thin); 127 } 128 129 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); 130 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 131 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 132 ToolChain.addProfileRTLibs(Args, CmdArgs); 133 134 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 135 if (Args.hasArg(options::OPT_static)) 136 CmdArgs.push_back("-Bdynamic"); 137 138 if (D.CCCIsCXX()) { 139 if (ToolChain.ShouldLinkCXXStdlib(Args)) { 140 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 141 !Args.hasArg(options::OPT_static); 142 CmdArgs.push_back("--push-state"); 143 CmdArgs.push_back("--as-needed"); 144 if (OnlyLibstdcxxStatic) 145 CmdArgs.push_back("-Bstatic"); 146 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 147 if (OnlyLibstdcxxStatic) 148 CmdArgs.push_back("-Bdynamic"); 149 CmdArgs.push_back("-lm"); 150 CmdArgs.push_back("--pop-state"); 151 } 152 } 153 154 if (NeedsSanitizerDeps) 155 linkSanitizerRuntimeDeps(ToolChain, CmdArgs); 156 157 if (NeedsXRayDeps) 158 linkXRayRuntimeDeps(ToolChain, CmdArgs); 159 160 AddRunTimeLibs(ToolChain, D, CmdArgs, Args); 161 162 if (Args.hasArg(options::OPT_pthread) || 163 Args.hasArg(options::OPT_pthreads)) 164 CmdArgs.push_back("-lpthread"); 165 166 if (Args.hasArg(options::OPT_fsplit_stack)) 167 CmdArgs.push_back("--wrap=pthread_create"); 168 169 if (!Args.hasArg(options::OPT_nolibc)) 170 CmdArgs.push_back("-lc"); 171 } 172 173 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), 174 Exec, CmdArgs, Inputs, Output)); 175 } 176 177 /// Fuchsia - Fuchsia tool chain which can call as(1) and ld(1) directly. 178 179 Fuchsia::Fuchsia(const Driver &D, const llvm::Triple &Triple, 180 const ArgList &Args) 181 : ToolChain(D, Triple, Args) { 182 getProgramPaths().push_back(getDriver().getInstalledDir()); 183 if (getDriver().getInstalledDir() != D.Dir) 184 getProgramPaths().push_back(D.Dir); 185 186 if (!D.SysRoot.empty()) { 187 SmallString<128> P(D.SysRoot); 188 llvm::sys::path::append(P, "lib"); 189 getFilePaths().push_back(std::string(P.str())); 190 } 191 192 auto FilePaths = [&](const Multilib &M) -> std::vector<std::string> { 193 std::vector<std::string> FP; 194 SmallString<128> P(getStdlibPath()); 195 llvm::sys::path::append(P, M.gccSuffix()); 196 FP.push_back(std::string(P.str())); 197 return FP; 198 }; 199 200 Multilibs.push_back(Multilib()); 201 // Use the noexcept variant with -fno-exceptions to avoid the extra overhead. 202 Multilibs.push_back(Multilib("noexcept", {}, {}, 1) 203 .flag("-fexceptions") 204 .flag("+fno-exceptions")); 205 // ASan has higher priority because we always want the instrumentated version. 206 Multilibs.push_back(Multilib("asan", {}, {}, 2) 207 .flag("+fsanitize=address")); 208 // Use the asan+noexcept variant with ASan and -fno-exceptions. 209 Multilibs.push_back(Multilib("asan+noexcept", {}, {}, 3) 210 .flag("+fsanitize=address") 211 .flag("-fexceptions") 212 .flag("+fno-exceptions")); 213 // HWASan has higher priority because we always want the instrumentated 214 // version. 215 Multilibs.push_back( 216 Multilib("hwasan", {}, {}, 4).flag("+fsanitize=hwaddress")); 217 // Use the hwasan+noexcept variant with HWASan and -fno-exceptions. 218 Multilibs.push_back(Multilib("hwasan+noexcept", {}, {}, 5) 219 .flag("+fsanitize=hwaddress") 220 .flag("-fexceptions") 221 .flag("+fno-exceptions")); 222 // Use the relative vtables ABI. 223 // TODO: Remove these multilibs once relative vtables are enabled by default 224 // for Fuchsia. 225 Multilibs.push_back(Multilib("relative-vtables", {}, {}, 6) 226 .flag("+fexperimental-relative-c++-abi-vtables")); 227 Multilibs.push_back(Multilib("relative-vtables+noexcept", {}, {}, 7) 228 .flag("+fexperimental-relative-c++-abi-vtables") 229 .flag("-fexceptions") 230 .flag("+fno-exceptions")); 231 Multilibs.push_back(Multilib("relative-vtables+asan", {}, {}, 8) 232 .flag("+fexperimental-relative-c++-abi-vtables") 233 .flag("+fsanitize=address")); 234 Multilibs.push_back(Multilib("relative-vtables+asan+noexcept", {}, {}, 9) 235 .flag("+fexperimental-relative-c++-abi-vtables") 236 .flag("+fsanitize=address") 237 .flag("-fexceptions") 238 .flag("+fno-exceptions")); 239 Multilibs.push_back(Multilib("relative-vtables+hwasan", {}, {}, 10) 240 .flag("+fexperimental-relative-c++-abi-vtables") 241 .flag("+fsanitize=hwaddress")); 242 Multilibs.push_back(Multilib("relative-vtables+hwasan+noexcept", {}, {}, 11) 243 .flag("+fexperimental-relative-c++-abi-vtables") 244 .flag("+fsanitize=hwaddress") 245 .flag("-fexceptions") 246 .flag("+fno-exceptions")); 247 // Use Itanium C++ ABI for the compat multilib. 248 Multilibs.push_back(Multilib("compat", {}, {}, 12).flag("+fc++-abi=itanium")); 249 250 Multilibs.FilterOut([&](const Multilib &M) { 251 std::vector<std::string> RD = FilePaths(M); 252 return llvm::all_of(RD, [&](std::string P) { return !getVFS().exists(P); }); 253 }); 254 255 Multilib::flags_list Flags; 256 addMultilibFlag( 257 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, true), 258 "fexceptions", Flags); 259 addMultilibFlag(getSanitizerArgs(Args).needsAsanRt(), "fsanitize=address", 260 Flags); 261 addMultilibFlag(getSanitizerArgs(Args).needsHwasanRt(), "fsanitize=hwaddress", 262 Flags); 263 264 addMultilibFlag( 265 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables, 266 options::OPT_fno_experimental_relative_cxx_abi_vtables, 267 /*default=*/false), 268 "fexperimental-relative-c++-abi-vtables", Flags); 269 addMultilibFlag(Args.getLastArgValue(options::OPT_fcxx_abi_EQ) == "itanium", 270 "fc++-abi=itanium", Flags); 271 272 Multilibs.setFilePathsCallback(FilePaths); 273 274 if (Multilibs.select(Flags, SelectedMultilib)) 275 if (!SelectedMultilib.isDefault()) 276 if (const auto &PathsCallback = Multilibs.filePathsCallback()) 277 for (const auto &Path : PathsCallback(SelectedMultilib)) 278 // Prepend the multilib path to ensure it takes the precedence. 279 getFilePaths().insert(getFilePaths().begin(), Path); 280 } 281 282 std::string Fuchsia::ComputeEffectiveClangTriple(const ArgList &Args, 283 types::ID InputType) const { 284 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType)); 285 return Triple.str(); 286 } 287 288 Tool *Fuchsia::buildLinker() const { 289 return new tools::fuchsia::Linker(*this); 290 } 291 292 ToolChain::RuntimeLibType Fuchsia::GetRuntimeLibType( 293 const ArgList &Args) const { 294 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_rtlib_EQ)) { 295 StringRef Value = A->getValue(); 296 if (Value != "compiler-rt") 297 getDriver().Diag(clang::diag::err_drv_invalid_rtlib_name) 298 << A->getAsString(Args); 299 } 300 301 return ToolChain::RLT_CompilerRT; 302 } 303 304 ToolChain::CXXStdlibType 305 Fuchsia::GetCXXStdlibType(const ArgList &Args) const { 306 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { 307 StringRef Value = A->getValue(); 308 if (Value != "libc++") 309 getDriver().Diag(diag::err_drv_invalid_stdlib_name) 310 << A->getAsString(Args); 311 } 312 313 return ToolChain::CST_Libcxx; 314 } 315 316 void Fuchsia::addClangTargetOptions(const ArgList &DriverArgs, 317 ArgStringList &CC1Args, 318 Action::OffloadKind) const { 319 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 320 options::OPT_fno_use_init_array, true)) 321 CC1Args.push_back("-fno-use-init-array"); 322 } 323 324 void Fuchsia::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 325 ArgStringList &CC1Args) const { 326 const Driver &D = getDriver(); 327 328 if (DriverArgs.hasArg(options::OPT_nostdinc)) 329 return; 330 331 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 332 SmallString<128> P(D.ResourceDir); 333 llvm::sys::path::append(P, "include"); 334 addSystemInclude(DriverArgs, CC1Args, P); 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 if (!D.SysRoot.empty()) { 354 SmallString<128> P(D.SysRoot); 355 llvm::sys::path::append(P, "include"); 356 addExternCSystemInclude(DriverArgs, CC1Args, P.str()); 357 } 358 } 359 360 void Fuchsia::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 361 ArgStringList &CC1Args) const { 362 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 363 DriverArgs.hasArg(options::OPT_nostdincxx)) 364 return; 365 366 const Driver &D = getDriver(); 367 std::string Target = getTripleString(); 368 369 auto AddCXXIncludePath = [&](StringRef Path) { 370 std::string Version = detectLibcxxVersion(Path); 371 if (Version.empty()) 372 return; 373 374 // First add the per-target include path. 375 SmallString<128> TargetDir(Path); 376 llvm::sys::path::append(TargetDir, Target, "c++", Version); 377 if (getVFS().exists(TargetDir)) 378 addSystemInclude(DriverArgs, CC1Args, TargetDir); 379 380 // Second add the generic one. 381 SmallString<128> Dir(Path); 382 llvm::sys::path::append(Dir, "c++", Version); 383 addSystemInclude(DriverArgs, CC1Args, Dir); 384 }; 385 386 switch (GetCXXStdlibType(DriverArgs)) { 387 case ToolChain::CST_Libcxx: { 388 SmallString<128> P(D.Dir); 389 llvm::sys::path::append(P, "..", "include"); 390 AddCXXIncludePath(P); 391 break; 392 } 393 394 default: 395 llvm_unreachable("invalid stdlib name"); 396 } 397 } 398 399 void Fuchsia::AddCXXStdlibLibArgs(const ArgList &Args, 400 ArgStringList &CmdArgs) const { 401 switch (GetCXXStdlibType(Args)) { 402 case ToolChain::CST_Libcxx: 403 CmdArgs.push_back("-lc++"); 404 break; 405 406 case ToolChain::CST_Libstdcxx: 407 llvm_unreachable("invalid stdlib name"); 408 } 409 } 410 411 SanitizerMask Fuchsia::getSupportedSanitizers() const { 412 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 413 Res |= SanitizerKind::Address; 414 Res |= SanitizerKind::HWAddress; 415 Res |= SanitizerKind::PointerCompare; 416 Res |= SanitizerKind::PointerSubtract; 417 Res |= SanitizerKind::Fuzzer; 418 Res |= SanitizerKind::FuzzerNoLink; 419 Res |= SanitizerKind::Leak; 420 Res |= SanitizerKind::SafeStack; 421 Res |= SanitizerKind::Scudo; 422 Res |= SanitizerKind::Thread; 423 return Res; 424 } 425 426 SanitizerMask Fuchsia::getDefaultSanitizers() const { 427 SanitizerMask Res; 428 switch (getTriple().getArch()) { 429 case llvm::Triple::aarch64: 430 Res |= SanitizerKind::ShadowCallStack; 431 break; 432 case llvm::Triple::x86_64: 433 Res |= SanitizerKind::SafeStack; 434 break; 435 default: 436 // TODO: Enable SafeStack on RISC-V once tested. 437 break; 438 } 439 return Res; 440 } 441