1 //===--- CommonArgs.cpp - Args handling for multiple toolchains -*- 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 "CommonArgs.h" 10 #include "Arch/AArch64.h" 11 #include "Arch/ARM.h" 12 #include "Arch/M68k.h" 13 #include "Arch/Mips.h" 14 #include "Arch/PPC.h" 15 #include "Arch/SystemZ.h" 16 #include "Arch/VE.h" 17 #include "Arch/X86.h" 18 #include "HIP.h" 19 #include "Hexagon.h" 20 #include "InputInfo.h" 21 #include "clang/Basic/CharInfo.h" 22 #include "clang/Basic/LangOptions.h" 23 #include "clang/Basic/ObjCRuntime.h" 24 #include "clang/Basic/Version.h" 25 #include "clang/Config/config.h" 26 #include "clang/Driver/Action.h" 27 #include "clang/Driver/Compilation.h" 28 #include "clang/Driver/Driver.h" 29 #include "clang/Driver/DriverDiagnostic.h" 30 #include "clang/Driver/Job.h" 31 #include "clang/Driver/Options.h" 32 #include "clang/Driver/SanitizerArgs.h" 33 #include "clang/Driver/ToolChain.h" 34 #include "clang/Driver/Util.h" 35 #include "clang/Driver/XRayArgs.h" 36 #include "llvm/ADT/STLExtras.h" 37 #include "llvm/ADT/SmallString.h" 38 #include "llvm/ADT/StringExtras.h" 39 #include "llvm/ADT/StringSwitch.h" 40 #include "llvm/ADT/Twine.h" 41 #include "llvm/Config/llvm-config.h" 42 #include "llvm/Option/Arg.h" 43 #include "llvm/Option/ArgList.h" 44 #include "llvm/Option/Option.h" 45 #include "llvm/Support/CodeGen.h" 46 #include "llvm/Support/Compression.h" 47 #include "llvm/Support/Debug.h" 48 #include "llvm/Support/ErrorHandling.h" 49 #include "llvm/Support/FileSystem.h" 50 #include "llvm/Support/Host.h" 51 #include "llvm/Support/Path.h" 52 #include "llvm/Support/Process.h" 53 #include "llvm/Support/Program.h" 54 #include "llvm/Support/ScopedPrinter.h" 55 #include "llvm/Support/TargetParser.h" 56 #include "llvm/Support/Threading.h" 57 #include "llvm/Support/VirtualFileSystem.h" 58 #include "llvm/Support/YAMLParser.h" 59 60 using namespace clang::driver; 61 using namespace clang::driver::tools; 62 using namespace clang; 63 using namespace llvm::opt; 64 65 static void renderRpassOptions(const ArgList &Args, ArgStringList &CmdArgs) { 66 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ)) 67 CmdArgs.push_back(Args.MakeArgString(Twine("--plugin-opt=-pass-remarks=") + 68 A->getValue())); 69 70 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ)) 71 CmdArgs.push_back(Args.MakeArgString( 72 Twine("--plugin-opt=-pass-remarks-missed=") + A->getValue())); 73 74 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ)) 75 CmdArgs.push_back(Args.MakeArgString( 76 Twine("--plugin-opt=-pass-remarks-analysis=") + A->getValue())); 77 } 78 79 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, 80 const llvm::Triple &Triple, 81 const InputInfo &Input, 82 const InputInfo &Output) { 83 StringRef Format = "yaml"; 84 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ)) 85 Format = A->getValue(); 86 87 SmallString<128> F; 88 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ); 89 if (A) 90 F = A->getValue(); 91 else if (Output.isFilename()) 92 F = Output.getFilename(); 93 94 assert(!F.empty() && "Cannot determine remarks output name."); 95 // Append "opt.ld.<format>" to the end of the file name. 96 CmdArgs.push_back( 97 Args.MakeArgString(Twine("--plugin-opt=opt-remarks-filename=") + F + 98 Twine(".opt.ld.") + Format)); 99 100 if (const Arg *A = 101 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) 102 CmdArgs.push_back(Args.MakeArgString( 103 Twine("--plugin-opt=opt-remarks-passes=") + A->getValue())); 104 105 CmdArgs.push_back(Args.MakeArgString( 106 Twine("--plugin-opt=opt-remarks-format=") + Format.data())); 107 } 108 109 static void renderRemarksHotnessOptions(const ArgList &Args, 110 ArgStringList &CmdArgs) { 111 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness, 112 options::OPT_fno_diagnostics_show_hotness, false)) 113 CmdArgs.push_back("--plugin-opt=opt-remarks-with-hotness"); 114 115 if (const Arg *A = 116 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) 117 CmdArgs.push_back(Args.MakeArgString( 118 Twine("--plugin-opt=opt-remarks-hotness-threshold=") + A->getValue())); 119 } 120 121 void tools::addPathIfExists(const Driver &D, const Twine &Path, 122 ToolChain::path_list &Paths) { 123 if (D.getVFS().exists(Path)) 124 Paths.push_back(Path.str()); 125 } 126 127 void tools::handleTargetFeaturesGroup(const ArgList &Args, 128 std::vector<StringRef> &Features, 129 OptSpecifier Group) { 130 for (const Arg *A : Args.filtered(Group)) { 131 StringRef Name = A->getOption().getName(); 132 A->claim(); 133 134 // Skip over "-m". 135 assert(Name.startswith("m") && "Invalid feature name."); 136 Name = Name.substr(1); 137 138 bool IsNegative = Name.startswith("no-"); 139 if (IsNegative) 140 Name = Name.substr(3); 141 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 142 } 143 } 144 145 std::vector<StringRef> 146 tools::unifyTargetFeatures(const std::vector<StringRef> &Features) { 147 std::vector<StringRef> UnifiedFeatures; 148 // Find the last of each feature. 149 llvm::StringMap<unsigned> LastOpt; 150 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 151 StringRef Name = Features[I]; 152 assert(Name[0] == '-' || Name[0] == '+'); 153 LastOpt[Name.drop_front(1)] = I; 154 } 155 156 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 157 // If this feature was overridden, ignore it. 158 StringRef Name = Features[I]; 159 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1)); 160 assert(LastI != LastOpt.end()); 161 unsigned Last = LastI->second; 162 if (Last != I) 163 continue; 164 165 UnifiedFeatures.push_back(Name); 166 } 167 return UnifiedFeatures; 168 } 169 170 void tools::addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs, 171 const char *ArgName, const char *EnvVar) { 172 const char *DirList = ::getenv(EnvVar); 173 bool CombinedArg = false; 174 175 if (!DirList) 176 return; // Nothing to do. 177 178 StringRef Name(ArgName); 179 if (Name.equals("-I") || Name.equals("-L") || Name.empty()) 180 CombinedArg = true; 181 182 StringRef Dirs(DirList); 183 if (Dirs.empty()) // Empty string should not add '.'. 184 return; 185 186 StringRef::size_type Delim; 187 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) { 188 if (Delim == 0) { // Leading colon. 189 if (CombinedArg) { 190 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 191 } else { 192 CmdArgs.push_back(ArgName); 193 CmdArgs.push_back("."); 194 } 195 } else { 196 if (CombinedArg) { 197 CmdArgs.push_back( 198 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim))); 199 } else { 200 CmdArgs.push_back(ArgName); 201 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim))); 202 } 203 } 204 Dirs = Dirs.substr(Delim + 1); 205 } 206 207 if (Dirs.empty()) { // Trailing colon. 208 if (CombinedArg) { 209 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 210 } else { 211 CmdArgs.push_back(ArgName); 212 CmdArgs.push_back("."); 213 } 214 } else { // Add the last path. 215 if (CombinedArg) { 216 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs)); 217 } else { 218 CmdArgs.push_back(ArgName); 219 CmdArgs.push_back(Args.MakeArgString(Dirs)); 220 } 221 } 222 } 223 224 void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, 225 const ArgList &Args, ArgStringList &CmdArgs, 226 const JobAction &JA) { 227 const Driver &D = TC.getDriver(); 228 229 // Add extra linker input arguments which are not treated as inputs 230 // (constructed via -Xarch_). 231 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input); 232 233 // LIBRARY_PATH are included before user inputs and only supported on native 234 // toolchains. 235 if (!TC.isCrossCompiling()) 236 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH"); 237 238 for (const auto &II : Inputs) { 239 // If the current tool chain refers to an OpenMP offloading host, we 240 // should ignore inputs that refer to OpenMP offloading devices - 241 // they will be embedded according to a proper linker script. 242 if (auto *IA = II.getAction()) 243 if ((JA.isHostOffloading(Action::OFK_OpenMP) && 244 IA->isDeviceOffloading(Action::OFK_OpenMP))) 245 continue; 246 247 if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(II.getType())) 248 // Don't try to pass LLVM inputs unless we have native support. 249 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString(); 250 251 // Add filenames immediately. 252 if (II.isFilename()) { 253 CmdArgs.push_back(II.getFilename()); 254 continue; 255 } 256 257 // Otherwise, this is a linker input argument. 258 const Arg &A = II.getInputArg(); 259 260 // Handle reserved library options. 261 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) 262 TC.AddCXXStdlibLibArgs(Args, CmdArgs); 263 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) 264 TC.AddCCKextLibArgs(Args, CmdArgs); 265 else if (A.getOption().matches(options::OPT_z)) { 266 // Pass -z prefix for gcc linker compatibility. 267 A.claim(); 268 A.render(Args, CmdArgs); 269 } else { 270 A.renderAsInput(Args, CmdArgs); 271 } 272 } 273 } 274 275 void tools::addLinkerCompressDebugSectionsOption( 276 const ToolChain &TC, const llvm::opt::ArgList &Args, 277 llvm::opt::ArgStringList &CmdArgs) { 278 // GNU ld supports --compress-debug-sections=none|zlib|zlib-gnu|zlib-gabi 279 // whereas zlib is an alias to zlib-gabi. Therefore -gz=none|zlib|zlib-gnu 280 // are translated to --compress-debug-sections=none|zlib|zlib-gnu. 281 // -gz is not translated since ld --compress-debug-sections option requires an 282 // argument. 283 if (const Arg *A = Args.getLastArg(options::OPT_gz_EQ)) { 284 StringRef V = A->getValue(); 285 if (V == "none" || V == "zlib" || V == "zlib-gnu") 286 CmdArgs.push_back(Args.MakeArgString("--compress-debug-sections=" + V)); 287 else 288 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument) 289 << A->getOption().getName() << V; 290 } 291 } 292 293 void tools::AddTargetFeature(const ArgList &Args, 294 std::vector<StringRef> &Features, 295 OptSpecifier OnOpt, OptSpecifier OffOpt, 296 StringRef FeatureName) { 297 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) { 298 if (A->getOption().matches(OnOpt)) 299 Features.push_back(Args.MakeArgString("+" + FeatureName)); 300 else 301 Features.push_back(Args.MakeArgString("-" + FeatureName)); 302 } 303 } 304 305 /// Get the (LLVM) name of the AMDGPU gpu we are targeting. 306 static std::string getAMDGPUTargetGPU(const llvm::Triple &T, 307 const ArgList &Args) { 308 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 309 auto GPUName = getProcessorFromTargetID(T, A->getValue()); 310 return llvm::StringSwitch<std::string>(GPUName) 311 .Cases("rv630", "rv635", "r600") 312 .Cases("rv610", "rv620", "rs780", "rs880") 313 .Case("rv740", "rv770") 314 .Case("palm", "cedar") 315 .Cases("sumo", "sumo2", "sumo") 316 .Case("hemlock", "cypress") 317 .Case("aruba", "cayman") 318 .Default(GPUName.str()); 319 } 320 return ""; 321 } 322 323 static std::string getLanaiTargetCPU(const ArgList &Args) { 324 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 325 return A->getValue(); 326 } 327 return ""; 328 } 329 330 /// Get the (LLVM) name of the WebAssembly cpu we are targeting. 331 static StringRef getWebAssemblyTargetCPU(const ArgList &Args) { 332 // If we have -mcpu=, use that. 333 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 334 StringRef CPU = A->getValue(); 335 336 #ifdef __wasm__ 337 // Handle "native" by examining the host. "native" isn't meaningful when 338 // cross compiling, so only support this when the host is also WebAssembly. 339 if (CPU == "native") 340 return llvm::sys::getHostCPUName(); 341 #endif 342 343 return CPU; 344 } 345 346 return "generic"; 347 } 348 349 std::string tools::getCPUName(const ArgList &Args, const llvm::Triple &T, 350 bool FromAs) { 351 Arg *A; 352 353 switch (T.getArch()) { 354 default: 355 return ""; 356 357 case llvm::Triple::aarch64: 358 case llvm::Triple::aarch64_32: 359 case llvm::Triple::aarch64_be: 360 return aarch64::getAArch64TargetCPU(Args, T, A); 361 362 case llvm::Triple::arm: 363 case llvm::Triple::armeb: 364 case llvm::Triple::thumb: 365 case llvm::Triple::thumbeb: { 366 StringRef MArch, MCPU; 367 arm::getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs); 368 return arm::getARMTargetCPU(MCPU, MArch, T); 369 } 370 371 case llvm::Triple::avr: 372 if (const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ)) 373 return A->getValue(); 374 return ""; 375 376 case llvm::Triple::m68k: 377 return m68k::getM68kTargetCPU(Args); 378 379 case llvm::Triple::mips: 380 case llvm::Triple::mipsel: 381 case llvm::Triple::mips64: 382 case llvm::Triple::mips64el: { 383 StringRef CPUName; 384 StringRef ABIName; 385 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName); 386 return std::string(CPUName); 387 } 388 389 case llvm::Triple::nvptx: 390 case llvm::Triple::nvptx64: 391 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 392 return A->getValue(); 393 return ""; 394 395 case llvm::Triple::ppc: 396 case llvm::Triple::ppcle: 397 case llvm::Triple::ppc64: 398 case llvm::Triple::ppc64le: { 399 std::string TargetCPUName = ppc::getPPCTargetCPU(Args); 400 // LLVM may default to generating code for the native CPU, 401 // but, like gcc, we default to a more generic option for 402 // each architecture. (except on AIX) 403 if (!TargetCPUName.empty()) 404 return TargetCPUName; 405 406 if (T.isOSAIX()) { 407 unsigned major, minor, unused_micro; 408 T.getOSVersion(major, minor, unused_micro); 409 // The minimal arch level moved from pwr4 for AIX7.1 to 410 // pwr7 for AIX7.2. 411 TargetCPUName = 412 (major < 7 || (major == 7 && minor < 2)) ? "pwr4" : "pwr7"; 413 } else if (T.getArch() == llvm::Triple::ppc64le) 414 TargetCPUName = "ppc64le"; 415 else if (T.getArch() == llvm::Triple::ppc64) 416 TargetCPUName = "ppc64"; 417 else 418 TargetCPUName = "ppc"; 419 420 return TargetCPUName; 421 } 422 case llvm::Triple::riscv32: 423 case llvm::Triple::riscv64: 424 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 425 return A->getValue(); 426 return ""; 427 428 case llvm::Triple::bpfel: 429 case llvm::Triple::bpfeb: 430 case llvm::Triple::sparc: 431 case llvm::Triple::sparcel: 432 case llvm::Triple::sparcv9: 433 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 434 return A->getValue(); 435 if (T.getArch() == llvm::Triple::sparc && T.isOSSolaris()) 436 return "v9"; 437 return ""; 438 439 case llvm::Triple::x86: 440 case llvm::Triple::x86_64: 441 return x86::getX86TargetCPU(Args, T); 442 443 case llvm::Triple::hexagon: 444 return "hexagon" + 445 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str(); 446 447 case llvm::Triple::lanai: 448 return getLanaiTargetCPU(Args); 449 450 case llvm::Triple::systemz: 451 return systemz::getSystemZTargetCPU(Args); 452 453 case llvm::Triple::r600: 454 case llvm::Triple::amdgcn: 455 return getAMDGPUTargetGPU(T, Args); 456 457 case llvm::Triple::wasm32: 458 case llvm::Triple::wasm64: 459 return std::string(getWebAssemblyTargetCPU(Args)); 460 } 461 } 462 463 llvm::StringRef tools::getLTOParallelism(const ArgList &Args, const Driver &D) { 464 Arg *LtoJobsArg = Args.getLastArg(options::OPT_flto_jobs_EQ); 465 if (!LtoJobsArg) 466 return {}; 467 if (!llvm::get_threadpool_strategy(LtoJobsArg->getValue())) 468 D.Diag(diag::err_drv_invalid_int_value) 469 << LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue(); 470 return LtoJobsArg->getValue(); 471 } 472 473 // CloudABI uses -ffunction-sections and -fdata-sections by default. 474 bool tools::isUseSeparateSections(const llvm::Triple &Triple) { 475 return Triple.getOS() == llvm::Triple::CloudABI; 476 } 477 478 void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args, 479 ArgStringList &CmdArgs, const InputInfo &Output, 480 const InputInfo &Input, bool IsThinLTO) { 481 const char *Linker = Args.MakeArgString(ToolChain.GetLinkerPath()); 482 const Driver &D = ToolChain.getDriver(); 483 if (llvm::sys::path::filename(Linker) != "ld.lld" && 484 llvm::sys::path::stem(Linker) != "ld.lld") { 485 // Tell the linker to load the plugin. This has to come before 486 // AddLinkerInputs as gold requires -plugin to come before any -plugin-opt 487 // that -Wl might forward. 488 CmdArgs.push_back("-plugin"); 489 490 #if defined(_WIN32) 491 const char *Suffix = ".dll"; 492 #elif defined(__APPLE__) 493 const char *Suffix = ".dylib"; 494 #else 495 const char *Suffix = ".so"; 496 #endif 497 498 SmallString<1024> Plugin; 499 llvm::sys::path::native( 500 Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix, 501 Plugin); 502 CmdArgs.push_back(Args.MakeArgString(Plugin)); 503 } 504 505 // Try to pass driver level flags relevant to LTO code generation down to 506 // the plugin. 507 508 // Handle flags for selecting CPU variants. 509 std::string CPU = getCPUName(Args, ToolChain.getTriple()); 510 if (!CPU.empty()) 511 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU)); 512 513 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 514 // The optimization level matches 515 // CompilerInvocation.cpp:getOptimizationLevel(). 516 StringRef OOpt; 517 if (A->getOption().matches(options::OPT_O4) || 518 A->getOption().matches(options::OPT_Ofast)) 519 OOpt = "3"; 520 else if (A->getOption().matches(options::OPT_O)) { 521 OOpt = A->getValue(); 522 if (OOpt == "g") 523 OOpt = "1"; 524 else if (OOpt == "s" || OOpt == "z") 525 OOpt = "2"; 526 } else if (A->getOption().matches(options::OPT_O0)) 527 OOpt = "0"; 528 if (!OOpt.empty()) 529 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=O") + OOpt)); 530 } 531 532 if (Args.hasArg(options::OPT_gsplit_dwarf)) { 533 CmdArgs.push_back( 534 Args.MakeArgString(Twine("-plugin-opt=dwo_dir=") + 535 Output.getFilename() + "_dwo")); 536 } 537 538 if (IsThinLTO) 539 CmdArgs.push_back("-plugin-opt=thinlto"); 540 541 StringRef Parallelism = getLTOParallelism(Args, D); 542 if (!Parallelism.empty()) 543 CmdArgs.push_back( 544 Args.MakeArgString("-plugin-opt=jobs=" + Twine(Parallelism))); 545 546 // If an explicit debugger tuning argument appeared, pass it along. 547 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group, 548 options::OPT_ggdbN_Group)) { 549 if (A->getOption().matches(options::OPT_glldb)) 550 CmdArgs.push_back("-plugin-opt=-debugger-tune=lldb"); 551 else if (A->getOption().matches(options::OPT_gsce)) 552 CmdArgs.push_back("-plugin-opt=-debugger-tune=sce"); 553 else if (A->getOption().matches(options::OPT_gdbx)) 554 CmdArgs.push_back("-plugin-opt=-debugger-tune=dbx"); 555 else 556 CmdArgs.push_back("-plugin-opt=-debugger-tune=gdb"); 557 } 558 559 bool UseSeparateSections = 560 isUseSeparateSections(ToolChain.getEffectiveTriple()); 561 562 if (Args.hasFlag(options::OPT_ffunction_sections, 563 options::OPT_fno_function_sections, UseSeparateSections)) { 564 CmdArgs.push_back("-plugin-opt=-function-sections"); 565 } 566 567 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections, 568 UseSeparateSections)) { 569 CmdArgs.push_back("-plugin-opt=-data-sections"); 570 } 571 572 if (Arg *A = getLastProfileSampleUseArg(Args)) { 573 StringRef FName = A->getValue(); 574 if (!llvm::sys::fs::exists(FName)) 575 D.Diag(diag::err_drv_no_such_file) << FName; 576 else 577 CmdArgs.push_back( 578 Args.MakeArgString(Twine("-plugin-opt=sample-profile=") + FName)); 579 } 580 581 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate, 582 options::OPT_fcs_profile_generate_EQ, 583 options::OPT_fno_profile_generate); 584 if (CSPGOGenerateArg && 585 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate)) 586 CSPGOGenerateArg = nullptr; 587 588 auto *ProfileUseArg = getLastProfileUseArg(Args); 589 590 if (CSPGOGenerateArg) { 591 CmdArgs.push_back(Args.MakeArgString("-plugin-opt=cs-profile-generate")); 592 if (CSPGOGenerateArg->getOption().matches( 593 options::OPT_fcs_profile_generate_EQ)) { 594 SmallString<128> Path(CSPGOGenerateArg->getValue()); 595 llvm::sys::path::append(Path, "default_%m.profraw"); 596 CmdArgs.push_back( 597 Args.MakeArgString(Twine("-plugin-opt=cs-profile-path=") + Path)); 598 } else 599 CmdArgs.push_back( 600 Args.MakeArgString("-plugin-opt=cs-profile-path=default_%m.profraw")); 601 } else if (ProfileUseArg) { 602 SmallString<128> Path( 603 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue()); 604 if (Path.empty() || llvm::sys::fs::is_directory(Path)) 605 llvm::sys::path::append(Path, "default.profdata"); 606 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=cs-profile-path=") + 607 Path)); 608 } 609 610 // Pass an option to enable/disable the new pass manager. 611 if (auto *A = Args.getLastArg(options::OPT_flegacy_pass_manager, 612 options::OPT_fno_legacy_pass_manager)) { 613 if (A->getOption().matches(options::OPT_flegacy_pass_manager)) 614 CmdArgs.push_back("-plugin-opt=legacy-pass-manager"); 615 else 616 CmdArgs.push_back("-plugin-opt=new-pass-manager"); 617 } 618 619 // Pass an option to enable pseudo probe emission. 620 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling, 621 options::OPT_fno_pseudo_probe_for_profiling, false)) 622 CmdArgs.push_back("-plugin-opt=pseudo-probe-for-profiling"); 623 624 // Setup statistics file output. 625 SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D); 626 if (!StatsFile.empty()) 627 CmdArgs.push_back( 628 Args.MakeArgString(Twine("-plugin-opt=stats-file=") + StatsFile)); 629 630 addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/true); 631 632 // Handle remark diagnostics on screen options: '-Rpass-*'. 633 renderRpassOptions(Args, CmdArgs); 634 635 // Handle serialized remarks options: '-fsave-optimization-record' 636 // and '-foptimization-record-*'. 637 if (willEmitRemarks(Args)) 638 renderRemarksOptions(Args, CmdArgs, ToolChain.getEffectiveTriple(), Input, 639 Output); 640 641 // Handle remarks hotness/threshold related options. 642 renderRemarksHotnessOptions(Args, CmdArgs); 643 644 addMachineOutlinerArgs(D, Args, CmdArgs, ToolChain.getEffectiveTriple(), 645 /*IsLTO=*/true); 646 } 647 648 void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args, 649 ArgStringList &CmdArgs) { 650 // Enable -frtlib-add-rpath by default for the case of VE. 651 const bool IsVE = TC.getTriple().isVE(); 652 bool DefaultValue = IsVE; 653 if (!Args.hasFlag(options::OPT_frtlib_add_rpath, 654 options::OPT_fno_rtlib_add_rpath, DefaultValue)) 655 return; 656 657 std::string CandidateRPath = TC.getArchSpecificLibPath(); 658 if (TC.getVFS().exists(CandidateRPath)) { 659 CmdArgs.push_back("-rpath"); 660 CmdArgs.push_back(Args.MakeArgString(CandidateRPath.c_str())); 661 } 662 } 663 664 bool tools::addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC, 665 const ArgList &Args, bool ForceStaticHostRuntime, 666 bool IsOffloadingHost, bool GompNeedsRT) { 667 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ, 668 options::OPT_fno_openmp, false)) 669 return false; 670 671 Driver::OpenMPRuntimeKind RTKind = TC.getDriver().getOpenMPRuntime(Args); 672 673 if (RTKind == Driver::OMPRT_Unknown) 674 // Already diagnosed. 675 return false; 676 677 if (ForceStaticHostRuntime) 678 CmdArgs.push_back("-Bstatic"); 679 680 switch (RTKind) { 681 case Driver::OMPRT_OMP: 682 CmdArgs.push_back("-lomp"); 683 break; 684 case Driver::OMPRT_GOMP: 685 CmdArgs.push_back("-lgomp"); 686 break; 687 case Driver::OMPRT_IOMP5: 688 CmdArgs.push_back("-liomp5"); 689 break; 690 case Driver::OMPRT_Unknown: 691 break; 692 } 693 694 if (ForceStaticHostRuntime) 695 CmdArgs.push_back("-Bdynamic"); 696 697 if (RTKind == Driver::OMPRT_GOMP && GompNeedsRT) 698 CmdArgs.push_back("-lrt"); 699 700 if (IsOffloadingHost) 701 CmdArgs.push_back("-lomptarget"); 702 703 addArchSpecificRPath(TC, Args, CmdArgs); 704 705 return true; 706 } 707 708 static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args, 709 ArgStringList &CmdArgs, StringRef Sanitizer, 710 bool IsShared, bool IsWhole) { 711 // Wrap any static runtimes that must be forced into executable in 712 // whole-archive. 713 if (IsWhole) CmdArgs.push_back("--whole-archive"); 714 CmdArgs.push_back(TC.getCompilerRTArgString( 715 Args, Sanitizer, IsShared ? ToolChain::FT_Shared : ToolChain::FT_Static)); 716 if (IsWhole) CmdArgs.push_back("--no-whole-archive"); 717 718 if (IsShared) { 719 addArchSpecificRPath(TC, Args, CmdArgs); 720 } 721 } 722 723 // Tries to use a file with the list of dynamic symbols that need to be exported 724 // from the runtime library. Returns true if the file was found. 725 static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args, 726 ArgStringList &CmdArgs, 727 StringRef Sanitizer) { 728 // Solaris ld defaults to --export-dynamic behaviour but doesn't support 729 // the option, so don't try to pass it. 730 if (TC.getTriple().getOS() == llvm::Triple::Solaris) 731 return true; 732 // Myriad is static linking only. Furthermore, some versions of its 733 // linker have the bug where --export-dynamic overrides -static, so 734 // don't use --export-dynamic on that platform. 735 if (TC.getTriple().getVendor() == llvm::Triple::Myriad) 736 return true; 737 SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer)); 738 if (llvm::sys::fs::exists(SanRT + ".syms")) { 739 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms")); 740 return true; 741 } 742 return false; 743 } 744 745 static const char *getAsNeededOption(const ToolChain &TC, bool as_needed) { 746 // While the Solaris 11.2 ld added --as-needed/--no-as-needed as aliases 747 // for the native forms -z ignore/-z record, they are missing in Illumos, 748 // so always use the native form. 749 if (TC.getTriple().isOSSolaris()) 750 return as_needed ? "-zignore" : "-zrecord"; 751 else 752 return as_needed ? "--as-needed" : "--no-as-needed"; 753 } 754 755 void tools::linkSanitizerRuntimeDeps(const ToolChain &TC, 756 ArgStringList &CmdArgs) { 757 // Fuchsia never needs these. Any sanitizer runtimes with system 758 // dependencies use the `.deplibs` feature instead. 759 if (TC.getTriple().isOSFuchsia()) 760 return; 761 762 // Force linking against the system libraries sanitizers depends on 763 // (see PR15823 why this is necessary). 764 CmdArgs.push_back(getAsNeededOption(TC, false)); 765 // There's no libpthread or librt on RTEMS & Android. 766 if (TC.getTriple().getOS() != llvm::Triple::RTEMS && 767 !TC.getTriple().isAndroid()) { 768 CmdArgs.push_back("-lpthread"); 769 if (!TC.getTriple().isOSOpenBSD()) 770 CmdArgs.push_back("-lrt"); 771 } 772 CmdArgs.push_back("-lm"); 773 // There's no libdl on all OSes. 774 if (!TC.getTriple().isOSFreeBSD() && 775 !TC.getTriple().isOSNetBSD() && 776 !TC.getTriple().isOSOpenBSD() && 777 TC.getTriple().getOS() != llvm::Triple::RTEMS) 778 CmdArgs.push_back("-ldl"); 779 // Required for backtrace on some OSes 780 if (TC.getTriple().isOSFreeBSD() || 781 TC.getTriple().isOSNetBSD()) 782 CmdArgs.push_back("-lexecinfo"); 783 } 784 785 static void 786 collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, 787 SmallVectorImpl<StringRef> &SharedRuntimes, 788 SmallVectorImpl<StringRef> &StaticRuntimes, 789 SmallVectorImpl<StringRef> &NonWholeStaticRuntimes, 790 SmallVectorImpl<StringRef> &HelperStaticRuntimes, 791 SmallVectorImpl<StringRef> &RequiredSymbols) { 792 const SanitizerArgs &SanArgs = TC.getSanitizerArgs(); 793 // Collect shared runtimes. 794 if (SanArgs.needsSharedRt()) { 795 if (SanArgs.needsAsanRt() && SanArgs.linkRuntimes()) { 796 SharedRuntimes.push_back("asan"); 797 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid()) 798 HelperStaticRuntimes.push_back("asan-preinit"); 799 } 800 if (SanArgs.needsMemProfRt() && SanArgs.linkRuntimes()) { 801 SharedRuntimes.push_back("memprof"); 802 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid()) 803 HelperStaticRuntimes.push_back("memprof-preinit"); 804 } 805 if (SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) { 806 if (SanArgs.requiresMinimalRuntime()) 807 SharedRuntimes.push_back("ubsan_minimal"); 808 else 809 SharedRuntimes.push_back("ubsan_standalone"); 810 } 811 if (SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) { 812 if (SanArgs.requiresMinimalRuntime()) 813 SharedRuntimes.push_back("scudo_minimal"); 814 else 815 SharedRuntimes.push_back("scudo"); 816 } 817 if (SanArgs.needsTsanRt() && SanArgs.linkRuntimes()) 818 SharedRuntimes.push_back("tsan"); 819 if (SanArgs.needsHwasanRt() && SanArgs.linkRuntimes()) { 820 if (SanArgs.needsHwasanAliasesRt()) 821 SharedRuntimes.push_back("hwasan_aliases"); 822 else 823 SharedRuntimes.push_back("hwasan"); 824 } 825 } 826 827 // The stats_client library is also statically linked into DSOs. 828 if (SanArgs.needsStatsRt() && SanArgs.linkRuntimes()) 829 StaticRuntimes.push_back("stats_client"); 830 831 // Collect static runtimes. 832 if (Args.hasArg(options::OPT_shared)) { 833 // Don't link static runtimes into DSOs. 834 return; 835 } 836 837 // Each static runtime that has a DSO counterpart above is excluded below, 838 // but runtimes that exist only as static are not affected by needsSharedRt. 839 840 if (!SanArgs.needsSharedRt() && SanArgs.needsAsanRt() && SanArgs.linkRuntimes()) { 841 StaticRuntimes.push_back("asan"); 842 if (SanArgs.linkCXXRuntimes()) 843 StaticRuntimes.push_back("asan_cxx"); 844 } 845 846 if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt() && 847 SanArgs.linkRuntimes()) { 848 StaticRuntimes.push_back("memprof"); 849 if (SanArgs.linkCXXRuntimes()) 850 StaticRuntimes.push_back("memprof_cxx"); 851 } 852 853 if (!SanArgs.needsSharedRt() && SanArgs.needsHwasanRt() && SanArgs.linkRuntimes()) { 854 if (SanArgs.needsHwasanAliasesRt()) { 855 StaticRuntimes.push_back("hwasan_aliases"); 856 if (SanArgs.linkCXXRuntimes()) 857 StaticRuntimes.push_back("hwasan_aliases_cxx"); 858 } else { 859 StaticRuntimes.push_back("hwasan"); 860 if (SanArgs.linkCXXRuntimes()) 861 StaticRuntimes.push_back("hwasan_cxx"); 862 } 863 } 864 if (SanArgs.needsDfsanRt() && SanArgs.linkRuntimes()) 865 StaticRuntimes.push_back("dfsan"); 866 if (SanArgs.needsLsanRt() && SanArgs.linkRuntimes()) 867 StaticRuntimes.push_back("lsan"); 868 if (SanArgs.needsMsanRt() && SanArgs.linkRuntimes()) { 869 StaticRuntimes.push_back("msan"); 870 if (SanArgs.linkCXXRuntimes()) 871 StaticRuntimes.push_back("msan_cxx"); 872 } 873 if (!SanArgs.needsSharedRt() && SanArgs.needsTsanRt() && 874 SanArgs.linkRuntimes()) { 875 StaticRuntimes.push_back("tsan"); 876 if (SanArgs.linkCXXRuntimes()) 877 StaticRuntimes.push_back("tsan_cxx"); 878 } 879 if (!SanArgs.needsSharedRt() && SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) { 880 if (SanArgs.requiresMinimalRuntime()) { 881 StaticRuntimes.push_back("ubsan_minimal"); 882 } else { 883 StaticRuntimes.push_back("ubsan_standalone"); 884 if (SanArgs.linkCXXRuntimes()) 885 StaticRuntimes.push_back("ubsan_standalone_cxx"); 886 } 887 } 888 if (SanArgs.needsSafeStackRt() && SanArgs.linkRuntimes()) { 889 NonWholeStaticRuntimes.push_back("safestack"); 890 RequiredSymbols.push_back("__safestack_init"); 891 } 892 if (!(SanArgs.needsSharedRt() && SanArgs.needsUbsanRt() && SanArgs.linkRuntimes())) { 893 if (SanArgs.needsCfiRt() && SanArgs.linkRuntimes()) 894 StaticRuntimes.push_back("cfi"); 895 if (SanArgs.needsCfiDiagRt() && SanArgs.linkRuntimes()) { 896 StaticRuntimes.push_back("cfi_diag"); 897 if (SanArgs.linkCXXRuntimes()) 898 StaticRuntimes.push_back("ubsan_standalone_cxx"); 899 } 900 } 901 if (SanArgs.needsStatsRt() && SanArgs.linkRuntimes()) { 902 NonWholeStaticRuntimes.push_back("stats"); 903 RequiredSymbols.push_back("__sanitizer_stats_register"); 904 } 905 if (!SanArgs.needsSharedRt() && SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) { 906 if (SanArgs.requiresMinimalRuntime()) { 907 StaticRuntimes.push_back("scudo_minimal"); 908 if (SanArgs.linkCXXRuntimes()) 909 StaticRuntimes.push_back("scudo_cxx_minimal"); 910 } else { 911 StaticRuntimes.push_back("scudo"); 912 if (SanArgs.linkCXXRuntimes()) 913 StaticRuntimes.push_back("scudo_cxx"); 914 } 915 } 916 } 917 918 // Should be called before we add system libraries (C++ ABI, libstdc++/libc++, 919 // C runtime, etc). Returns true if sanitizer system deps need to be linked in. 920 bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, 921 ArgStringList &CmdArgs) { 922 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes, 923 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols; 924 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes, 925 NonWholeStaticRuntimes, HelperStaticRuntimes, 926 RequiredSymbols); 927 928 const SanitizerArgs &SanArgs = TC.getSanitizerArgs(); 929 // Inject libfuzzer dependencies. 930 if (SanArgs.needsFuzzer() && SanArgs.linkRuntimes() && 931 !Args.hasArg(options::OPT_shared)) { 932 933 addSanitizerRuntime(TC, Args, CmdArgs, "fuzzer", false, true); 934 if (SanArgs.needsFuzzerInterceptors()) 935 addSanitizerRuntime(TC, Args, CmdArgs, "fuzzer_interceptors", false, 936 true); 937 if (!Args.hasArg(clang::driver::options::OPT_nostdlibxx)) { 938 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 939 !Args.hasArg(options::OPT_static); 940 if (OnlyLibstdcxxStatic) 941 CmdArgs.push_back("-Bstatic"); 942 TC.AddCXXStdlibLibArgs(Args, CmdArgs); 943 if (OnlyLibstdcxxStatic) 944 CmdArgs.push_back("-Bdynamic"); 945 } 946 } 947 948 for (auto RT : SharedRuntimes) 949 addSanitizerRuntime(TC, Args, CmdArgs, RT, true, false); 950 for (auto RT : HelperStaticRuntimes) 951 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true); 952 bool AddExportDynamic = false; 953 for (auto RT : StaticRuntimes) { 954 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true); 955 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT); 956 } 957 for (auto RT : NonWholeStaticRuntimes) { 958 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, false); 959 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT); 960 } 961 for (auto S : RequiredSymbols) { 962 CmdArgs.push_back("-u"); 963 CmdArgs.push_back(Args.MakeArgString(S)); 964 } 965 // If there is a static runtime with no dynamic list, force all the symbols 966 // to be dynamic to be sure we export sanitizer interface functions. 967 if (AddExportDynamic) 968 CmdArgs.push_back("--export-dynamic"); 969 970 if (SanArgs.hasCrossDsoCfi() && !AddExportDynamic) 971 CmdArgs.push_back("--export-dynamic-symbol=__cfi_check"); 972 973 return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty(); 974 } 975 976 bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) { 977 if (Args.hasArg(options::OPT_shared)) 978 return false; 979 980 if (TC.getXRayArgs().needsXRayRt()) { 981 CmdArgs.push_back("-whole-archive"); 982 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray")); 983 for (const auto &Mode : TC.getXRayArgs().modeList()) 984 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Mode)); 985 CmdArgs.push_back("-no-whole-archive"); 986 return true; 987 } 988 989 return false; 990 } 991 992 void tools::linkXRayRuntimeDeps(const ToolChain &TC, ArgStringList &CmdArgs) { 993 CmdArgs.push_back(getAsNeededOption(TC, false)); 994 CmdArgs.push_back("-lpthread"); 995 if (!TC.getTriple().isOSOpenBSD()) 996 CmdArgs.push_back("-lrt"); 997 CmdArgs.push_back("-lm"); 998 999 if (!TC.getTriple().isOSFreeBSD() && 1000 !TC.getTriple().isOSNetBSD() && 1001 !TC.getTriple().isOSOpenBSD()) 1002 CmdArgs.push_back("-ldl"); 1003 } 1004 1005 bool tools::areOptimizationsEnabled(const ArgList &Args) { 1006 // Find the last -O arg and see if it is non-zero. 1007 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1008 return !A->getOption().matches(options::OPT_O0); 1009 // Defaults to -O0. 1010 return false; 1011 } 1012 1013 const char *tools::SplitDebugName(const JobAction &JA, const ArgList &Args, 1014 const InputInfo &Input, 1015 const InputInfo &Output) { 1016 auto AddPostfix = [JA](auto &F) { 1017 if (JA.getOffloadingDeviceKind() == Action::OFK_HIP) 1018 F += (Twine("_") + JA.getOffloadingArch()).str(); 1019 F += ".dwo"; 1020 }; 1021 if (Arg *A = Args.getLastArg(options::OPT_gsplit_dwarf_EQ)) 1022 if (StringRef(A->getValue()) == "single") 1023 return Args.MakeArgString(Output.getFilename()); 1024 1025 Arg *FinalOutput = Args.getLastArg(options::OPT_o); 1026 if (FinalOutput && Args.hasArg(options::OPT_c)) { 1027 SmallString<128> T(FinalOutput->getValue()); 1028 llvm::sys::path::remove_filename(T); 1029 llvm::sys::path::append(T, llvm::sys::path::stem(FinalOutput->getValue())); 1030 AddPostfix(T); 1031 return Args.MakeArgString(T); 1032 } else { 1033 // Use the compilation dir. 1034 Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ, 1035 options::OPT_fdebug_compilation_dir_EQ); 1036 SmallString<128> T(A ? A->getValue() : ""); 1037 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput())); 1038 AddPostfix(F); 1039 T += F; 1040 return Args.MakeArgString(T); 1041 } 1042 } 1043 1044 void tools::SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T, 1045 const JobAction &JA, const ArgList &Args, 1046 const InputInfo &Output, const char *OutFile) { 1047 ArgStringList ExtractArgs; 1048 ExtractArgs.push_back("--extract-dwo"); 1049 1050 ArgStringList StripArgs; 1051 StripArgs.push_back("--strip-dwo"); 1052 1053 // Grabbing the output of the earlier compile step. 1054 StripArgs.push_back(Output.getFilename()); 1055 ExtractArgs.push_back(Output.getFilename()); 1056 ExtractArgs.push_back(OutFile); 1057 1058 const char *Exec = 1059 Args.MakeArgString(TC.GetProgramPath(CLANG_DEFAULT_OBJCOPY)); 1060 InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename()); 1061 1062 // First extract the dwo sections. 1063 C.addCommand(std::make_unique<Command>(JA, T, 1064 ResponseFileSupport::AtFileCurCP(), 1065 Exec, ExtractArgs, II, Output)); 1066 1067 // Then remove them from the original .o file. 1068 C.addCommand(std::make_unique<Command>( 1069 JA, T, ResponseFileSupport::AtFileCurCP(), Exec, StripArgs, II, Output)); 1070 } 1071 1072 // Claim options we don't want to warn if they are unused. We do this for 1073 // options that build systems might add but are unused when assembling or only 1074 // running the preprocessor for example. 1075 void tools::claimNoWarnArgs(const ArgList &Args) { 1076 // Don't warn about unused -f(no-)?lto. This can happen when we're 1077 // preprocessing, precompiling or assembling. 1078 Args.ClaimAllArgs(options::OPT_flto_EQ); 1079 Args.ClaimAllArgs(options::OPT_flto); 1080 Args.ClaimAllArgs(options::OPT_fno_lto); 1081 } 1082 1083 Arg *tools::getLastProfileUseArg(const ArgList &Args) { 1084 auto *ProfileUseArg = Args.getLastArg( 1085 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ, 1086 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ, 1087 options::OPT_fno_profile_instr_use); 1088 1089 if (ProfileUseArg && 1090 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use)) 1091 ProfileUseArg = nullptr; 1092 1093 return ProfileUseArg; 1094 } 1095 1096 Arg *tools::getLastProfileSampleUseArg(const ArgList &Args) { 1097 auto *ProfileSampleUseArg = Args.getLastArg( 1098 options::OPT_fprofile_sample_use, options::OPT_fprofile_sample_use_EQ, 1099 options::OPT_fauto_profile, options::OPT_fauto_profile_EQ, 1100 options::OPT_fno_profile_sample_use, options::OPT_fno_auto_profile); 1101 1102 if (ProfileSampleUseArg && 1103 (ProfileSampleUseArg->getOption().matches( 1104 options::OPT_fno_profile_sample_use) || 1105 ProfileSampleUseArg->getOption().matches(options::OPT_fno_auto_profile))) 1106 return nullptr; 1107 1108 return Args.getLastArg(options::OPT_fprofile_sample_use_EQ, 1109 options::OPT_fauto_profile_EQ); 1110 } 1111 1112 /// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then, 1113 /// smooshes them together with platform defaults, to decide whether 1114 /// this compile should be using PIC mode or not. Returns a tuple of 1115 /// (RelocationModel, PICLevel, IsPIE). 1116 std::tuple<llvm::Reloc::Model, unsigned, bool> 1117 tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) { 1118 const llvm::Triple &EffectiveTriple = ToolChain.getEffectiveTriple(); 1119 const llvm::Triple &Triple = ToolChain.getTriple(); 1120 1121 bool PIE = ToolChain.isPIEDefault(); 1122 bool PIC = PIE || ToolChain.isPICDefault(); 1123 // The Darwin/MachO default to use PIC does not apply when using -static. 1124 if (Triple.isOSBinFormatMachO() && Args.hasArg(options::OPT_static)) 1125 PIE = PIC = false; 1126 bool IsPICLevelTwo = PIC; 1127 1128 bool KernelOrKext = 1129 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext); 1130 1131 // Android-specific defaults for PIC/PIE 1132 if (Triple.isAndroid()) { 1133 switch (Triple.getArch()) { 1134 case llvm::Triple::arm: 1135 case llvm::Triple::armeb: 1136 case llvm::Triple::thumb: 1137 case llvm::Triple::thumbeb: 1138 case llvm::Triple::aarch64: 1139 case llvm::Triple::mips: 1140 case llvm::Triple::mipsel: 1141 case llvm::Triple::mips64: 1142 case llvm::Triple::mips64el: 1143 PIC = true; // "-fpic" 1144 break; 1145 1146 case llvm::Triple::x86: 1147 case llvm::Triple::x86_64: 1148 PIC = true; // "-fPIC" 1149 IsPICLevelTwo = true; 1150 break; 1151 1152 default: 1153 break; 1154 } 1155 } 1156 1157 // OpenBSD-specific defaults for PIE 1158 if (Triple.isOSOpenBSD()) { 1159 switch (ToolChain.getArch()) { 1160 case llvm::Triple::arm: 1161 case llvm::Triple::aarch64: 1162 case llvm::Triple::mips64: 1163 case llvm::Triple::mips64el: 1164 case llvm::Triple::x86: 1165 case llvm::Triple::x86_64: 1166 IsPICLevelTwo = false; // "-fpie" 1167 break; 1168 1169 case llvm::Triple::ppc: 1170 case llvm::Triple::sparcv9: 1171 IsPICLevelTwo = true; // "-fPIE" 1172 break; 1173 1174 default: 1175 break; 1176 } 1177 } 1178 1179 // AMDGPU-specific defaults for PIC. 1180 if (Triple.getArch() == llvm::Triple::amdgcn) 1181 PIC = true; 1182 1183 // The last argument relating to either PIC or PIE wins, and no 1184 // other argument is used. If the last argument is any flavor of the 1185 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE 1186 // option implicitly enables PIC at the same level. 1187 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 1188 options::OPT_fpic, options::OPT_fno_pic, 1189 options::OPT_fPIE, options::OPT_fno_PIE, 1190 options::OPT_fpie, options::OPT_fno_pie); 1191 if (Triple.isOSWindows() && LastPICArg && 1192 LastPICArg == 1193 Args.getLastArg(options::OPT_fPIC, options::OPT_fpic, 1194 options::OPT_fPIE, options::OPT_fpie)) { 1195 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) 1196 << LastPICArg->getSpelling() << Triple.str(); 1197 if (Triple.getArch() == llvm::Triple::x86_64) 1198 return std::make_tuple(llvm::Reloc::PIC_, 2U, false); 1199 return std::make_tuple(llvm::Reloc::Static, 0U, false); 1200 } 1201 1202 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness 1203 // is forced, then neither PIC nor PIE flags will have no effect. 1204 if (!ToolChain.isPICDefaultForced()) { 1205 if (LastPICArg) { 1206 Option O = LastPICArg->getOption(); 1207 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) || 1208 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) { 1209 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie); 1210 PIC = 1211 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic); 1212 IsPICLevelTwo = 1213 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC); 1214 } else { 1215 PIE = PIC = false; 1216 if (EffectiveTriple.isPS4CPU()) { 1217 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ); 1218 StringRef Model = ModelArg ? ModelArg->getValue() : ""; 1219 if (Model != "kernel") { 1220 PIC = true; 1221 ToolChain.getDriver().Diag(diag::warn_drv_ps4_force_pic) 1222 << LastPICArg->getSpelling(); 1223 } 1224 } 1225 } 1226 } 1227 } 1228 1229 // Introduce a Darwin and PS4-specific hack. If the default is PIC, but the 1230 // PIC level would've been set to level 1, force it back to level 2 PIC 1231 // instead. 1232 if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS4CPU())) 1233 IsPICLevelTwo |= ToolChain.isPICDefault(); 1234 1235 // This kernel flags are a trump-card: they will disable PIC/PIE 1236 // generation, independent of the argument order. 1237 if (KernelOrKext && 1238 ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) && 1239 !EffectiveTriple.isWatchOS())) 1240 PIC = PIE = false; 1241 1242 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) { 1243 // This is a very special mode. It trumps the other modes, almost no one 1244 // uses it, and it isn't even valid on any OS but Darwin. 1245 if (!Triple.isOSDarwin()) 1246 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) 1247 << A->getSpelling() << Triple.str(); 1248 1249 // FIXME: Warn when this flag trumps some other PIC or PIE flag. 1250 1251 // Only a forced PIC mode can cause the actual compile to have PIC defines 1252 // etc., no flags are sufficient. This behavior was selected to closely 1253 // match that of llvm-gcc and Apple GCC before that. 1254 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced(); 1255 1256 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0U, false); 1257 } 1258 1259 bool EmbeddedPISupported; 1260 switch (Triple.getArch()) { 1261 case llvm::Triple::arm: 1262 case llvm::Triple::armeb: 1263 case llvm::Triple::thumb: 1264 case llvm::Triple::thumbeb: 1265 EmbeddedPISupported = true; 1266 break; 1267 default: 1268 EmbeddedPISupported = false; 1269 break; 1270 } 1271 1272 bool ROPI = false, RWPI = false; 1273 Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi); 1274 if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) { 1275 if (!EmbeddedPISupported) 1276 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) 1277 << LastROPIArg->getSpelling() << Triple.str(); 1278 ROPI = true; 1279 } 1280 Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi); 1281 if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) { 1282 if (!EmbeddedPISupported) 1283 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) 1284 << LastRWPIArg->getSpelling() << Triple.str(); 1285 RWPI = true; 1286 } 1287 1288 // ROPI and RWPI are not compatible with PIC or PIE. 1289 if ((ROPI || RWPI) && (PIC || PIE)) 1290 ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic); 1291 1292 if (Triple.isMIPS()) { 1293 StringRef CPUName; 1294 StringRef ABIName; 1295 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 1296 // When targeting the N64 ABI, PIC is the default, except in the case 1297 // when the -mno-abicalls option is used. In that case we exit 1298 // at next check regardless of PIC being set below. 1299 if (ABIName == "n64") 1300 PIC = true; 1301 // When targettng MIPS with -mno-abicalls, it's always static. 1302 if(Args.hasArg(options::OPT_mno_abicalls)) 1303 return std::make_tuple(llvm::Reloc::Static, 0U, false); 1304 // Unlike other architectures, MIPS, even with -fPIC/-mxgot/multigot, 1305 // does not use PIC level 2 for historical reasons. 1306 IsPICLevelTwo = false; 1307 } 1308 1309 if (PIC) 1310 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE); 1311 1312 llvm::Reloc::Model RelocM = llvm::Reloc::Static; 1313 if (ROPI && RWPI) 1314 RelocM = llvm::Reloc::ROPI_RWPI; 1315 else if (ROPI) 1316 RelocM = llvm::Reloc::ROPI; 1317 else if (RWPI) 1318 RelocM = llvm::Reloc::RWPI; 1319 1320 return std::make_tuple(RelocM, 0U, false); 1321 } 1322 1323 // `-falign-functions` indicates that the functions should be aligned to a 1324 // 16-byte boundary. 1325 // 1326 // `-falign-functions=1` is the same as `-fno-align-functions`. 1327 // 1328 // The scalar `n` in `-falign-functions=n` must be an integral value between 1329 // [0, 65536]. If the value is not a power-of-two, it will be rounded up to 1330 // the nearest power-of-two. 1331 // 1332 // If we return `0`, the frontend will default to the backend's preferred 1333 // alignment. 1334 // 1335 // NOTE: icc only allows values between [0, 4096]. icc uses `-falign-functions` 1336 // to mean `-falign-functions=16`. GCC defaults to the backend's preferred 1337 // alignment. For unaligned functions, we default to the backend's preferred 1338 // alignment. 1339 unsigned tools::ParseFunctionAlignment(const ToolChain &TC, 1340 const ArgList &Args) { 1341 const Arg *A = Args.getLastArg(options::OPT_falign_functions, 1342 options::OPT_falign_functions_EQ, 1343 options::OPT_fno_align_functions); 1344 if (!A || A->getOption().matches(options::OPT_fno_align_functions)) 1345 return 0; 1346 1347 if (A->getOption().matches(options::OPT_falign_functions)) 1348 return 0; 1349 1350 unsigned Value = 0; 1351 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 65536) 1352 TC.getDriver().Diag(diag::err_drv_invalid_int_value) 1353 << A->getAsString(Args) << A->getValue(); 1354 return Value ? llvm::Log2_32_Ceil(std::min(Value, 65536u)) : Value; 1355 } 1356 1357 unsigned tools::ParseDebugDefaultVersion(const ToolChain &TC, 1358 const ArgList &Args) { 1359 const Arg *A = Args.getLastArg(options::OPT_fdebug_default_version); 1360 1361 if (!A) 1362 return 0; 1363 1364 unsigned Value = 0; 1365 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 5 || 1366 Value < 2) 1367 TC.getDriver().Diag(diag::err_drv_invalid_int_value) 1368 << A->getAsString(Args) << A->getValue(); 1369 return Value; 1370 } 1371 1372 void tools::AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args, 1373 ArgStringList &CmdArgs) { 1374 llvm::Reloc::Model RelocationModel; 1375 unsigned PICLevel; 1376 bool IsPIE; 1377 std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(ToolChain, Args); 1378 1379 if (RelocationModel != llvm::Reloc::Static) 1380 CmdArgs.push_back("-KPIC"); 1381 } 1382 1383 /// Determine whether Objective-C automated reference counting is 1384 /// enabled. 1385 bool tools::isObjCAutoRefCount(const ArgList &Args) { 1386 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false); 1387 } 1388 1389 enum class LibGccType { UnspecifiedLibGcc, StaticLibGcc, SharedLibGcc }; 1390 1391 static LibGccType getLibGccType(const ToolChain &TC, const Driver &D, 1392 const ArgList &Args) { 1393 if (Args.hasArg(options::OPT_static_libgcc) || 1394 Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie)) 1395 return LibGccType::StaticLibGcc; 1396 if (Args.hasArg(options::OPT_shared_libgcc)) 1397 return LibGccType::SharedLibGcc; 1398 // The Android NDK only provides libunwind.a, not libunwind.so. 1399 if (TC.getTriple().isAndroid()) 1400 return LibGccType::StaticLibGcc; 1401 // For MinGW, don't imply a shared libgcc here, we only want to return 1402 // SharedLibGcc if that was explicitly requested. 1403 if (D.CCCIsCXX() && !TC.getTriple().isOSCygMing()) 1404 return LibGccType::SharedLibGcc; 1405 return LibGccType::UnspecifiedLibGcc; 1406 } 1407 1408 // Gcc adds libgcc arguments in various ways: 1409 // 1410 // gcc <none>: -lgcc --as-needed -lgcc_s --no-as-needed 1411 // g++ <none>: -lgcc_s -lgcc 1412 // gcc shared: -lgcc_s -lgcc 1413 // g++ shared: -lgcc_s -lgcc 1414 // gcc static: -lgcc -lgcc_eh 1415 // g++ static: -lgcc -lgcc_eh 1416 // gcc static-pie: -lgcc -lgcc_eh 1417 // g++ static-pie: -lgcc -lgcc_eh 1418 // 1419 // Also, certain targets need additional adjustments. 1420 1421 static void AddUnwindLibrary(const ToolChain &TC, const Driver &D, 1422 ArgStringList &CmdArgs, const ArgList &Args) { 1423 ToolChain::UnwindLibType UNW = TC.GetUnwindLibType(Args); 1424 // Targets that don't use unwind libraries. 1425 if ((TC.getTriple().isAndroid() && UNW == ToolChain::UNW_Libgcc) || 1426 TC.getTriple().isOSIAMCU() || TC.getTriple().isOSBinFormatWasm() || 1427 UNW == ToolChain::UNW_None) 1428 return; 1429 1430 LibGccType LGT = getLibGccType(TC, D, Args); 1431 bool AsNeeded = LGT == LibGccType::UnspecifiedLibGcc && 1432 !TC.getTriple().isAndroid() && !TC.getTriple().isOSCygMing(); 1433 if (AsNeeded) 1434 CmdArgs.push_back(getAsNeededOption(TC, true)); 1435 1436 switch (UNW) { 1437 case ToolChain::UNW_None: 1438 return; 1439 case ToolChain::UNW_Libgcc: { 1440 if (LGT == LibGccType::StaticLibGcc) 1441 CmdArgs.push_back("-lgcc_eh"); 1442 else 1443 CmdArgs.push_back("-lgcc_s"); 1444 break; 1445 } 1446 case ToolChain::UNW_CompilerRT: 1447 if (LGT == LibGccType::StaticLibGcc) 1448 CmdArgs.push_back("-l:libunwind.a"); 1449 else if (TC.getTriple().isOSCygMing()) { 1450 if (LGT == LibGccType::SharedLibGcc) 1451 CmdArgs.push_back("-l:libunwind.dll.a"); 1452 else 1453 // Let the linker choose between libunwind.dll.a and libunwind.a 1454 // depending on what's available, and depending on the -static flag 1455 CmdArgs.push_back("-lunwind"); 1456 } else 1457 CmdArgs.push_back("-l:libunwind.so"); 1458 break; 1459 } 1460 1461 if (AsNeeded) 1462 CmdArgs.push_back(getAsNeededOption(TC, false)); 1463 } 1464 1465 static void AddLibgcc(const ToolChain &TC, const Driver &D, 1466 ArgStringList &CmdArgs, const ArgList &Args) { 1467 LibGccType LGT = getLibGccType(TC, D, Args); 1468 if (LGT != LibGccType::SharedLibGcc) 1469 CmdArgs.push_back("-lgcc"); 1470 AddUnwindLibrary(TC, D, CmdArgs, Args); 1471 if (LGT == LibGccType::SharedLibGcc) 1472 CmdArgs.push_back("-lgcc"); 1473 } 1474 1475 void tools::AddRunTimeLibs(const ToolChain &TC, const Driver &D, 1476 ArgStringList &CmdArgs, const ArgList &Args) { 1477 // Make use of compiler-rt if --rtlib option is used 1478 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args); 1479 1480 switch (RLT) { 1481 case ToolChain::RLT_CompilerRT: 1482 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins")); 1483 AddUnwindLibrary(TC, D, CmdArgs, Args); 1484 break; 1485 case ToolChain::RLT_Libgcc: 1486 // Make sure libgcc is not used under MSVC environment by default 1487 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) { 1488 // Issue error diagnostic if libgcc is explicitly specified 1489 // through command line as --rtlib option argument. 1490 if (Args.hasArg(options::OPT_rtlib_EQ)) { 1491 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform) 1492 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "MSVC"; 1493 } 1494 } else 1495 AddLibgcc(TC, D, CmdArgs, Args); 1496 break; 1497 } 1498 1499 // On Android, the unwinder uses dl_iterate_phdr (or one of 1500 // dl_unwind_find_exidx/__gnu_Unwind_Find_exidx on arm32) from libdl.so. For 1501 // statically-linked executables, these functions come from libc.a instead. 1502 if (TC.getTriple().isAndroid() && !Args.hasArg(options::OPT_static) && 1503 !Args.hasArg(options::OPT_static_pie)) 1504 CmdArgs.push_back("-ldl"); 1505 } 1506 1507 SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args, 1508 const InputInfo &Output, 1509 const InputInfo &Input, 1510 const Driver &D) { 1511 const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ); 1512 if (!A) 1513 return {}; 1514 1515 StringRef SaveStats = A->getValue(); 1516 SmallString<128> StatsFile; 1517 if (SaveStats == "obj" && Output.isFilename()) { 1518 StatsFile.assign(Output.getFilename()); 1519 llvm::sys::path::remove_filename(StatsFile); 1520 } else if (SaveStats != "cwd") { 1521 D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats; 1522 return {}; 1523 } 1524 1525 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput()); 1526 llvm::sys::path::append(StatsFile, BaseName); 1527 llvm::sys::path::replace_extension(StatsFile, "stats"); 1528 return StatsFile; 1529 } 1530 1531 void tools::addMultilibFlag(bool Enabled, const char *const Flag, 1532 Multilib::flags_list &Flags) { 1533 Flags.push_back(std::string(Enabled ? "+" : "-") + Flag); 1534 } 1535 1536 void tools::addX86AlignBranchArgs(const Driver &D, const ArgList &Args, 1537 ArgStringList &CmdArgs, bool IsLTO) { 1538 auto addArg = [&, IsLTO](const Twine &Arg) { 1539 if (IsLTO) { 1540 CmdArgs.push_back(Args.MakeArgString("-plugin-opt=" + Arg)); 1541 } else { 1542 CmdArgs.push_back("-mllvm"); 1543 CmdArgs.push_back(Args.MakeArgString(Arg)); 1544 } 1545 }; 1546 1547 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) { 1548 addArg(Twine("-x86-branches-within-32B-boundaries")); 1549 } 1550 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) { 1551 StringRef Value = A->getValue(); 1552 unsigned Boundary; 1553 if (Value.getAsInteger(10, Boundary) || Boundary < 16 || 1554 !llvm::isPowerOf2_64(Boundary)) { 1555 D.Diag(diag::err_drv_invalid_argument_to_option) 1556 << Value << A->getOption().getName(); 1557 } else { 1558 addArg("-x86-align-branch-boundary=" + Twine(Boundary)); 1559 } 1560 } 1561 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) { 1562 std::string AlignBranch; 1563 for (StringRef T : A->getValues()) { 1564 if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" && 1565 T != "ret" && T != "indirect") 1566 D.Diag(diag::err_drv_invalid_malign_branch_EQ) 1567 << T << "fused, jcc, jmp, call, ret, indirect"; 1568 if (!AlignBranch.empty()) 1569 AlignBranch += '+'; 1570 AlignBranch += T; 1571 } 1572 addArg("-x86-align-branch=" + Twine(AlignBranch)); 1573 } 1574 if (const Arg *A = Args.getLastArg(options::OPT_mpad_max_prefix_size_EQ)) { 1575 StringRef Value = A->getValue(); 1576 unsigned PrefixSize; 1577 if (Value.getAsInteger(10, PrefixSize)) { 1578 D.Diag(diag::err_drv_invalid_argument_to_option) 1579 << Value << A->getOption().getName(); 1580 } else { 1581 addArg("-x86-pad-max-prefix-size=" + Twine(PrefixSize)); 1582 } 1583 } 1584 } 1585 1586 static llvm::opt::Arg * 1587 getAMDGPUCodeObjectArgument(const Driver &D, const llvm::opt::ArgList &Args) { 1588 // The last of -mcode-object-v3, -mno-code-object-v3 and 1589 // -mcode-object-version=<version> wins. 1590 return Args.getLastArg(options::OPT_mcode_object_v3_legacy, 1591 options::OPT_mno_code_object_v3_legacy, 1592 options::OPT_mcode_object_version_EQ); 1593 } 1594 1595 void tools::checkAMDGPUCodeObjectVersion(const Driver &D, 1596 const llvm::opt::ArgList &Args) { 1597 const unsigned MinCodeObjVer = 2; 1598 const unsigned MaxCodeObjVer = 4; 1599 1600 // Emit warnings for legacy options even if they are overridden. 1601 if (Args.hasArg(options::OPT_mno_code_object_v3_legacy)) 1602 D.Diag(diag::warn_drv_deprecated_arg) << "-mno-code-object-v3" 1603 << "-mcode-object-version=2"; 1604 1605 if (Args.hasArg(options::OPT_mcode_object_v3_legacy)) 1606 D.Diag(diag::warn_drv_deprecated_arg) << "-mcode-object-v3" 1607 << "-mcode-object-version=3"; 1608 1609 if (auto *CodeObjArg = getAMDGPUCodeObjectArgument(D, Args)) { 1610 if (CodeObjArg->getOption().getID() == 1611 options::OPT_mcode_object_version_EQ) { 1612 unsigned CodeObjVer = MaxCodeObjVer; 1613 auto Remnant = 1614 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer); 1615 if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer) 1616 D.Diag(diag::err_drv_invalid_int_value) 1617 << CodeObjArg->getAsString(Args) << CodeObjArg->getValue(); 1618 } 1619 } 1620 } 1621 1622 unsigned tools::getAMDGPUCodeObjectVersion(const Driver &D, 1623 const llvm::opt::ArgList &Args) { 1624 unsigned CodeObjVer = 4; // default 1625 if (auto *CodeObjArg = getAMDGPUCodeObjectArgument(D, Args)) { 1626 if (CodeObjArg->getOption().getID() == 1627 options::OPT_mno_code_object_v3_legacy) { 1628 CodeObjVer = 2; 1629 } else if (CodeObjArg->getOption().getID() == 1630 options::OPT_mcode_object_v3_legacy) { 1631 CodeObjVer = 3; 1632 } else { 1633 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer); 1634 } 1635 } 1636 return CodeObjVer; 1637 } 1638 1639 bool tools::haveAMDGPUCodeObjectVersionArgument( 1640 const Driver &D, const llvm::opt::ArgList &Args) { 1641 return getAMDGPUCodeObjectArgument(D, Args) != nullptr; 1642 } 1643 1644 void tools::addMachineOutlinerArgs(const Driver &D, 1645 const llvm::opt::ArgList &Args, 1646 llvm::opt::ArgStringList &CmdArgs, 1647 const llvm::Triple &Triple, bool IsLTO) { 1648 auto addArg = [&, IsLTO](const Twine &Arg) { 1649 if (IsLTO) { 1650 CmdArgs.push_back(Args.MakeArgString("-plugin-opt=" + Arg)); 1651 } else { 1652 CmdArgs.push_back("-mllvm"); 1653 CmdArgs.push_back(Args.MakeArgString(Arg)); 1654 } 1655 }; 1656 1657 if (Arg *A = Args.getLastArg(options::OPT_moutline, 1658 options::OPT_mno_outline)) { 1659 if (A->getOption().matches(options::OPT_moutline)) { 1660 // We only support -moutline in AArch64 and ARM targets right now. If 1661 // we're not compiling for these, emit a warning and ignore the flag. 1662 // Otherwise, add the proper mllvm flags. 1663 if (!(Triple.isARM() || Triple.isThumb() || 1664 Triple.getArch() == llvm::Triple::aarch64 || 1665 Triple.getArch() == llvm::Triple::aarch64_32)) { 1666 D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName(); 1667 } else { 1668 addArg(Twine("-enable-machine-outliner")); 1669 } 1670 } else { 1671 // Disable all outlining behaviour. 1672 addArg(Twine("-enable-machine-outliner=never")); 1673 } 1674 } 1675 } 1676 1677 void tools::addOpenMPDeviceRTL(const Driver &D, 1678 const llvm::opt::ArgList &DriverArgs, 1679 llvm::opt::ArgStringList &CC1Args, 1680 StringRef BitcodeSuffix, 1681 const llvm::Triple &Triple) { 1682 SmallVector<StringRef, 8> LibraryPaths; 1683 // Add user defined library paths from LIBRARY_PATH. 1684 llvm::Optional<std::string> LibPath = 1685 llvm::sys::Process::GetEnv("LIBRARY_PATH"); 1686 if (LibPath) { 1687 SmallVector<StringRef, 8> Frags; 1688 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'}; 1689 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr); 1690 for (StringRef Path : Frags) 1691 LibraryPaths.emplace_back(Path.trim()); 1692 } 1693 1694 // Add path to lib / lib64 folder. 1695 SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(D.Dir); 1696 llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX); 1697 LibraryPaths.emplace_back(DefaultLibPath.c_str()); 1698 1699 OptSpecifier LibomptargetBCPathOpt = 1700 Triple.isAMDGCN() ? options::OPT_libomptarget_amdgcn_bc_path_EQ 1701 : options::OPT_libomptarget_nvptx_bc_path_EQ; 1702 1703 StringRef ArchPrefix = Triple.isAMDGCN() ? "amdgcn" : "nvptx"; 1704 // First check whether user specifies bc library 1705 if (const Arg *A = DriverArgs.getLastArg(LibomptargetBCPathOpt)) { 1706 std::string LibOmpTargetName(A->getValue()); 1707 if (llvm::sys::fs::exists(LibOmpTargetName)) { 1708 CC1Args.push_back("-mlink-builtin-bitcode"); 1709 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetName)); 1710 } else { 1711 D.Diag(diag::err_drv_omp_offload_target_bcruntime_not_found) 1712 << LibOmpTargetName; 1713 } 1714 } else { 1715 bool FoundBCLibrary = false; 1716 1717 std::string LibOmpTargetName = 1718 "libomptarget-" + BitcodeSuffix.str() + ".bc"; 1719 1720 for (StringRef LibraryPath : LibraryPaths) { 1721 SmallString<128> LibOmpTargetFile(LibraryPath); 1722 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName); 1723 if (llvm::sys::fs::exists(LibOmpTargetFile)) { 1724 CC1Args.push_back("-mlink-builtin-bitcode"); 1725 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile)); 1726 FoundBCLibrary = true; 1727 break; 1728 } 1729 } 1730 1731 if (!FoundBCLibrary) 1732 D.Diag(diag::err_drv_omp_offload_target_missingbcruntime) 1733 << LibOmpTargetName << ArchPrefix; 1734 } 1735 } 1736
Indexes created Mon Jun 08 00:24:58 UTC 2026