1 //===--- Gnu.cpp - Gnu Tool and 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 "Gnu.h" 10 #include "Arch/ARM.h" 11 #include "Arch/CSKY.h" 12 #include "Arch/LoongArch.h" 13 #include "Arch/Mips.h" 14 #include "Arch/PPC.h" 15 #include "Arch/RISCV.h" 16 #include "Arch/Sparc.h" 17 #include "Arch/SystemZ.h" 18 #include "CommonArgs.h" 19 #include "Linux.h" 20 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX 21 #include "clang/Driver/Compilation.h" 22 #include "clang/Driver/Driver.h" 23 #include "clang/Driver/DriverDiagnostic.h" 24 #include "clang/Driver/MultilibBuilder.h" 25 #include "clang/Driver/Options.h" 26 #include "clang/Driver/Tool.h" 27 #include "clang/Driver/ToolChain.h" 28 #include "llvm/ADT/StringSet.h" 29 #include "llvm/ADT/Twine.h" 30 #include "llvm/Option/ArgList.h" 31 #include "llvm/Support/CodeGen.h" 32 #include "llvm/Support/Path.h" 33 #include "llvm/Support/VirtualFileSystem.h" 34 #include "llvm/TargetParser/TargetParser.h" 35 #include <system_error> 36 37 using namespace clang::driver; 38 using namespace clang::driver::toolchains; 39 using namespace clang; 40 using namespace llvm::opt; 41 42 using tools::addMultilibFlag; 43 using tools::addPathIfExists; 44 45 static bool forwardToGCC(const Option &O) { 46 // LinkerInput options have been forwarded. Don't duplicate. 47 if (O.hasFlag(options::LinkerInput)) 48 return false; 49 return O.matches(options::OPT_Link_Group) || O.hasFlag(options::LinkOption); 50 } 51 52 // Switch CPU names not recognized by GNU assembler to a close CPU that it does 53 // recognize, instead of a lower march from being picked in the absence of a cpu 54 // flag. 55 static void normalizeCPUNamesForAssembler(const ArgList &Args, 56 ArgStringList &CmdArgs) { 57 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 58 StringRef CPUArg(A->getValue()); 59 if (CPUArg.equals_insensitive("krait")) 60 CmdArgs.push_back("-mcpu=cortex-a15"); 61 else if (CPUArg.equals_insensitive("kryo")) 62 CmdArgs.push_back("-mcpu=cortex-a57"); 63 else 64 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 65 } 66 } 67 68 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 69 const InputInfo &Output, 70 const InputInfoList &Inputs, 71 const ArgList &Args, 72 const char *LinkingOutput) const { 73 const Driver &D = getToolChain().getDriver(); 74 ArgStringList CmdArgs; 75 76 for (const auto &A : Args) { 77 if (forwardToGCC(A->getOption())) { 78 // It is unfortunate that we have to claim here, as this means 79 // we will basically never report anything interesting for 80 // platforms using a generic gcc, even if we are just using gcc 81 // to get to the assembler. 82 A->claim(); 83 84 A->render(Args, CmdArgs); 85 } 86 } 87 88 RenderExtraToolArgs(JA, CmdArgs); 89 90 // If using a driver, force the arch. 91 if (getToolChain().getTriple().isOSDarwin()) { 92 CmdArgs.push_back("-arch"); 93 CmdArgs.push_back( 94 Args.MakeArgString(getToolChain().getDefaultUniversalArchName())); 95 } 96 97 // Try to force gcc to match the tool chain we want, if we recognize 98 // the arch. 99 // 100 // FIXME: The triple class should directly provide the information we want 101 // here. 102 switch (getToolChain().getArch()) { 103 default: 104 break; 105 case llvm::Triple::x86: 106 case llvm::Triple::ppc: 107 case llvm::Triple::ppcle: 108 CmdArgs.push_back("-m32"); 109 break; 110 case llvm::Triple::x86_64: 111 case llvm::Triple::ppc64: 112 case llvm::Triple::ppc64le: 113 CmdArgs.push_back("-m64"); 114 break; 115 case llvm::Triple::sparcel: 116 CmdArgs.push_back("-EL"); 117 break; 118 } 119 120 assert((Output.isFilename() || Output.isNothing()) && "Invalid output."); 121 if (Output.isFilename()) { 122 CmdArgs.push_back("-o"); 123 CmdArgs.push_back(Output.getFilename()); 124 } else { 125 CmdArgs.push_back("-fsyntax-only"); 126 } 127 128 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 129 130 // Only pass -x if gcc will understand it; otherwise hope gcc 131 // understands the suffix correctly. The main use case this would go 132 // wrong in is for linker inputs if they happened to have an odd 133 // suffix; really the only way to get this to happen is a command 134 // like '-x foobar a.c' which will treat a.c like a linker input. 135 // 136 // FIXME: For the linker case specifically, can we safely convert 137 // inputs into '-Wl,' options? 138 for (const auto &II : Inputs) { 139 // Don't try to pass LLVM or AST inputs to a generic gcc. 140 if (types::isLLVMIR(II.getType())) 141 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 142 << getToolChain().getTripleString(); 143 else if (II.getType() == types::TY_AST) 144 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString(); 145 else if (II.getType() == types::TY_ModuleFile) 146 D.Diag(diag::err_drv_no_module_support) 147 << getToolChain().getTripleString(); 148 149 if (types::canTypeBeUserSpecified(II.getType())) { 150 CmdArgs.push_back("-x"); 151 CmdArgs.push_back(types::getTypeName(II.getType())); 152 } 153 154 if (II.isFilename()) 155 CmdArgs.push_back(II.getFilename()); 156 else { 157 const Arg &A = II.getInputArg(); 158 159 // Reverse translate some rewritten options. 160 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 161 CmdArgs.push_back("-lstdc++"); 162 continue; 163 } 164 165 // Don't render as input, we need gcc to do the translations. 166 A.render(Args, CmdArgs); 167 } 168 } 169 170 const std::string &customGCCName = D.getCCCGenericGCCName(); 171 const char *GCCName; 172 if (!customGCCName.empty()) 173 GCCName = customGCCName.c_str(); 174 else if (D.CCCIsCXX()) { 175 GCCName = "g++"; 176 } else 177 GCCName = "gcc"; 178 179 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 180 C.addCommand(std::make_unique<Command>(JA, *this, 181 ResponseFileSupport::AtFileCurCP(), 182 Exec, CmdArgs, Inputs, Output)); 183 } 184 185 void tools::gcc::Preprocessor::RenderExtraToolArgs( 186 const JobAction &JA, ArgStringList &CmdArgs) const { 187 CmdArgs.push_back("-E"); 188 } 189 190 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA, 191 ArgStringList &CmdArgs) const { 192 const Driver &D = getToolChain().getDriver(); 193 194 switch (JA.getType()) { 195 // If -flto, etc. are present then make sure not to force assembly output. 196 case types::TY_LLVM_IR: 197 case types::TY_LTO_IR: 198 case types::TY_LLVM_BC: 199 case types::TY_LTO_BC: 200 CmdArgs.push_back("-c"); 201 break; 202 // We assume we've got an "integrated" assembler in that gcc will produce an 203 // object file itself. 204 case types::TY_Object: 205 CmdArgs.push_back("-c"); 206 break; 207 case types::TY_PP_Asm: 208 CmdArgs.push_back("-S"); 209 break; 210 case types::TY_Nothing: 211 CmdArgs.push_back("-fsyntax-only"); 212 break; 213 default: 214 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType()); 215 } 216 } 217 218 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA, 219 ArgStringList &CmdArgs) const { 220 // The types are (hopefully) good enough. 221 } 222 223 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) { 224 switch (T.getArch()) { 225 case llvm::Triple::x86: 226 if (T.isOSIAMCU()) 227 return "elf_iamcu"; 228 return "elf_i386"; 229 case llvm::Triple::aarch64: 230 return "aarch64linux"; 231 case llvm::Triple::aarch64_be: 232 return "aarch64linuxb"; 233 case llvm::Triple::arm: 234 case llvm::Triple::thumb: 235 case llvm::Triple::armeb: 236 case llvm::Triple::thumbeb: 237 return tools::arm::isARMBigEndian(T, Args) ? "armelfb_linux_eabi" 238 : "armelf_linux_eabi"; 239 case llvm::Triple::m68k: 240 return "m68kelf"; 241 case llvm::Triple::ppc: 242 if (T.isOSLinux()) 243 return "elf32ppclinux"; 244 return "elf32ppc"; 245 case llvm::Triple::ppcle: 246 if (T.isOSLinux()) 247 return "elf32lppclinux"; 248 return "elf32lppc"; 249 case llvm::Triple::ppc64: 250 return "elf64ppc"; 251 case llvm::Triple::ppc64le: 252 return "elf64lppc"; 253 case llvm::Triple::riscv32: 254 return "elf32lriscv"; 255 case llvm::Triple::riscv64: 256 return "elf64lriscv"; 257 case llvm::Triple::sparc: 258 case llvm::Triple::sparcel: 259 return "elf32_sparc"; 260 case llvm::Triple::sparcv9: 261 return "elf64_sparc"; 262 case llvm::Triple::loongarch32: 263 return "elf32loongarch"; 264 case llvm::Triple::loongarch64: 265 return "elf64loongarch"; 266 case llvm::Triple::mips: 267 return "elf32btsmip"; 268 case llvm::Triple::mipsel: 269 return "elf32ltsmip"; 270 case llvm::Triple::mips64: 271 if (tools::mips::hasMipsAbiArg(Args, "n32") || 272 T.getEnvironment() == llvm::Triple::GNUABIN32) 273 return "elf32btsmipn32"; 274 return "elf64btsmip"; 275 case llvm::Triple::mips64el: 276 if (tools::mips::hasMipsAbiArg(Args, "n32") || 277 T.getEnvironment() == llvm::Triple::GNUABIN32) 278 return "elf32ltsmipn32"; 279 return "elf64ltsmip"; 280 case llvm::Triple::systemz: 281 return "elf64_s390"; 282 case llvm::Triple::x86_64: 283 if (T.isX32()) 284 return "elf32_x86_64"; 285 return "elf_x86_64"; 286 case llvm::Triple::ve: 287 return "elf64ve"; 288 case llvm::Triple::csky: 289 return "cskyelf_linux"; 290 default: 291 return nullptr; 292 } 293 } 294 295 static bool getStaticPIE(const ArgList &Args, const ToolChain &TC) { 296 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie); 297 if (HasStaticPIE && Args.hasArg(options::OPT_no_pie)) { 298 const Driver &D = TC.getDriver(); 299 const llvm::opt::OptTable &Opts = D.getOpts(); 300 StringRef StaticPIEName = Opts.getOptionName(options::OPT_static_pie); 301 StringRef NoPIEName = Opts.getOptionName(options::OPT_nopie); 302 D.Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName; 303 } 304 return HasStaticPIE; 305 } 306 307 static bool getStatic(const ArgList &Args) { 308 return Args.hasArg(options::OPT_static) && 309 !Args.hasArg(options::OPT_static_pie); 310 } 311 312 void tools::gnutools::StaticLibTool::ConstructJob( 313 Compilation &C, const JobAction &JA, const InputInfo &Output, 314 const InputInfoList &Inputs, const ArgList &Args, 315 const char *LinkingOutput) const { 316 const Driver &D = getToolChain().getDriver(); 317 318 // Silence warning for "clang -g foo.o -o foo" 319 Args.ClaimAllArgs(options::OPT_g_Group); 320 // and "clang -emit-llvm foo.o -o foo" 321 Args.ClaimAllArgs(options::OPT_emit_llvm); 322 // and for "clang -w foo.o -o foo". Other warning options are already 323 // handled somewhere else. 324 Args.ClaimAllArgs(options::OPT_w); 325 // Silence warnings when linking C code with a C++ '-stdlib' argument. 326 Args.ClaimAllArgs(options::OPT_stdlib_EQ); 327 328 // ar tool command "llvm-ar <options> <output_file> <input_files>". 329 ArgStringList CmdArgs; 330 // Create and insert file members with a deterministic index. 331 CmdArgs.push_back("rcsD"); 332 CmdArgs.push_back(Output.getFilename()); 333 334 for (const auto &II : Inputs) { 335 if (II.isFilename()) { 336 CmdArgs.push_back(II.getFilename()); 337 } 338 } 339 340 // Delete old output archive file if it already exists before generating a new 341 // archive file. 342 auto OutputFileName = Output.getFilename(); 343 if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) { 344 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) { 345 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message(); 346 return; 347 } 348 } 349 350 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath()); 351 C.addCommand(std::make_unique<Command>(JA, *this, 352 ResponseFileSupport::AtFileCurCP(), 353 Exec, CmdArgs, Inputs, Output)); 354 } 355 356 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, 357 const InputInfo &Output, 358 const InputInfoList &Inputs, 359 const ArgList &Args, 360 const char *LinkingOutput) const { 361 // FIXME: The Linker class constructor takes a ToolChain and not a 362 // Generic_ELF, so the static_cast might return a reference to a invalid 363 // instance (see PR45061). Ideally, the Linker constructor needs to take a 364 // Generic_ELF instead. 365 const auto &ToolChain = static_cast<const Generic_ELF &>(getToolChain()); 366 const Driver &D = ToolChain.getDriver(); 367 368 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 369 370 const llvm::Triple::ArchType Arch = ToolChain.getArch(); 371 const bool isOHOSFamily = ToolChain.getTriple().isOHOSFamily(); 372 const bool isAndroid = ToolChain.getTriple().isAndroid(); 373 const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU(); 374 const bool IsVE = ToolChain.getTriple().isVE(); 375 const bool IsStaticPIE = getStaticPIE(Args, ToolChain); 376 const bool IsStatic = getStatic(Args); 377 const bool HasCRTBeginEndFiles = 378 ToolChain.getTriple().hasEnvironment() || 379 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies); 380 381 ArgStringList CmdArgs; 382 383 // Silence warning for "clang -g foo.o -o foo" 384 Args.ClaimAllArgs(options::OPT_g_Group); 385 // and "clang -emit-llvm foo.o -o foo" 386 Args.ClaimAllArgs(options::OPT_emit_llvm); 387 // and for "clang -w foo.o -o foo". Other warning options are already 388 // handled somewhere else. 389 Args.ClaimAllArgs(options::OPT_w); 390 391 if (!D.SysRoot.empty()) 392 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 393 394 if (Args.hasArg(options::OPT_s)) 395 CmdArgs.push_back("-s"); 396 397 if (Triple.isARM() || Triple.isThumb()) { 398 bool IsBigEndian = arm::isARMBigEndian(Triple, Args); 399 if (IsBigEndian) 400 arm::appendBE8LinkFlag(Args, CmdArgs, Triple); 401 CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL"); 402 } else if (Triple.isAArch64()) { 403 CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ? "-EB" : "-EL"); 404 } 405 406 // Most Android ARM64 targets should enable the linker fix for erratum 407 // 843419. Only non-Cortex-A53 devices are allowed to skip this flag. 408 if (Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily)) { 409 std::string CPU = getCPUName(D, Args, Triple); 410 if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53") 411 CmdArgs.push_back("--fix-cortex-a53-843419"); 412 } 413 414 ToolChain.addExtraOpts(CmdArgs); 415 416 CmdArgs.push_back("--eh-frame-hdr"); 417 418 if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) { 419 CmdArgs.push_back("-m"); 420 CmdArgs.push_back(LDMOption); 421 } else { 422 D.Diag(diag::err_target_unknown_triple) << Triple.str(); 423 return; 424 } 425 if (Triple.isRISCV()) 426 CmdArgs.push_back("-X"); 427 428 const bool IsShared = Args.hasArg(options::OPT_shared); 429 if (IsShared) 430 CmdArgs.push_back("-shared"); 431 bool IsPIE = false; 432 if (IsStaticPIE) { 433 CmdArgs.push_back("-static"); 434 CmdArgs.push_back("-pie"); 435 CmdArgs.push_back("--no-dynamic-linker"); 436 CmdArgs.push_back("-z"); 437 CmdArgs.push_back("text"); 438 } else if (IsStatic) { 439 CmdArgs.push_back("-static"); 440 } else if (!Args.hasArg(options::OPT_r)) { 441 if (Args.hasArg(options::OPT_rdynamic)) 442 CmdArgs.push_back("-export-dynamic"); 443 if (!IsShared) { 444 IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie, 445 ToolChain.isPIEDefault(Args)); 446 if (IsPIE) 447 CmdArgs.push_back("-pie"); 448 CmdArgs.push_back("-dynamic-linker"); 449 CmdArgs.push_back(Args.MakeArgString(Twine(D.DyldPrefix) + 450 ToolChain.getDynamicLinker(Args))); 451 } 452 } 453 454 CmdArgs.push_back("-o"); 455 CmdArgs.push_back(Output.getFilename()); 456 457 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, 458 options::OPT_r)) { 459 if (!isAndroid && !IsIAMCU) { 460 const char *crt1 = nullptr; 461 if (!Args.hasArg(options::OPT_shared)) { 462 if (Args.hasArg(options::OPT_pg)) 463 crt1 = "gcrt1.o"; 464 else if (IsPIE) 465 crt1 = "Scrt1.o"; 466 else if (IsStaticPIE) 467 crt1 = "rcrt1.o"; 468 else 469 crt1 = "crt1.o"; 470 } 471 if (crt1) 472 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 473 474 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 475 } 476 477 if (IsVE) { 478 CmdArgs.push_back("-z"); 479 CmdArgs.push_back("max-page-size=0x4000000"); 480 } 481 482 if (IsIAMCU) 483 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o"))); 484 else if (HasCRTBeginEndFiles) { 485 std::string P; 486 if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT && 487 !isAndroid) { 488 std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin", 489 ToolChain::FT_Object); 490 if (ToolChain.getVFS().exists(crtbegin)) 491 P = crtbegin; 492 } 493 if (P.empty()) { 494 const char *crtbegin; 495 if (Args.hasArg(options::OPT_shared)) 496 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o"; 497 else if (IsStatic) 498 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o"; 499 else if (IsPIE || IsStaticPIE) 500 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o"; 501 else 502 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o"; 503 P = ToolChain.GetFilePath(crtbegin); 504 } 505 CmdArgs.push_back(Args.MakeArgString(P)); 506 } 507 508 // Add crtfastmath.o if available and fast math is enabled. 509 ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs); 510 } 511 512 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_u}); 513 514 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 515 516 if (D.isUsingLTO()) { 517 assert(!Inputs.empty() && "Must have at least one input."); 518 // Find the first filename InputInfo object. 519 auto Input = llvm::find_if( 520 Inputs, [](const InputInfo &II) -> bool { return II.isFilename(); }); 521 if (Input == Inputs.end()) 522 // For a very rare case, all of the inputs to the linker are 523 // InputArg. If that happens, just use the first InputInfo. 524 Input = Inputs.begin(); 525 526 addLTOOptions(ToolChain, Args, CmdArgs, Output, *Input, 527 D.getLTOMode() == LTOK_Thin); 528 } 529 530 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 531 CmdArgs.push_back("--no-demangle"); 532 533 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); 534 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 535 addLinkerCompressDebugSectionsOption(ToolChain, Args, CmdArgs); 536 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 537 538 addHIPRuntimeLibArgs(ToolChain, C, Args, CmdArgs); 539 540 // The profile runtime also needs access to system libraries. 541 getToolChain().addProfileRTLibs(Args, CmdArgs); 542 543 if (D.CCCIsCXX() && 544 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, 545 options::OPT_r)) { 546 if (ToolChain.ShouldLinkCXXStdlib(Args)) { 547 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 548 !Args.hasArg(options::OPT_static); 549 if (OnlyLibstdcxxStatic) 550 CmdArgs.push_back("-Bstatic"); 551 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 552 if (OnlyLibstdcxxStatic) 553 CmdArgs.push_back("-Bdynamic"); 554 } 555 CmdArgs.push_back("-lm"); 556 } 557 558 // Silence warnings when linking C code with a C++ '-stdlib' argument. 559 Args.ClaimAllArgs(options::OPT_stdlib_EQ); 560 561 // Additional linker set-up and flags for Fortran. This is required in order 562 // to generate executables. As Fortran runtime depends on the C runtime, 563 // these dependencies need to be listed before the C runtime below (i.e. 564 // AddRunTimeLibs). 565 if (D.IsFlangMode()) { 566 addFortranRuntimeLibraryPath(ToolChain, Args, CmdArgs); 567 addFortranRuntimeLibs(ToolChain, Args, CmdArgs); 568 CmdArgs.push_back("-lm"); 569 } 570 571 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) { 572 if (!Args.hasArg(options::OPT_nodefaultlibs)) { 573 if (IsStatic || IsStaticPIE) 574 CmdArgs.push_back("--start-group"); 575 576 if (NeedsSanitizerDeps) 577 linkSanitizerRuntimeDeps(ToolChain, Args, CmdArgs); 578 579 if (NeedsXRayDeps) 580 linkXRayRuntimeDeps(ToolChain, Args, CmdArgs); 581 582 bool WantPthread = Args.hasArg(options::OPT_pthread) || 583 Args.hasArg(options::OPT_pthreads); 584 585 // Use the static OpenMP runtime with -static-openmp 586 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) && 587 !Args.hasArg(options::OPT_static); 588 589 // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that 590 // require librt. Most modern Linux platforms do, but some may not. 591 if (addOpenMPRuntime(CmdArgs, ToolChain, Args, StaticOpenMP, 592 JA.isHostOffloading(Action::OFK_OpenMP), 593 /* GompNeedsRT= */ true)) 594 // OpenMP runtimes implies pthreads when using the GNU toolchain. 595 // FIXME: Does this really make sense for all GNU toolchains? 596 WantPthread = true; 597 598 AddRunTimeLibs(ToolChain, D, CmdArgs, Args); 599 600 // LLVM support for atomics on 32-bit SPARC V8+ is incomplete, so 601 // forcibly link with libatomic as a workaround. 602 // TODO: Issue #41880 and D118021. 603 if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) { 604 CmdArgs.push_back("--push-state"); 605 CmdArgs.push_back("--as-needed"); 606 CmdArgs.push_back("-latomic"); 607 CmdArgs.push_back("--pop-state"); 608 } 609 610 // We don't need libpthread neither for bionic (Android) nor for musl, 611 // (used by OHOS as runtime library). 612 if (WantPthread && !isAndroid && !isOHOSFamily) 613 CmdArgs.push_back("-lpthread"); 614 615 if (Args.hasArg(options::OPT_fsplit_stack)) 616 CmdArgs.push_back("--wrap=pthread_create"); 617 618 if (!Args.hasArg(options::OPT_nolibc)) 619 CmdArgs.push_back("-lc"); 620 621 // Add IAMCU specific libs, if needed. 622 if (IsIAMCU) 623 CmdArgs.push_back("-lgloss"); 624 625 if (IsStatic || IsStaticPIE) 626 CmdArgs.push_back("--end-group"); 627 else 628 AddRunTimeLibs(ToolChain, D, CmdArgs, Args); 629 630 // Add IAMCU specific libs (outside the group), if needed. 631 if (IsIAMCU) { 632 CmdArgs.push_back("--as-needed"); 633 CmdArgs.push_back("-lsoftfp"); 634 CmdArgs.push_back("--no-as-needed"); 635 } 636 } 637 638 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) { 639 if (HasCRTBeginEndFiles) { 640 std::string P; 641 if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT && 642 !isAndroid) { 643 std::string crtend = ToolChain.getCompilerRT(Args, "crtend", 644 ToolChain::FT_Object); 645 if (ToolChain.getVFS().exists(crtend)) 646 P = crtend; 647 } 648 if (P.empty()) { 649 const char *crtend; 650 if (Args.hasArg(options::OPT_shared)) 651 crtend = isAndroid ? "crtend_so.o" : "crtendS.o"; 652 else if (IsPIE || IsStaticPIE) 653 crtend = isAndroid ? "crtend_android.o" : "crtendS.o"; 654 else 655 crtend = isAndroid ? "crtend_android.o" : "crtend.o"; 656 P = ToolChain.GetFilePath(crtend); 657 } 658 CmdArgs.push_back(Args.MakeArgString(P)); 659 } 660 if (!isAndroid) 661 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 662 } 663 } 664 665 Args.AddAllArgs(CmdArgs, options::OPT_T); 666 667 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 668 C.addCommand(std::make_unique<Command>(JA, *this, 669 ResponseFileSupport::AtFileCurCP(), 670 Exec, CmdArgs, Inputs, Output)); 671 } 672 673 void tools::gnutools::Assembler::ConstructJob(Compilation &C, 674 const JobAction &JA, 675 const InputInfo &Output, 676 const InputInfoList &Inputs, 677 const ArgList &Args, 678 const char *LinkingOutput) const { 679 const auto &D = getToolChain().getDriver(); 680 681 claimNoWarnArgs(Args); 682 683 ArgStringList CmdArgs; 684 685 llvm::Reloc::Model RelocationModel; 686 unsigned PICLevel; 687 bool IsPIE; 688 const char *DefaultAssembler = "as"; 689 // Enforce GNU as on Solaris; the native assembler's input syntax isn't fully 690 // compatible. 691 if (getToolChain().getTriple().isOSSolaris()) 692 DefaultAssembler = "gas"; 693 std::tie(RelocationModel, PICLevel, IsPIE) = 694 ParsePICArgs(getToolChain(), Args); 695 696 if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) { 697 if (A->getOption().getID() == options::OPT_gz) { 698 CmdArgs.push_back("--compress-debug-sections"); 699 } else { 700 StringRef Value = A->getValue(); 701 if (Value == "none" || Value == "zlib" || Value == "zstd") { 702 CmdArgs.push_back( 703 Args.MakeArgString("--compress-debug-sections=" + Twine(Value))); 704 } else { 705 D.Diag(diag::err_drv_unsupported_option_argument) 706 << A->getSpelling() << Value; 707 } 708 } 709 } 710 711 switch (getToolChain().getArch()) { 712 default: 713 break; 714 // Add --32/--64 to make sure we get the format we want. 715 // This is incomplete 716 case llvm::Triple::x86: 717 CmdArgs.push_back("--32"); 718 break; 719 case llvm::Triple::x86_64: 720 if (getToolChain().getTriple().isX32()) 721 CmdArgs.push_back("--x32"); 722 else 723 CmdArgs.push_back("--64"); 724 break; 725 case llvm::Triple::ppc: { 726 CmdArgs.push_back("-a32"); 727 CmdArgs.push_back("-mppc"); 728 CmdArgs.push_back("-mbig-endian"); 729 CmdArgs.push_back(ppc::getPPCAsmModeForCPU( 730 getCPUName(D, Args, getToolChain().getTriple()))); 731 break; 732 } 733 case llvm::Triple::ppcle: { 734 CmdArgs.push_back("-a32"); 735 CmdArgs.push_back("-mppc"); 736 CmdArgs.push_back("-mlittle-endian"); 737 CmdArgs.push_back(ppc::getPPCAsmModeForCPU( 738 getCPUName(D, Args, getToolChain().getTriple()))); 739 break; 740 } 741 case llvm::Triple::ppc64: { 742 CmdArgs.push_back("-a64"); 743 CmdArgs.push_back("-mppc64"); 744 CmdArgs.push_back("-mbig-endian"); 745 CmdArgs.push_back(ppc::getPPCAsmModeForCPU( 746 getCPUName(D, Args, getToolChain().getTriple()))); 747 break; 748 } 749 case llvm::Triple::ppc64le: { 750 CmdArgs.push_back("-a64"); 751 CmdArgs.push_back("-mppc64"); 752 CmdArgs.push_back("-mlittle-endian"); 753 CmdArgs.push_back(ppc::getPPCAsmModeForCPU( 754 getCPUName(D, Args, getToolChain().getTriple()))); 755 break; 756 } 757 case llvm::Triple::riscv32: 758 case llvm::Triple::riscv64: { 759 StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple()); 760 CmdArgs.push_back("-mabi"); 761 CmdArgs.push_back(ABIName.data()); 762 StringRef MArchName = riscv::getRISCVArch(Args, getToolChain().getTriple()); 763 CmdArgs.push_back("-march"); 764 CmdArgs.push_back(MArchName.data()); 765 if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax, true)) 766 Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax); 767 break; 768 } 769 case llvm::Triple::sparc: 770 case llvm::Triple::sparcel: { 771 CmdArgs.push_back("-32"); 772 std::string CPU = getCPUName(D, Args, getToolChain().getTriple()); 773 CmdArgs.push_back( 774 sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 775 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 776 break; 777 } 778 case llvm::Triple::sparcv9: { 779 CmdArgs.push_back("-64"); 780 std::string CPU = getCPUName(D, Args, getToolChain().getTriple()); 781 CmdArgs.push_back( 782 sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 783 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 784 break; 785 } 786 case llvm::Triple::arm: 787 case llvm::Triple::armeb: 788 case llvm::Triple::thumb: 789 case llvm::Triple::thumbeb: { 790 const llvm::Triple &Triple2 = getToolChain().getTriple(); 791 CmdArgs.push_back(arm::isARMBigEndian(Triple2, Args) ? "-EB" : "-EL"); 792 switch (Triple2.getSubArch()) { 793 case llvm::Triple::ARMSubArch_v7: 794 CmdArgs.push_back("-mfpu=neon"); 795 break; 796 case llvm::Triple::ARMSubArch_v8: 797 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8"); 798 break; 799 default: 800 break; 801 } 802 803 switch (arm::getARMFloatABI(getToolChain(), Args)) { 804 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!"); 805 case arm::FloatABI::Soft: 806 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft")); 807 break; 808 case arm::FloatABI::SoftFP: 809 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp")); 810 break; 811 case arm::FloatABI::Hard: 812 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard")); 813 break; 814 } 815 816 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 817 normalizeCPUNamesForAssembler(Args, CmdArgs); 818 819 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); 820 // The integrated assembler doesn't implement e_flags setting behavior for 821 // -meabi=gnu (gcc -mabi={apcs-gnu,atpcs} passes -meabi=gnu to gas). For 822 // compatibility we accept but warn. 823 if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ)) 824 A->ignoreTargetSpecific(); 825 break; 826 } 827 case llvm::Triple::aarch64: 828 case llvm::Triple::aarch64_be: { 829 CmdArgs.push_back( 830 getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL"); 831 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 832 normalizeCPUNamesForAssembler(Args, CmdArgs); 833 834 break; 835 } 836 // TODO: handle loongarch32. 837 case llvm::Triple::loongarch64: { 838 StringRef ABIName = 839 loongarch::getLoongArchABI(D, Args, getToolChain().getTriple()); 840 CmdArgs.push_back(Args.MakeArgString("-mabi=" + ABIName)); 841 break; 842 } 843 case llvm::Triple::mips: 844 case llvm::Triple::mipsel: 845 case llvm::Triple::mips64: 846 case llvm::Triple::mips64el: { 847 StringRef CPUName; 848 StringRef ABIName; 849 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 850 ABIName = mips::getGnuCompatibleMipsABIName(ABIName); 851 852 CmdArgs.push_back("-march"); 853 CmdArgs.push_back(CPUName.data()); 854 855 CmdArgs.push_back("-mabi"); 856 CmdArgs.push_back(ABIName.data()); 857 858 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE, 859 // or -mshared (not implemented) is in effect. 860 if (RelocationModel == llvm::Reloc::Static) 861 CmdArgs.push_back("-mno-shared"); 862 863 // LLVM doesn't support -mplt yet and acts as if it is always given. 864 // However, -mplt has no effect with the N64 ABI. 865 if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls)) 866 CmdArgs.push_back("-call_nonpic"); 867 868 if (getToolChain().getTriple().isLittleEndian()) 869 CmdArgs.push_back("-EL"); 870 else 871 CmdArgs.push_back("-EB"); 872 873 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 874 if (StringRef(A->getValue()) == "2008") 875 CmdArgs.push_back(Args.MakeArgString("-mnan=2008")); 876 } 877 878 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default. 879 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx, 880 options::OPT_mfp64)) { 881 A->claim(); 882 A->render(Args, CmdArgs); 883 } else if (mips::shouldUseFPXX( 884 Args, getToolChain().getTriple(), CPUName, ABIName, 885 mips::getMipsFloatABI(getToolChain().getDriver(), Args, 886 getToolChain().getTriple()))) 887 CmdArgs.push_back("-mfpxx"); 888 889 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of 890 // -mno-mips16 is actually -no-mips16. 891 if (Arg *A = 892 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) { 893 if (A->getOption().matches(options::OPT_mips16)) { 894 A->claim(); 895 A->render(Args, CmdArgs); 896 } else { 897 A->claim(); 898 CmdArgs.push_back("-no-mips16"); 899 } 900 } 901 902 Args.AddLastArg(CmdArgs, options::OPT_mmicromips, 903 options::OPT_mno_micromips); 904 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp); 905 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2); 906 907 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) { 908 // Do not use AddLastArg because not all versions of MIPS assembler 909 // support -mmsa / -mno-msa options. 910 if (A->getOption().matches(options::OPT_mmsa)) 911 CmdArgs.push_back(Args.MakeArgString("-mmsa")); 912 } 913 914 Args.AddLastArg(CmdArgs, options::OPT_mhard_float, 915 options::OPT_msoft_float); 916 917 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float, 918 options::OPT_msingle_float); 919 920 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg, 921 options::OPT_mno_odd_spreg); 922 923 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 924 break; 925 } 926 case llvm::Triple::systemz: { 927 // Always pass an -march option, since our default of z10 is later 928 // than the GNU assembler's default. 929 std::string CPUName = systemz::getSystemZTargetCPU(Args); 930 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName)); 931 break; 932 } 933 case llvm::Triple::ve: 934 DefaultAssembler = "nas"; 935 } 936 937 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ, 938 options::OPT_fdebug_prefix_map_EQ)) { 939 StringRef Map = A->getValue(); 940 if (!Map.contains('=')) 941 D.Diag(diag::err_drv_invalid_argument_to_option) 942 << Map << A->getOption().getName(); 943 else { 944 CmdArgs.push_back(Args.MakeArgString("--debug-prefix-map")); 945 CmdArgs.push_back(Args.MakeArgString(Map)); 946 } 947 A->claim(); 948 } 949 950 Args.AddAllArgs(CmdArgs, options::OPT_I); 951 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 952 953 CmdArgs.push_back("-o"); 954 CmdArgs.push_back(Output.getFilename()); 955 956 for (const auto &II : Inputs) 957 CmdArgs.push_back(II.getFilename()); 958 959 if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group, 960 options::OPT_gdwarf_2, options::OPT_gdwarf_3, 961 options::OPT_gdwarf_4, options::OPT_gdwarf_5, 962 options::OPT_gdwarf)) 963 if (!A->getOption().matches(options::OPT_g0)) { 964 Args.AddLastArg(CmdArgs, options::OPT_g_Flag); 965 966 unsigned DwarfVersion = getDwarfVersion(getToolChain(), Args); 967 CmdArgs.push_back(Args.MakeArgString("-gdwarf-" + Twine(DwarfVersion))); 968 } 969 970 const char *Exec = 971 Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler)); 972 C.addCommand(std::make_unique<Command>(JA, *this, 973 ResponseFileSupport::AtFileCurCP(), 974 Exec, CmdArgs, Inputs, Output)); 975 976 // Handle the debug info splitting at object creation time if we're 977 // creating an object. 978 // TODO: Currently only works on linux with newer objcopy. 979 if (Args.hasArg(options::OPT_gsplit_dwarf) && 980 getToolChain().getTriple().isOSLinux()) 981 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, 982 SplitDebugName(JA, Args, Inputs[0], Output)); 983 } 984 985 namespace { 986 // Filter to remove Multilibs that don't exist as a suffix to Path 987 class FilterNonExistent { 988 StringRef Base, File; 989 llvm::vfs::FileSystem &VFS; 990 991 public: 992 FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS) 993 : Base(Base), File(File), VFS(VFS) {} 994 bool operator()(const Multilib &M) { 995 return !VFS.exists(Base + M.gccSuffix() + File); 996 } 997 }; 998 } // end anonymous namespace 999 1000 static bool isSoftFloatABI(const ArgList &Args) { 1001 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, 1002 options::OPT_mfloat_abi_EQ); 1003 if (!A) 1004 return false; 1005 1006 return A->getOption().matches(options::OPT_msoft_float) || 1007 (A->getOption().matches(options::OPT_mfloat_abi_EQ) && 1008 A->getValue() == StringRef("soft")); 1009 } 1010 1011 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) { 1012 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb; 1013 } 1014 1015 static bool isMipsEL(llvm::Triple::ArchType Arch) { 1016 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el; 1017 } 1018 1019 static bool isMips16(const ArgList &Args) { 1020 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16); 1021 return A && A->getOption().matches(options::OPT_mips16); 1022 } 1023 1024 static bool isMicroMips(const ArgList &Args) { 1025 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips); 1026 return A && A->getOption().matches(options::OPT_mmicromips); 1027 } 1028 1029 static bool isMSP430(llvm::Triple::ArchType Arch) { 1030 return Arch == llvm::Triple::msp430; 1031 } 1032 1033 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, 1034 FilterNonExistent &NonExistent, 1035 DetectedMultilibs &Result) { 1036 // Check for Code Sourcery toolchain multilibs 1037 MultilibSet CSMipsMultilibs; 1038 { 1039 auto MArchMips16 = MultilibBuilder("/mips16").flag("-m32").flag("-mips16"); 1040 1041 auto MArchMicroMips = 1042 MultilibBuilder("/micromips").flag("-m32").flag("-mmicromips"); 1043 1044 auto MArchDefault = MultilibBuilder("") 1045 .flag("-mips16", /*Disallow=*/true) 1046 .flag("-mmicromips", /*Disallow=*/true); 1047 1048 auto UCLibc = MultilibBuilder("/uclibc").flag("-muclibc"); 1049 1050 auto SoftFloat = MultilibBuilder("/soft-float").flag("-msoft-float"); 1051 1052 auto Nan2008 = MultilibBuilder("/nan2008").flag("-mnan=2008"); 1053 1054 auto DefaultFloat = MultilibBuilder("") 1055 .flag("-msoft-float", /*Disallow=*/true) 1056 .flag("-mnan=2008", /*Disallow=*/true); 1057 1058 auto BigEndian = 1059 MultilibBuilder("").flag("-EB").flag("-EL", /*Disallow=*/true); 1060 1061 auto LittleEndian = 1062 MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true); 1063 1064 // Note that this one's osSuffix is "" 1065 auto MAbi64 = MultilibBuilder("") 1066 .gccSuffix("/64") 1067 .includeSuffix("/64") 1068 .flag("-mabi=n64") 1069 .flag("-mabi=n32", /*Disallow=*/true) 1070 .flag("-m32", /*Disallow=*/true); 1071 1072 CSMipsMultilibs = 1073 MultilibSetBuilder() 1074 .Either(MArchMips16, MArchMicroMips, MArchDefault) 1075 .Maybe(UCLibc) 1076 .Either(SoftFloat, Nan2008, DefaultFloat) 1077 .FilterOut("/micromips/nan2008") 1078 .FilterOut("/mips16/nan2008") 1079 .Either(BigEndian, LittleEndian) 1080 .Maybe(MAbi64) 1081 .FilterOut("/mips16.*/64") 1082 .FilterOut("/micromips.*/64") 1083 .makeMultilibSet() 1084 .FilterOut(NonExistent) 1085 .setIncludeDirsCallback([](const Multilib &M) { 1086 std::vector<std::string> Dirs({"/include"}); 1087 if (StringRef(M.includeSuffix()).starts_with("/uclibc")) 1088 Dirs.push_back( 1089 "/../../../../mips-linux-gnu/libc/uclibc/usr/include"); 1090 else 1091 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include"); 1092 return Dirs; 1093 }); 1094 } 1095 1096 MultilibSet DebianMipsMultilibs; 1097 { 1098 MultilibBuilder MAbiN32 = 1099 MultilibBuilder().gccSuffix("/n32").includeSuffix("/n32").flag( 1100 "-mabi=n32"); 1101 1102 MultilibBuilder M64 = MultilibBuilder() 1103 .gccSuffix("/64") 1104 .includeSuffix("/64") 1105 .flag("-m64") 1106 .flag("-m32", /*Disallow=*/true) 1107 .flag("-mabi=n32", /*Disallow=*/true); 1108 1109 MultilibBuilder M32 = MultilibBuilder() 1110 .gccSuffix("/32") 1111 .flag("-m64", /*Disallow=*/true) 1112 .flag("-m32") 1113 .flag("-mabi=n32", /*Disallow=*/true); 1114 1115 DebianMipsMultilibs = MultilibSetBuilder() 1116 .Either(M32, M64, MAbiN32) 1117 .makeMultilibSet() 1118 .FilterOut(NonExistent); 1119 } 1120 1121 // Sort candidates. Toolchain that best meets the directories tree goes first. 1122 // Then select the first toolchains matches command line flags. 1123 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs}; 1124 if (CSMipsMultilibs.size() < DebianMipsMultilibs.size()) 1125 std::iter_swap(Candidates, Candidates + 1); 1126 for (const MultilibSet *Candidate : Candidates) { 1127 if (Candidate->select(Flags, Result.SelectedMultilibs)) { 1128 if (Candidate == &DebianMipsMultilibs) 1129 Result.BiarchSibling = Multilib(); 1130 Result.Multilibs = *Candidate; 1131 return true; 1132 } 1133 } 1134 return false; 1135 } 1136 1137 static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path, 1138 const Multilib::flags_list &Flags, 1139 FilterNonExistent &NonExistent, 1140 DetectedMultilibs &Result) { 1141 1142 MultilibSet AndroidMipsMultilibs = 1143 MultilibSetBuilder() 1144 .Maybe(MultilibBuilder("/mips-r2", {}, {}).flag("-march=mips32r2")) 1145 .Maybe(MultilibBuilder("/mips-r6", {}, {}).flag("-march=mips32r6")) 1146 .makeMultilibSet() 1147 .FilterOut(NonExistent); 1148 1149 MultilibSet AndroidMipselMultilibs = 1150 MultilibSetBuilder() 1151 .Either(MultilibBuilder().flag("-march=mips32"), 1152 MultilibBuilder("/mips-r2", "", "/mips-r2") 1153 .flag("-march=mips32r2"), 1154 MultilibBuilder("/mips-r6", "", "/mips-r6") 1155 .flag("-march=mips32r6")) 1156 .makeMultilibSet() 1157 .FilterOut(NonExistent); 1158 1159 MultilibSet AndroidMips64elMultilibs = 1160 MultilibSetBuilder() 1161 .Either(MultilibBuilder().flag("-march=mips64r6"), 1162 MultilibBuilder("/32/mips-r1", "", "/mips-r1") 1163 .flag("-march=mips32"), 1164 MultilibBuilder("/32/mips-r2", "", "/mips-r2") 1165 .flag("-march=mips32r2"), 1166 MultilibBuilder("/32/mips-r6", "", "/mips-r6") 1167 .flag("-march=mips32r6")) 1168 .makeMultilibSet() 1169 .FilterOut(NonExistent); 1170 1171 MultilibSet *MS = &AndroidMipsMultilibs; 1172 if (VFS.exists(Path + "/mips-r6")) 1173 MS = &AndroidMipselMultilibs; 1174 else if (VFS.exists(Path + "/32")) 1175 MS = &AndroidMips64elMultilibs; 1176 if (MS->select(Flags, Result.SelectedMultilibs)) { 1177 Result.Multilibs = *MS; 1178 return true; 1179 } 1180 return false; 1181 } 1182 1183 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, 1184 FilterNonExistent &NonExistent, 1185 DetectedMultilibs &Result) { 1186 // Musl toolchain multilibs 1187 MultilibSet MuslMipsMultilibs; 1188 { 1189 auto MArchMipsR2 = MultilibBuilder("") 1190 .osSuffix("/mips-r2-hard-musl") 1191 .flag("-EB") 1192 .flag("-EL", /*Disallow=*/true) 1193 .flag("-march=mips32r2"); 1194 1195 auto MArchMipselR2 = MultilibBuilder("/mipsel-r2-hard-musl") 1196 .flag("-EB", /*Disallow=*/true) 1197 .flag("-EL") 1198 .flag("-march=mips32r2"); 1199 1200 MuslMipsMultilibs = MultilibSetBuilder() 1201 .Either(MArchMipsR2, MArchMipselR2) 1202 .makeMultilibSet(); 1203 1204 // Specify the callback that computes the include directories. 1205 MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) { 1206 return std::vector<std::string>( 1207 {"/../sysroot" + M.osSuffix() + "/usr/include"}); 1208 }); 1209 } 1210 if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilibs)) { 1211 Result.Multilibs = MuslMipsMultilibs; 1212 return true; 1213 } 1214 return false; 1215 } 1216 1217 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, 1218 FilterNonExistent &NonExistent, 1219 DetectedMultilibs &Result) { 1220 // CodeScape MTI toolchain v1.2 and early. 1221 MultilibSet MtiMipsMultilibsV1; 1222 { 1223 auto MArchMips32 = MultilibBuilder("/mips32") 1224 .flag("-m32") 1225 .flag("-m64", /*Disallow=*/true) 1226 .flag("-mmicromips", /*Disallow=*/true) 1227 .flag("-march=mips32"); 1228 1229 auto MArchMicroMips = MultilibBuilder("/micromips") 1230 .flag("-m32") 1231 .flag("-m64", /*Disallow=*/true) 1232 .flag("-mmicromips"); 1233 1234 auto MArchMips64r2 = MultilibBuilder("/mips64r2") 1235 .flag("-m32", /*Disallow=*/true) 1236 .flag("-m64") 1237 .flag("-march=mips64r2"); 1238 1239 auto MArchMips64 = MultilibBuilder("/mips64") 1240 .flag("-m32", /*Disallow=*/true) 1241 .flag("-m64") 1242 .flag("-march=mips64r2", /*Disallow=*/true); 1243 1244 auto MArchDefault = MultilibBuilder("") 1245 .flag("-m32") 1246 .flag("-m64", /*Disallow=*/true) 1247 .flag("-mmicromips", /*Disallow=*/true) 1248 .flag("-march=mips32r2"); 1249 1250 auto Mips16 = MultilibBuilder("/mips16").flag("-mips16"); 1251 1252 auto UCLibc = MultilibBuilder("/uclibc").flag("-muclibc"); 1253 1254 auto MAbi64 = MultilibBuilder("/64") 1255 .flag("-mabi=n64") 1256 .flag("-mabi=n32", /*Disallow=*/true) 1257 .flag("-m32", /*Disallow=*/true); 1258 1259 auto BigEndian = 1260 MultilibBuilder("").flag("-EB").flag("-EL", /*Disallow=*/true); 1261 1262 auto LittleEndian = 1263 MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true); 1264 1265 auto SoftFloat = MultilibBuilder("/sof").flag("-msoft-float"); 1266 1267 auto Nan2008 = MultilibBuilder("/nan2008").flag("-mnan=2008"); 1268 1269 MtiMipsMultilibsV1 = 1270 MultilibSetBuilder() 1271 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64, 1272 MArchDefault) 1273 .Maybe(UCLibc) 1274 .Maybe(Mips16) 1275 .FilterOut("/mips64/mips16") 1276 .FilterOut("/mips64r2/mips16") 1277 .FilterOut("/micromips/mips16") 1278 .Maybe(MAbi64) 1279 .FilterOut("/micromips/64") 1280 .FilterOut("/mips32/64") 1281 .FilterOut("^/64") 1282 .FilterOut("/mips16/64") 1283 .Either(BigEndian, LittleEndian) 1284 .Maybe(SoftFloat) 1285 .Maybe(Nan2008) 1286 .FilterOut(".*sof/nan2008") 1287 .makeMultilibSet() 1288 .FilterOut(NonExistent) 1289 .setIncludeDirsCallback([](const Multilib &M) { 1290 std::vector<std::string> Dirs({"/include"}); 1291 if (StringRef(M.includeSuffix()).starts_with("/uclibc")) 1292 Dirs.push_back("/../../../../sysroot/uclibc/usr/include"); 1293 else 1294 Dirs.push_back("/../../../../sysroot/usr/include"); 1295 return Dirs; 1296 }); 1297 } 1298 1299 // CodeScape IMG toolchain starting from v1.3. 1300 MultilibSet MtiMipsMultilibsV2; 1301 { 1302 auto BeHard = MultilibBuilder("/mips-r2-hard") 1303 .flag("-EB") 1304 .flag("-msoft-float", /*Disallow=*/true) 1305 .flag("-mnan=2008", /*Disallow=*/true) 1306 .flag("-muclibc", /*Disallow=*/true); 1307 auto BeSoft = MultilibBuilder("/mips-r2-soft") 1308 .flag("-EB") 1309 .flag("-msoft-float") 1310 .flag("-mnan=2008", /*Disallow=*/true); 1311 auto ElHard = MultilibBuilder("/mipsel-r2-hard") 1312 .flag("-EL") 1313 .flag("-msoft-float", /*Disallow=*/true) 1314 .flag("-mnan=2008", /*Disallow=*/true) 1315 .flag("-muclibc", /*Disallow=*/true); 1316 auto ElSoft = MultilibBuilder("/mipsel-r2-soft") 1317 .flag("-EL") 1318 .flag("-msoft-float") 1319 .flag("-mnan=2008", /*Disallow=*/true) 1320 .flag("-mmicromips", /*Disallow=*/true); 1321 auto BeHardNan = MultilibBuilder("/mips-r2-hard-nan2008") 1322 .flag("-EB") 1323 .flag("-msoft-float", /*Disallow=*/true) 1324 .flag("-mnan=2008") 1325 .flag("-muclibc", /*Disallow=*/true); 1326 auto ElHardNan = MultilibBuilder("/mipsel-r2-hard-nan2008") 1327 .flag("-EL") 1328 .flag("-msoft-float", /*Disallow=*/true) 1329 .flag("-mnan=2008") 1330 .flag("-muclibc", /*Disallow=*/true) 1331 .flag("-mmicromips", /*Disallow=*/true); 1332 auto BeHardNanUclibc = MultilibBuilder("/mips-r2-hard-nan2008-uclibc") 1333 .flag("-EB") 1334 .flag("-msoft-float", /*Disallow=*/true) 1335 .flag("-mnan=2008") 1336 .flag("-muclibc"); 1337 auto ElHardNanUclibc = MultilibBuilder("/mipsel-r2-hard-nan2008-uclibc") 1338 .flag("-EL") 1339 .flag("-msoft-float", /*Disallow=*/true) 1340 .flag("-mnan=2008") 1341 .flag("-muclibc"); 1342 auto BeHardUclibc = MultilibBuilder("/mips-r2-hard-uclibc") 1343 .flag("-EB") 1344 .flag("-msoft-float", /*Disallow=*/true) 1345 .flag("-mnan=2008", /*Disallow=*/true) 1346 .flag("-muclibc"); 1347 auto ElHardUclibc = MultilibBuilder("/mipsel-r2-hard-uclibc") 1348 .flag("-EL") 1349 .flag("-msoft-float", /*Disallow=*/true) 1350 .flag("-mnan=2008", /*Disallow=*/true) 1351 .flag("-muclibc"); 1352 auto ElMicroHardNan = MultilibBuilder("/micromipsel-r2-hard-nan2008") 1353 .flag("-EL") 1354 .flag("-msoft-float", /*Disallow=*/true) 1355 .flag("-mnan=2008") 1356 .flag("-mmicromips"); 1357 auto ElMicroSoft = MultilibBuilder("/micromipsel-r2-soft") 1358 .flag("-EL") 1359 .flag("-msoft-float") 1360 .flag("-mnan=2008", /*Disallow=*/true) 1361 .flag("-mmicromips"); 1362 1363 auto O32 = MultilibBuilder("/lib") 1364 .osSuffix("") 1365 .flag("-mabi=n32", /*Disallow=*/true) 1366 .flag("-mabi=n64", /*Disallow=*/true); 1367 auto N32 = MultilibBuilder("/lib32") 1368 .osSuffix("") 1369 .flag("-mabi=n32") 1370 .flag("-mabi=n64", /*Disallow=*/true); 1371 auto N64 = MultilibBuilder("/lib64") 1372 .osSuffix("") 1373 .flag("-mabi=n32", /*Disallow=*/true) 1374 .flag("-mabi=n64"); 1375 1376 MtiMipsMultilibsV2 = 1377 MultilibSetBuilder() 1378 .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan, 1379 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc, 1380 ElHardUclibc, ElMicroHardNan, ElMicroSoft}) 1381 .Either(O32, N32, N64) 1382 .makeMultilibSet() 1383 .FilterOut(NonExistent) 1384 .setIncludeDirsCallback([](const Multilib &M) { 1385 return std::vector<std::string>({"/../../../../sysroot" + 1386 M.includeSuffix() + 1387 "/../usr/include"}); 1388 }) 1389 .setFilePathsCallback([](const Multilib &M) { 1390 return std::vector<std::string>( 1391 {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()}); 1392 }); 1393 } 1394 for (auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) { 1395 if (Candidate->select(Flags, Result.SelectedMultilibs)) { 1396 Result.Multilibs = *Candidate; 1397 return true; 1398 } 1399 } 1400 return false; 1401 } 1402 1403 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, 1404 FilterNonExistent &NonExistent, 1405 DetectedMultilibs &Result) { 1406 // CodeScape IMG toolchain v1.2 and early. 1407 MultilibSet ImgMultilibsV1; 1408 { 1409 auto Mips64r6 = MultilibBuilder("/mips64r6") 1410 .flag("-m64") 1411 .flag("-m32", /*Disallow=*/true); 1412 1413 auto LittleEndian = 1414 MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true); 1415 1416 auto MAbi64 = MultilibBuilder("/64") 1417 .flag("-mabi=n64") 1418 .flag("-mabi=n32", /*Disallow=*/true) 1419 .flag("-m32", /*Disallow=*/true); 1420 1421 ImgMultilibsV1 = 1422 MultilibSetBuilder() 1423 .Maybe(Mips64r6) 1424 .Maybe(MAbi64) 1425 .Maybe(LittleEndian) 1426 .makeMultilibSet() 1427 .FilterOut(NonExistent) 1428 .setIncludeDirsCallback([](const Multilib &M) { 1429 return std::vector<std::string>( 1430 {"/include", "/../../../../sysroot/usr/include"}); 1431 }); 1432 } 1433 1434 // CodeScape IMG toolchain starting from v1.3. 1435 MultilibSet ImgMultilibsV2; 1436 { 1437 auto BeHard = MultilibBuilder("/mips-r6-hard") 1438 .flag("-EB") 1439 .flag("-msoft-float", /*Disallow=*/true) 1440 .flag("-mmicromips", /*Disallow=*/true); 1441 auto BeSoft = MultilibBuilder("/mips-r6-soft") 1442 .flag("-EB") 1443 .flag("-msoft-float") 1444 .flag("-mmicromips", /*Disallow=*/true); 1445 auto ElHard = MultilibBuilder("/mipsel-r6-hard") 1446 .flag("-EL") 1447 .flag("-msoft-float", /*Disallow=*/true) 1448 .flag("-mmicromips", /*Disallow=*/true); 1449 auto ElSoft = MultilibBuilder("/mipsel-r6-soft") 1450 .flag("-EL") 1451 .flag("-msoft-float") 1452 .flag("-mmicromips", /*Disallow=*/true); 1453 auto BeMicroHard = MultilibBuilder("/micromips-r6-hard") 1454 .flag("-EB") 1455 .flag("-msoft-float", /*Disallow=*/true) 1456 .flag("-mmicromips"); 1457 auto BeMicroSoft = MultilibBuilder("/micromips-r6-soft") 1458 .flag("-EB") 1459 .flag("-msoft-float") 1460 .flag("-mmicromips"); 1461 auto ElMicroHard = MultilibBuilder("/micromipsel-r6-hard") 1462 .flag("-EL") 1463 .flag("-msoft-float", /*Disallow=*/true) 1464 .flag("-mmicromips"); 1465 auto ElMicroSoft = MultilibBuilder("/micromipsel-r6-soft") 1466 .flag("-EL") 1467 .flag("-msoft-float") 1468 .flag("-mmicromips"); 1469 1470 auto O32 = MultilibBuilder("/lib") 1471 .osSuffix("") 1472 .flag("-mabi=n32", /*Disallow=*/true) 1473 .flag("-mabi=n64", /*Disallow=*/true); 1474 auto N32 = MultilibBuilder("/lib32") 1475 .osSuffix("") 1476 .flag("-mabi=n32") 1477 .flag("-mabi=n64", /*Disallow=*/true); 1478 auto N64 = MultilibBuilder("/lib64") 1479 .osSuffix("") 1480 .flag("-mabi=n32", /*Disallow=*/true) 1481 .flag("-mabi=n64"); 1482 1483 ImgMultilibsV2 = 1484 MultilibSetBuilder() 1485 .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft, 1486 ElMicroHard, ElMicroSoft}) 1487 .Either(O32, N32, N64) 1488 .makeMultilibSet() 1489 .FilterOut(NonExistent) 1490 .setIncludeDirsCallback([](const Multilib &M) { 1491 return std::vector<std::string>({"/../../../../sysroot" + 1492 M.includeSuffix() + 1493 "/../usr/include"}); 1494 }) 1495 .setFilePathsCallback([](const Multilib &M) { 1496 return std::vector<std::string>( 1497 {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()}); 1498 }); 1499 } 1500 for (auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) { 1501 if (Candidate->select(Flags, Result.SelectedMultilibs)) { 1502 Result.Multilibs = *Candidate; 1503 return true; 1504 } 1505 } 1506 return false; 1507 } 1508 1509 bool clang::driver::findMIPSMultilibs(const Driver &D, 1510 const llvm::Triple &TargetTriple, 1511 StringRef Path, const ArgList &Args, 1512 DetectedMultilibs &Result) { 1513 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1514 1515 StringRef CPUName; 1516 StringRef ABIName; 1517 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName); 1518 1519 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 1520 1521 Multilib::flags_list Flags; 1522 addMultilibFlag(TargetTriple.isMIPS32(), "-m32", Flags); 1523 addMultilibFlag(TargetTriple.isMIPS64(), "-m64", Flags); 1524 addMultilibFlag(isMips16(Args), "-mips16", Flags); 1525 addMultilibFlag(CPUName == "mips32", "-march=mips32", Flags); 1526 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" || 1527 CPUName == "mips32r5" || CPUName == "p5600", 1528 "-march=mips32r2", Flags); 1529 addMultilibFlag(CPUName == "mips32r6", "-march=mips32r6", Flags); 1530 addMultilibFlag(CPUName == "mips64", "-march=mips64", Flags); 1531 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" || 1532 CPUName == "mips64r5" || CPUName == "octeon" || 1533 CPUName == "octeon+", 1534 "-march=mips64r2", Flags); 1535 addMultilibFlag(CPUName == "mips64r6", "-march=mips64r6", Flags); 1536 addMultilibFlag(isMicroMips(Args), "-mmicromips", Flags); 1537 addMultilibFlag(tools::mips::isUCLibc(Args), "-muclibc", Flags); 1538 addMultilibFlag(tools::mips::isNaN2008(D, Args, TargetTriple), "-mnan=2008", 1539 Flags); 1540 addMultilibFlag(ABIName == "n32", "-mabi=n32", Flags); 1541 addMultilibFlag(ABIName == "n64", "-mabi=n64", Flags); 1542 addMultilibFlag(isSoftFloatABI(Args), "-msoft-float", Flags); 1543 addMultilibFlag(!isSoftFloatABI(Args), "-mhard-float", Flags); 1544 addMultilibFlag(isMipsEL(TargetArch), "-EL", Flags); 1545 addMultilibFlag(!isMipsEL(TargetArch), "-EB", Flags); 1546 1547 if (TargetTriple.isAndroid()) 1548 return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent, 1549 Result); 1550 1551 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1552 TargetTriple.getOS() == llvm::Triple::Linux && 1553 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) 1554 return findMipsMuslMultilibs(Flags, NonExistent, Result); 1555 1556 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1557 TargetTriple.getOS() == llvm::Triple::Linux && 1558 TargetTriple.isGNUEnvironment()) 1559 return findMipsMtiMultilibs(Flags, NonExistent, Result); 1560 1561 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies && 1562 TargetTriple.getOS() == llvm::Triple::Linux && 1563 TargetTriple.isGNUEnvironment()) 1564 return findMipsImgMultilibs(Flags, NonExistent, Result); 1565 1566 if (findMipsCsMultilibs(Flags, NonExistent, Result)) 1567 return true; 1568 1569 // Fallback to the regular toolchain-tree structure. 1570 Multilib Default; 1571 Result.Multilibs.push_back(Default); 1572 Result.Multilibs.FilterOut(NonExistent); 1573 1574 if (Result.Multilibs.select(Flags, Result.SelectedMultilibs)) { 1575 Result.BiarchSibling = Multilib(); 1576 return true; 1577 } 1578 1579 return false; 1580 } 1581 1582 static void findAndroidArmMultilibs(const Driver &D, 1583 const llvm::Triple &TargetTriple, 1584 StringRef Path, const ArgList &Args, 1585 DetectedMultilibs &Result) { 1586 // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb. 1587 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1588 MultilibBuilder ArmV7Multilib = MultilibBuilder("/armv7-a") 1589 .flag("-march=armv7-a") 1590 .flag("-mthumb", /*Disallow=*/true); 1591 MultilibBuilder ThumbMultilib = MultilibBuilder("/thumb") 1592 .flag("-march=armv7-a", /*Disallow=*/true) 1593 .flag("-mthumb"); 1594 MultilibBuilder ArmV7ThumbMultilib = 1595 MultilibBuilder("/armv7-a/thumb").flag("-march=armv7-a").flag("-mthumb"); 1596 MultilibBuilder DefaultMultilib = 1597 MultilibBuilder("") 1598 .flag("-march=armv7-a", /*Disallow=*/true) 1599 .flag("-mthumb", /*Disallow=*/true); 1600 MultilibSet AndroidArmMultilibs = 1601 MultilibSetBuilder() 1602 .Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib, 1603 DefaultMultilib) 1604 .makeMultilibSet() 1605 .FilterOut(NonExistent); 1606 1607 Multilib::flags_list Flags; 1608 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ); 1609 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm; 1610 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb; 1611 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7; 1612 bool IsThumbMode = IsThumbArch || 1613 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) || 1614 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB); 1615 bool IsArmV7Mode = (IsArmArch || IsThumbArch) && 1616 (llvm::ARM::parseArchVersion(Arch) == 7 || 1617 (IsArmArch && Arch == "" && IsV7SubArch)); 1618 addMultilibFlag(IsArmV7Mode, "-march=armv7-a", Flags); 1619 addMultilibFlag(IsThumbMode, "-mthumb", Flags); 1620 1621 if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilibs)) 1622 Result.Multilibs = AndroidArmMultilibs; 1623 } 1624 1625 static bool findMSP430Multilibs(const Driver &D, 1626 const llvm::Triple &TargetTriple, 1627 StringRef Path, const ArgList &Args, 1628 DetectedMultilibs &Result) { 1629 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1630 MultilibBuilder WithoutExceptions = 1631 MultilibBuilder("/430").flag("-exceptions", /*Disallow=*/true); 1632 MultilibBuilder WithExceptions = 1633 MultilibBuilder("/430/exceptions").flag("-exceptions"); 1634 1635 // FIXME: when clang starts to support msp430x ISA additional logic 1636 // to select between multilib must be implemented 1637 // MultilibBuilder MSP430xMultilib = MultilibBuilder("/large"); 1638 1639 Result.Multilibs.push_back(WithoutExceptions.makeMultilib()); 1640 Result.Multilibs.push_back(WithExceptions.makeMultilib()); 1641 Result.Multilibs.FilterOut(NonExistent); 1642 1643 Multilib::flags_list Flags; 1644 addMultilibFlag(Args.hasFlag(options::OPT_fexceptions, 1645 options::OPT_fno_exceptions, false), 1646 "-exceptions", Flags); 1647 if (Result.Multilibs.select(Flags, Result.SelectedMultilibs)) 1648 return true; 1649 1650 return false; 1651 } 1652 1653 static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple, 1654 StringRef Path, const ArgList &Args, 1655 DetectedMultilibs &Result) { 1656 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1657 1658 tools::csky::FloatABI TheFloatABI = tools::csky::getCSKYFloatABI(D, Args); 1659 std::optional<llvm::StringRef> Res = 1660 tools::csky::getCSKYArchName(D, Args, TargetTriple); 1661 1662 if (!Res) 1663 return; 1664 auto ARCHName = *Res; 1665 1666 Multilib::flags_list Flags; 1667 addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Hard, "-hard-fp", 1668 Flags); 1669 addMultilibFlag(TheFloatABI == tools::csky::FloatABI::SoftFP, "-soft-fp", 1670 Flags); 1671 addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Soft, "-soft", Flags); 1672 addMultilibFlag(ARCHName == "ck801", "-march=ck801", Flags); 1673 addMultilibFlag(ARCHName == "ck802", "-march=ck802", Flags); 1674 addMultilibFlag(ARCHName == "ck803", "-march=ck803", Flags); 1675 addMultilibFlag(ARCHName == "ck804", "-march=ck804", Flags); 1676 addMultilibFlag(ARCHName == "ck805", "-march=ck805", Flags); 1677 addMultilibFlag(ARCHName == "ck807", "-march=ck807", Flags); 1678 addMultilibFlag(ARCHName == "ck810", "-march=ck810", Flags); 1679 addMultilibFlag(ARCHName == "ck810v", "-march=ck810v", Flags); 1680 addMultilibFlag(ARCHName == "ck860", "-march=ck860", Flags); 1681 addMultilibFlag(ARCHName == "ck860v", "-march=ck860v", Flags); 1682 1683 bool isBigEndian = false; 1684 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian, 1685 options::OPT_mbig_endian)) 1686 isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian); 1687 addMultilibFlag(isBigEndian, "-EB", Flags); 1688 1689 auto HardFloat = MultilibBuilder("/hard-fp").flag("-hard-fp"); 1690 auto SoftFpFloat = MultilibBuilder("/soft-fp").flag("-soft-fp"); 1691 auto SoftFloat = MultilibBuilder("").flag("-soft"); 1692 auto Arch801 = MultilibBuilder("/ck801").flag("-march=ck801"); 1693 auto Arch802 = MultilibBuilder("/ck802").flag("-march=ck802"); 1694 auto Arch803 = MultilibBuilder("/ck803").flag("-march=ck803"); 1695 // CK804 use the same library as CK803 1696 auto Arch804 = MultilibBuilder("/ck803").flag("-march=ck804"); 1697 auto Arch805 = MultilibBuilder("/ck805").flag("-march=ck805"); 1698 auto Arch807 = MultilibBuilder("/ck807").flag("-march=ck807"); 1699 auto Arch810 = MultilibBuilder("").flag("-march=ck810"); 1700 auto Arch810v = MultilibBuilder("/ck810v").flag("-march=ck810v"); 1701 auto Arch860 = MultilibBuilder("/ck860").flag("-march=ck860"); 1702 auto Arch860v = MultilibBuilder("/ck860v").flag("-march=ck860v"); 1703 auto BigEndian = MultilibBuilder("/big").flag("-EB"); 1704 1705 MultilibSet CSKYMultilibs = 1706 MultilibSetBuilder() 1707 .Maybe(BigEndian) 1708 .Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807, 1709 Arch810, Arch810v, Arch860, Arch860v}) 1710 .Either(HardFloat, SoftFpFloat, SoftFloat) 1711 .makeMultilibSet() 1712 .FilterOut(NonExistent); 1713 1714 if (CSKYMultilibs.select(Flags, Result.SelectedMultilibs)) 1715 Result.Multilibs = CSKYMultilibs; 1716 } 1717 1718 static void findRISCVBareMetalMultilibs(const Driver &D, 1719 const llvm::Triple &TargetTriple, 1720 StringRef Path, const ArgList &Args, 1721 DetectedMultilibs &Result) { 1722 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1723 struct RiscvMultilib { 1724 StringRef march; 1725 StringRef mabi; 1726 }; 1727 // currently only support the set of multilibs like riscv-gnu-toolchain does. 1728 // TODO: support MULTILIB_REUSE 1729 constexpr RiscvMultilib RISCVMultilibSet[] = { 1730 {"rv32i", "ilp32"}, {"rv32im", "ilp32"}, {"rv32iac", "ilp32"}, 1731 {"rv32imac", "ilp32"}, {"rv32imafc", "ilp32f"}, {"rv64imac", "lp64"}, 1732 {"rv64imafdc", "lp64d"}}; 1733 1734 std::vector<MultilibBuilder> Ms; 1735 for (auto Element : RISCVMultilibSet) { 1736 // multilib path rule is ${march}/${mabi} 1737 Ms.emplace_back( 1738 MultilibBuilder( 1739 (Twine(Element.march) + "/" + Twine(Element.mabi)).str()) 1740 .flag(Twine("-march=", Element.march).str()) 1741 .flag(Twine("-mabi=", Element.mabi).str())); 1742 } 1743 MultilibSet RISCVMultilibs = 1744 MultilibSetBuilder() 1745 .Either(Ms) 1746 .makeMultilibSet() 1747 .FilterOut(NonExistent) 1748 .setFilePathsCallback([](const Multilib &M) { 1749 return std::vector<std::string>( 1750 {M.gccSuffix(), 1751 "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(), 1752 "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()}); 1753 }); 1754 1755 Multilib::flags_list Flags; 1756 llvm::StringSet<> Added_ABIs; 1757 StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple); 1758 StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple); 1759 for (auto Element : RISCVMultilibSet) { 1760 addMultilibFlag(MArch == Element.march, 1761 Twine("-march=", Element.march).str().c_str(), Flags); 1762 if (!Added_ABIs.count(Element.mabi)) { 1763 Added_ABIs.insert(Element.mabi); 1764 addMultilibFlag(ABIName == Element.mabi, 1765 Twine("-mabi=", Element.mabi).str().c_str(), Flags); 1766 } 1767 } 1768 1769 if (RISCVMultilibs.select(Flags, Result.SelectedMultilibs)) 1770 Result.Multilibs = RISCVMultilibs; 1771 } 1772 1773 static void findRISCVMultilibs(const Driver &D, 1774 const llvm::Triple &TargetTriple, StringRef Path, 1775 const ArgList &Args, DetectedMultilibs &Result) { 1776 if (TargetTriple.getOS() == llvm::Triple::UnknownOS) 1777 return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result); 1778 1779 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1780 MultilibBuilder Ilp32 = 1781 MultilibBuilder("lib32/ilp32").flag("-m32").flag("-mabi=ilp32"); 1782 MultilibBuilder Ilp32f = 1783 MultilibBuilder("lib32/ilp32f").flag("-m32").flag("-mabi=ilp32f"); 1784 MultilibBuilder Ilp32d = 1785 MultilibBuilder("lib32/ilp32d").flag("-m32").flag("-mabi=ilp32d"); 1786 MultilibBuilder Lp64 = 1787 MultilibBuilder("lib64/lp64").flag("-m64").flag("-mabi=lp64"); 1788 MultilibBuilder Lp64f = 1789 MultilibBuilder("lib64/lp64f").flag("-m64").flag("-mabi=lp64f"); 1790 MultilibBuilder Lp64d = 1791 MultilibBuilder("lib64/lp64d").flag("-m64").flag("-mabi=lp64d"); 1792 MultilibSet RISCVMultilibs = 1793 MultilibSetBuilder() 1794 .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d}) 1795 .makeMultilibSet() 1796 .FilterOut(NonExistent); 1797 1798 Multilib::flags_list Flags; 1799 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64; 1800 StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple); 1801 1802 addMultilibFlag(!IsRV64, "-m32", Flags); 1803 addMultilibFlag(IsRV64, "-m64", Flags); 1804 addMultilibFlag(ABIName == "ilp32", "-mabi=ilp32", Flags); 1805 addMultilibFlag(ABIName == "ilp32f", "-mabi=ilp32f", Flags); 1806 addMultilibFlag(ABIName == "ilp32d", "-mabi=ilp32d", Flags); 1807 addMultilibFlag(ABIName == "lp64", "-mabi=lp64", Flags); 1808 addMultilibFlag(ABIName == "lp64f", "-mabi=lp64f", Flags); 1809 addMultilibFlag(ABIName == "lp64d", "-mabi=lp64d", Flags); 1810 1811 if (RISCVMultilibs.select(Flags, Result.SelectedMultilibs)) 1812 Result.Multilibs = RISCVMultilibs; 1813 } 1814 1815 static bool findBiarchMultilibs(const Driver &D, 1816 const llvm::Triple &TargetTriple, 1817 StringRef Path, const ArgList &Args, 1818 bool NeedsBiarchSuffix, 1819 DetectedMultilibs &Result) { 1820 MultilibBuilder DefaultBuilder; 1821 1822 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs 1823 // in what would normally be GCCInstallPath and put the 64-bit 1824 // libs in a subdirectory named 64. The simple logic we follow is that 1825 // *if* there is a subdirectory of the right name with crtbegin.o in it, 1826 // we use that. If not, and if not a biarch triple alias, we look for 1827 // crtbegin.o without the subdirectory. 1828 1829 StringRef Suff64 = "/64"; 1830 // Solaris uses platform-specific suffixes instead of /64. 1831 if (TargetTriple.isOSSolaris()) { 1832 switch (TargetTriple.getArch()) { 1833 case llvm::Triple::x86: 1834 case llvm::Triple::x86_64: 1835 Suff64 = "/amd64"; 1836 break; 1837 case llvm::Triple::sparc: 1838 case llvm::Triple::sparcv9: 1839 Suff64 = "/sparcv9"; 1840 break; 1841 default: 1842 break; 1843 } 1844 } 1845 1846 Multilib Alt64 = MultilibBuilder() 1847 .gccSuffix(Suff64) 1848 .includeSuffix(Suff64) 1849 .flag("-m32", /*Disallow=*/true) 1850 .flag("-m64") 1851 .flag("-mx32", /*Disallow=*/true) 1852 .makeMultilib(); 1853 Multilib Alt32 = MultilibBuilder() 1854 .gccSuffix("/32") 1855 .includeSuffix("/32") 1856 .flag("-m32") 1857 .flag("-m64", /*Disallow=*/true) 1858 .flag("-mx32", /*Disallow=*/true) 1859 .makeMultilib(); 1860 Multilib Altx32 = MultilibBuilder() 1861 .gccSuffix("/x32") 1862 .includeSuffix("/x32") 1863 .flag("-m32", /*Disallow=*/true) 1864 .flag("-m64", /*Disallow=*/true) 1865 .flag("-mx32") 1866 .makeMultilib(); 1867 Multilib Alt32sparc = MultilibBuilder() 1868 .gccSuffix("/sparcv8plus") 1869 .includeSuffix("/sparcv8plus") 1870 .flag("-m32") 1871 .flag("-m64", /*Disallow=*/true) 1872 .makeMultilib(); 1873 1874 // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a. 1875 FilterNonExistent NonExistent( 1876 Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS()); 1877 1878 // Determine default multilib from: 32, 64, x32 1879 // Also handle cases such as 64 on 32, 32 on 64, etc. 1880 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN; 1881 const bool IsX32 = TargetTriple.isX32(); 1882 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32)) 1883 Want = WANT64; 1884 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32sparc)) 1885 Want = WANT64; 1886 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32)) 1887 Want = WANT64; 1888 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64)) 1889 Want = WANT32; 1890 else if (TargetTriple.isArch64Bit() && !NonExistent(Alt32sparc)) 1891 Want = WANT64; 1892 else { 1893 if (TargetTriple.isArch32Bit()) 1894 Want = NeedsBiarchSuffix ? WANT64 : WANT32; 1895 else if (IsX32) 1896 Want = NeedsBiarchSuffix ? WANT64 : WANTX32; 1897 else 1898 Want = NeedsBiarchSuffix ? WANT32 : WANT64; 1899 } 1900 1901 if (Want == WANT32) 1902 DefaultBuilder.flag("-m32") 1903 .flag("-m64", /*Disallow=*/true) 1904 .flag("-mx32", /*Disallow=*/true); 1905 else if (Want == WANT64) 1906 DefaultBuilder.flag("-m32", /*Disallow=*/true) 1907 .flag("-m64") 1908 .flag("-mx32", /*Disallow=*/true); 1909 else if (Want == WANTX32) 1910 DefaultBuilder.flag("-m32", /*Disallow=*/true) 1911 .flag("-m64", /*Disallow=*/true) 1912 .flag("-mx32"); 1913 else 1914 return false; 1915 1916 Multilib Default = DefaultBuilder.makeMultilib(); 1917 1918 Result.Multilibs.push_back(Default); 1919 Result.Multilibs.push_back(Alt64); 1920 Result.Multilibs.push_back(Alt32); 1921 Result.Multilibs.push_back(Altx32); 1922 Result.Multilibs.push_back(Alt32sparc); 1923 1924 Result.Multilibs.FilterOut(NonExistent); 1925 1926 Multilib::flags_list Flags; 1927 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "-m64", Flags); 1928 addMultilibFlag(TargetTriple.isArch32Bit(), "-m32", Flags); 1929 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "-mx32", Flags); 1930 1931 if (!Result.Multilibs.select(Flags, Result.SelectedMultilibs)) 1932 return false; 1933 1934 if (Result.SelectedMultilibs.back() == Alt64 || 1935 Result.SelectedMultilibs.back() == Alt32 || 1936 Result.SelectedMultilibs.back() == Altx32 || 1937 Result.SelectedMultilibs.back() == Alt32sparc) 1938 Result.BiarchSibling = Default; 1939 1940 return true; 1941 } 1942 1943 /// Generic_GCC - A tool chain using the 'gcc' command to perform 1944 /// all subcommands; this relies on gcc translating the majority of 1945 /// command line options. 1946 1947 /// Less-than for GCCVersion, implementing a Strict Weak Ordering. 1948 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor, 1949 int RHSPatch, 1950 StringRef RHSPatchSuffix) const { 1951 if (Major != RHSMajor) 1952 return Major < RHSMajor; 1953 if (Minor != RHSMinor) { 1954 // Note that versions without a specified minor sort higher than those with 1955 // a minor. 1956 if (RHSMinor == -1) 1957 return true; 1958 if (Minor == -1) 1959 return false; 1960 return Minor < RHSMinor; 1961 } 1962 if (Patch != RHSPatch) { 1963 // Note that versions without a specified patch sort higher than those with 1964 // a patch. 1965 if (RHSPatch == -1) 1966 return true; 1967 if (Patch == -1) 1968 return false; 1969 1970 // Otherwise just sort on the patch itself. 1971 return Patch < RHSPatch; 1972 } 1973 if (PatchSuffix != RHSPatchSuffix) { 1974 // Sort empty suffixes higher. 1975 if (RHSPatchSuffix.empty()) 1976 return true; 1977 if (PatchSuffix.empty()) 1978 return false; 1979 1980 // Provide a lexicographic sort to make this a total ordering. 1981 return PatchSuffix < RHSPatchSuffix; 1982 } 1983 1984 // The versions are equal. 1985 return false; 1986 } 1987 1988 /// Parse a GCCVersion object out of a string of text. 1989 /// 1990 /// This is the primary means of forming GCCVersion objects. 1991 /*static*/ 1992 Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) { 1993 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; 1994 std::pair<StringRef, StringRef> First = VersionText.split('.'); 1995 std::pair<StringRef, StringRef> Second = First.second.split('.'); 1996 1997 StringRef MajorStr = First.first; 1998 StringRef MinorStr = Second.first; 1999 StringRef PatchStr = Second.second; 2000 2001 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; 2002 2003 // Parse version number strings such as: 2004 // 5 2005 // 4.4 2006 // 4.4-patched 2007 // 4.4.0 2008 // 4.4.x 2009 // 4.4.2-rc4 2010 // 4.4.x-patched 2011 // 10-win32 2012 // Split on '.', handle 1, 2 or 3 such segments. Each segment must contain 2013 // purely a number, except for the last one, where a non-number suffix 2014 // is stored in PatchSuffix. The third segment is allowed to not contain 2015 // a number at all. 2016 2017 auto TryParseLastNumber = [&](StringRef Segment, int &Number, 2018 std::string &OutStr) -> bool { 2019 // Look for a number prefix and parse that, and split out any trailing 2020 // string into GoodVersion.PatchSuffix. 2021 2022 if (size_t EndNumber = Segment.find_first_not_of("0123456789")) { 2023 StringRef NumberStr = Segment.slice(0, EndNumber); 2024 if (NumberStr.getAsInteger(10, Number) || Number < 0) 2025 return false; 2026 OutStr = NumberStr; 2027 GoodVersion.PatchSuffix = Segment.substr(EndNumber); 2028 return true; 2029 } 2030 return false; 2031 }; 2032 auto TryParseNumber = [](StringRef Segment, int &Number) -> bool { 2033 if (Segment.getAsInteger(10, Number) || Number < 0) 2034 return false; 2035 return true; 2036 }; 2037 2038 if (MinorStr.empty()) { 2039 // If no minor string, major is the last segment 2040 if (!TryParseLastNumber(MajorStr, GoodVersion.Major, GoodVersion.MajorStr)) 2041 return BadVersion; 2042 return GoodVersion; 2043 } 2044 2045 if (!TryParseNumber(MajorStr, GoodVersion.Major)) 2046 return BadVersion; 2047 GoodVersion.MajorStr = MajorStr; 2048 2049 if (PatchStr.empty()) { 2050 // If no patch string, minor is the last segment 2051 if (!TryParseLastNumber(MinorStr, GoodVersion.Minor, GoodVersion.MinorStr)) 2052 return BadVersion; 2053 return GoodVersion; 2054 } 2055 2056 if (!TryParseNumber(MinorStr, GoodVersion.Minor)) 2057 return BadVersion; 2058 GoodVersion.MinorStr = MinorStr; 2059 2060 // For the last segment, tolerate a missing number. 2061 std::string DummyStr; 2062 TryParseLastNumber(PatchStr, GoodVersion.Patch, DummyStr); 2063 return GoodVersion; 2064 } 2065 2066 static llvm::StringRef getGCCToolchainDir(const ArgList &Args, 2067 llvm::StringRef SysRoot) { 2068 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain); 2069 if (A) 2070 return A->getValue(); 2071 2072 // If we have a SysRoot, ignore GCC_INSTALL_PREFIX. 2073 // GCC_INSTALL_PREFIX specifies the gcc installation for the default 2074 // sysroot and is likely not valid with a different sysroot. 2075 if (!SysRoot.empty()) 2076 return ""; 2077 2078 return GCC_INSTALL_PREFIX; 2079 } 2080 2081 /// Initialize a GCCInstallationDetector from the driver. 2082 /// 2083 /// This performs all of the autodetection and sets up the various paths. 2084 /// Once constructed, a GCCInstallationDetector is essentially immutable. 2085 /// 2086 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and 2087 /// should instead pull the target out of the driver. This is currently 2088 /// necessary because the driver doesn't store the final version of the target 2089 /// triple. 2090 void Generic_GCC::GCCInstallationDetector::init( 2091 const llvm::Triple &TargetTriple, const ArgList &Args) { 2092 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit() 2093 ? TargetTriple.get64BitArchVariant() 2094 : TargetTriple.get32BitArchVariant(); 2095 // The library directories which may contain GCC installations. 2096 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs; 2097 // The compatible GCC triples for this particular architecture. 2098 SmallVector<StringRef, 16> CandidateTripleAliases; 2099 SmallVector<StringRef, 16> CandidateBiarchTripleAliases; 2100 // Add some triples that we want to check first. 2101 CandidateTripleAliases.push_back(TargetTriple.str()); 2102 std::string TripleNoVendor = TargetTriple.getArchName().str() + "-" + 2103 TargetTriple.getOSAndEnvironmentName().str(); 2104 if (TargetTriple.getVendor() == llvm::Triple::UnknownVendor) 2105 CandidateTripleAliases.push_back(TripleNoVendor); 2106 2107 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs, 2108 CandidateTripleAliases, CandidateBiarchLibDirs, 2109 CandidateBiarchTripleAliases); 2110 2111 // If --gcc-install-dir= is specified, skip filesystem detection. 2112 if (const Arg *A = 2113 Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ); 2114 A && A->getValue()[0]) { 2115 StringRef InstallDir = A->getValue(); 2116 if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir, false)) { 2117 D.Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir; 2118 } else { 2119 (void)InstallDir.consume_back("/"); 2120 StringRef VersionText = llvm::sys::path::filename(InstallDir); 2121 StringRef TripleText = 2122 llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir)); 2123 2124 Version = GCCVersion::Parse(VersionText); 2125 GCCTriple.setTriple(TripleText); 2126 GCCInstallPath = std::string(InstallDir); 2127 GCCParentLibPath = GCCInstallPath + "/../../.."; 2128 IsValid = true; 2129 } 2130 return; 2131 } 2132 2133 // Compute the set of prefixes for our search. 2134 SmallVector<std::string, 8> Prefixes; 2135 StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot); 2136 if (GCCToolchainDir != "") { 2137 if (GCCToolchainDir.back() == '/') 2138 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the / 2139 2140 Prefixes.push_back(std::string(GCCToolchainDir)); 2141 } else { 2142 // If we have a SysRoot, try that first. 2143 if (!D.SysRoot.empty()) { 2144 Prefixes.push_back(D.SysRoot); 2145 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot); 2146 } 2147 2148 // Then look for gcc installed alongside clang. 2149 Prefixes.push_back(D.InstalledDir + "/.."); 2150 2151 // Next, look for prefix(es) that correspond to distribution-supplied gcc 2152 // installations. 2153 if (D.SysRoot.empty()) { 2154 // Typically /usr. 2155 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot); 2156 } 2157 2158 // Try to respect gcc-config on Gentoo if --gcc-toolchain is not provided. 2159 // This avoids accidentally enforcing the system GCC version when using a 2160 // custom toolchain. 2161 SmallVector<StringRef, 16> GentooTestTriples; 2162 // Try to match an exact triple as target triple first. 2163 // e.g. crossdev -S x86_64-gentoo-linux-gnu will install gcc libs for 2164 // x86_64-gentoo-linux-gnu. But "clang -target x86_64-gentoo-linux-gnu" 2165 // may pick the libraries for x86_64-pc-linux-gnu even when exact matching 2166 // triple x86_64-gentoo-linux-gnu is present. 2167 GentooTestTriples.push_back(TargetTriple.str()); 2168 GentooTestTriples.append(CandidateTripleAliases.begin(), 2169 CandidateTripleAliases.end()); 2170 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples, 2171 CandidateBiarchTripleAliases)) 2172 return; 2173 } 2174 2175 // Loop over the various components which exist and select the best GCC 2176 // installation available. GCC installs are ranked by version number. 2177 const GCCVersion VersionZero = GCCVersion::Parse("0.0.0"); 2178 Version = VersionZero; 2179 for (const std::string &Prefix : Prefixes) { 2180 auto &VFS = D.getVFS(); 2181 if (!VFS.exists(Prefix)) 2182 continue; 2183 for (StringRef Suffix : CandidateLibDirs) { 2184 const std::string LibDir = concat(Prefix, Suffix); 2185 if (!VFS.exists(LibDir)) 2186 continue; 2187 // Maybe filter out <libdir>/gcc and <libdir>/gcc-cross. 2188 bool GCCDirExists = VFS.exists(LibDir + "/gcc"); 2189 bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross"); 2190 for (StringRef Candidate : CandidateTripleAliases) 2191 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, false, 2192 GCCDirExists, GCCCrossDirExists); 2193 } 2194 for (StringRef Suffix : CandidateBiarchLibDirs) { 2195 const std::string LibDir = Prefix + Suffix.str(); 2196 if (!VFS.exists(LibDir)) 2197 continue; 2198 bool GCCDirExists = VFS.exists(LibDir + "/gcc"); 2199 bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross"); 2200 for (StringRef Candidate : CandidateBiarchTripleAliases) 2201 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, true, 2202 GCCDirExists, GCCCrossDirExists); 2203 } 2204 2205 // Skip other prefixes once a GCC installation is found. 2206 if (Version > VersionZero) 2207 break; 2208 } 2209 } 2210 2211 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const { 2212 for (const auto &InstallPath : CandidateGCCInstallPaths) 2213 OS << "Found candidate GCC installation: " << InstallPath << "\n"; 2214 2215 if (!GCCInstallPath.empty()) 2216 OS << "Selected GCC installation: " << GCCInstallPath << "\n"; 2217 2218 for (const auto &Multilib : Multilibs) 2219 OS << "Candidate multilib: " << Multilib << "\n"; 2220 2221 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault()) 2222 OS << "Selected multilib: " << SelectedMultilib << "\n"; 2223 } 2224 2225 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const { 2226 if (BiarchSibling) { 2227 M = *BiarchSibling; 2228 return true; 2229 } 2230 return false; 2231 } 2232 2233 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( 2234 const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes, 2235 StringRef SysRoot) { 2236 2237 if (TargetTriple.isOSHaiku()) { 2238 Prefixes.push_back(concat(SysRoot, "/boot/system/develop/tools")); 2239 return; 2240 } 2241 2242 if (TargetTriple.isOSSolaris()) { 2243 // Solaris is a special case. 2244 // The GCC installation is under 2245 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/ 2246 // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with 2247 // /usr/gcc/<version> as a prefix. 2248 2249 SmallVector<std::pair<GCCVersion, std::string>, 8> SolarisPrefixes; 2250 std::string PrefixDir = concat(SysRoot, "/usr/gcc"); 2251 std::error_code EC; 2252 for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC), 2253 LE; 2254 !EC && LI != LE; LI = LI.increment(EC)) { 2255 StringRef VersionText = llvm::sys::path::filename(LI->path()); 2256 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2257 2258 // Filter out obviously bad entries. 2259 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1)) 2260 continue; 2261 2262 std::string CandidatePrefix = PrefixDir + "/" + VersionText.str(); 2263 std::string CandidateLibPath = CandidatePrefix + "/lib/gcc"; 2264 if (!D.getVFS().exists(CandidateLibPath)) 2265 continue; 2266 2267 SolarisPrefixes.emplace_back( 2268 std::make_pair(CandidateVersion, CandidatePrefix)); 2269 } 2270 // Sort in reverse order so GCCInstallationDetector::init picks the latest. 2271 std::sort(SolarisPrefixes.rbegin(), SolarisPrefixes.rend()); 2272 for (auto p : SolarisPrefixes) 2273 Prefixes.emplace_back(p.second); 2274 return; 2275 } 2276 2277 // For Linux, if --sysroot is not specified, look for RHEL/CentOS devtoolsets 2278 // and gcc-toolsets. 2279 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux && 2280 D.getVFS().exists("/opt/rh")) { 2281 // TODO: We may want to remove this, since the functionality 2282 // can be achieved using config files. 2283 Prefixes.push_back("/opt/rh/gcc-toolset-12/root/usr"); 2284 Prefixes.push_back("/opt/rh/gcc-toolset-11/root/usr"); 2285 Prefixes.push_back("/opt/rh/gcc-toolset-10/root/usr"); 2286 Prefixes.push_back("/opt/rh/devtoolset-12/root/usr"); 2287 Prefixes.push_back("/opt/rh/devtoolset-11/root/usr"); 2288 Prefixes.push_back("/opt/rh/devtoolset-10/root/usr"); 2289 Prefixes.push_back("/opt/rh/devtoolset-9/root/usr"); 2290 Prefixes.push_back("/opt/rh/devtoolset-8/root/usr"); 2291 Prefixes.push_back("/opt/rh/devtoolset-7/root/usr"); 2292 Prefixes.push_back("/opt/rh/devtoolset-6/root/usr"); 2293 Prefixes.push_back("/opt/rh/devtoolset-4/root/usr"); 2294 Prefixes.push_back("/opt/rh/devtoolset-3/root/usr"); 2295 Prefixes.push_back("/opt/rh/devtoolset-2/root/usr"); 2296 } 2297 2298 // Fall back to /usr which is used by most non-Solaris systems. 2299 Prefixes.push_back(concat(SysRoot, "/usr")); 2300 } 2301 2302 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples( 2303 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple, 2304 SmallVectorImpl<StringRef> &LibDirs, 2305 SmallVectorImpl<StringRef> &TripleAliases, 2306 SmallVectorImpl<StringRef> &BiarchLibDirs, 2307 SmallVectorImpl<StringRef> &BiarchTripleAliases) { 2308 // Declare a bunch of static data sets that we'll select between below. These 2309 // are specifically designed to always refer to string literals to avoid any 2310 // lifetime or initialization issues. 2311 // 2312 // The *Triples variables hard code some triples so that, for example, 2313 // --target=aarch64 (incomplete triple) can detect lib/aarch64-linux-gnu. 2314 // They are not needed when the user has correct LLVM_DEFAULT_TARGET_TRIPLE 2315 // and always uses the full --target (e.g. --target=aarch64-linux-gnu). The 2316 // lists should shrink over time. Please don't add more elements to *Triples. 2317 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; 2318 static const char *const AArch64Triples[] = { 2319 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", 2320 "aarch64-suse-linux"}; 2321 static const char *const AArch64beLibDirs[] = {"/lib"}; 2322 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", 2323 "aarch64_be-linux-gnu"}; 2324 2325 static const char *const ARMLibDirs[] = {"/lib"}; 2326 static const char *const ARMTriples[] = {"arm-linux-gnueabi"}; 2327 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf", 2328 "armv7hl-redhat-linux-gnueabi", 2329 "armv6hl-suse-linux-gnueabi", 2330 "armv7hl-suse-linux-gnueabi"}; 2331 static const char *const ARMebLibDirs[] = {"/lib"}; 2332 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi"}; 2333 static const char *const ARMebHFTriples[] = { 2334 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"}; 2335 2336 static const char *const AVRLibDirs[] = {"/lib"}; 2337 static const char *const AVRTriples[] = {"avr"}; 2338 2339 static const char *const CSKYLibDirs[] = {"/lib"}; 2340 static const char *const CSKYTriples[] = { 2341 "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2"}; 2342 2343 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"}; 2344 static const char *const X86_64Triples[] = { 2345 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", 2346 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E", 2347 "x86_64-redhat-linux", "x86_64-suse-linux", 2348 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", 2349 "x86_64-slackware-linux", "x86_64-unknown-linux", 2350 "x86_64-amazon-linux"}; 2351 static const char *const X32Triples[] = {"x86_64-linux-gnux32", 2352 "x86_64-pc-linux-gnux32"}; 2353 static const char *const X32LibDirs[] = {"/libx32", "/lib"}; 2354 static const char *const X86LibDirs[] = {"/lib32", "/lib"}; 2355 static const char *const X86Triples[] = { 2356 "i586-linux-gnu", "i686-linux-gnu", "i686-pc-linux-gnu", 2357 "i386-redhat-linux6E", "i686-redhat-linux", "i386-redhat-linux", 2358 "i586-suse-linux", "i686-montavista-linux", "i686-gnu", 2359 }; 2360 2361 static const char *const LoongArch64LibDirs[] = {"/lib64", "/lib"}; 2362 static const char *const LoongArch64Triples[] = { 2363 "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu"}; 2364 2365 static const char *const M68kLibDirs[] = {"/lib"}; 2366 static const char *const M68kTriples[] = { 2367 "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux"}; 2368 2369 static const char *const MIPSLibDirs[] = {"/libo32", "/lib"}; 2370 static const char *const MIPSTriples[] = { 2371 "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu", 2372 "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"}; 2373 static const char *const MIPSELLibDirs[] = {"/libo32", "/lib"}; 2374 static const char *const MIPSELTriples[] = { 2375 "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu"}; 2376 2377 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"}; 2378 static const char *const MIPS64Triples[] = { 2379 "mips64-linux-gnu", "mips-mti-linux-gnu", 2380 "mips-img-linux-gnu", "mips64-linux-gnuabi64", 2381 "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64"}; 2382 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"}; 2383 static const char *const MIPS64ELTriples[] = { 2384 "mips64el-linux-gnu", "mips-mti-linux-gnu", 2385 "mips-img-linux-gnu", "mips64el-linux-gnuabi64", 2386 "mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64"}; 2387 2388 static const char *const MIPSN32LibDirs[] = {"/lib32"}; 2389 static const char *const MIPSN32Triples[] = {"mips64-linux-gnuabin32", 2390 "mipsisa64r6-linux-gnuabin32"}; 2391 static const char *const MIPSN32ELLibDirs[] = {"/lib32"}; 2392 static const char *const MIPSN32ELTriples[] = { 2393 "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32"}; 2394 2395 static const char *const MSP430LibDirs[] = {"/lib"}; 2396 static const char *const MSP430Triples[] = {"msp430-elf"}; 2397 2398 static const char *const PPCLibDirs[] = {"/lib32", "/lib"}; 2399 static const char *const PPCTriples[] = { 2400 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe", 2401 // On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a 2402 // 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux". 2403 "powerpc64-suse-linux", "powerpc-montavista-linuxspe"}; 2404 static const char *const PPCLELibDirs[] = {"/lib32", "/lib"}; 2405 static const char *const PPCLETriples[] = {"powerpcle-linux-gnu", 2406 "powerpcle-unknown-linux-gnu", 2407 "powerpcle-linux-musl"}; 2408 2409 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"}; 2410 static const char *const PPC64Triples[] = { 2411 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu", 2412 "powerpc64-suse-linux", "ppc64-redhat-linux"}; 2413 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"}; 2414 static const char *const PPC64LETriples[] = { 2415 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu", 2416 "powerpc64le-none-linux-gnu", "powerpc64le-suse-linux", 2417 "ppc64le-redhat-linux"}; 2418 2419 static const char *const RISCV32LibDirs[] = {"/lib32", "/lib"}; 2420 static const char *const RISCV32Triples[] = {"riscv32-unknown-linux-gnu", 2421 "riscv32-linux-gnu", 2422 "riscv32-unknown-elf"}; 2423 static const char *const RISCV64LibDirs[] = {"/lib64", "/lib"}; 2424 static const char *const RISCV64Triples[] = {"riscv64-unknown-linux-gnu", 2425 "riscv64-linux-gnu", 2426 "riscv64-unknown-elf"}; 2427 2428 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"}; 2429 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu", 2430 "sparcv8-linux-gnu"}; 2431 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"}; 2432 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu", 2433 "sparcv9-linux-gnu"}; 2434 2435 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"}; 2436 static const char *const SystemZTriples[] = { 2437 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu", 2438 "s390x-suse-linux", "s390x-redhat-linux"}; 2439 2440 2441 using std::begin; 2442 using std::end; 2443 2444 if (TargetTriple.isOSSolaris()) { 2445 static const char *const SolarisLibDirs[] = {"/lib"}; 2446 static const char *const SolarisSparcV8Triples[] = { 2447 "sparc-sun-solaris2.11"}; 2448 static const char *const SolarisSparcV9Triples[] = { 2449 "sparcv9-sun-solaris2.11"}; 2450 static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11"}; 2451 static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11"}; 2452 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs)); 2453 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs)); 2454 switch (TargetTriple.getArch()) { 2455 case llvm::Triple::x86: 2456 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples)); 2457 BiarchTripleAliases.append(begin(SolarisX86_64Triples), 2458 end(SolarisX86_64Triples)); 2459 break; 2460 case llvm::Triple::x86_64: 2461 TripleAliases.append(begin(SolarisX86_64Triples), 2462 end(SolarisX86_64Triples)); 2463 BiarchTripleAliases.append(begin(SolarisX86Triples), 2464 end(SolarisX86Triples)); 2465 break; 2466 case llvm::Triple::sparc: 2467 TripleAliases.append(begin(SolarisSparcV8Triples), 2468 end(SolarisSparcV8Triples)); 2469 BiarchTripleAliases.append(begin(SolarisSparcV9Triples), 2470 end(SolarisSparcV9Triples)); 2471 break; 2472 case llvm::Triple::sparcv9: 2473 TripleAliases.append(begin(SolarisSparcV9Triples), 2474 end(SolarisSparcV9Triples)); 2475 BiarchTripleAliases.append(begin(SolarisSparcV8Triples), 2476 end(SolarisSparcV8Triples)); 2477 break; 2478 default: 2479 break; 2480 } 2481 return; 2482 } 2483 2484 // Android targets should not use GNU/Linux tools or libraries. 2485 if (TargetTriple.isAndroid()) { 2486 static const char *const AArch64AndroidTriples[] = { 2487 "aarch64-linux-android"}; 2488 static const char *const ARMAndroidTriples[] = {"arm-linux-androideabi"}; 2489 static const char *const X86AndroidTriples[] = {"i686-linux-android"}; 2490 static const char *const X86_64AndroidTriples[] = {"x86_64-linux-android"}; 2491 2492 switch (TargetTriple.getArch()) { 2493 case llvm::Triple::aarch64: 2494 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 2495 TripleAliases.append(begin(AArch64AndroidTriples), 2496 end(AArch64AndroidTriples)); 2497 break; 2498 case llvm::Triple::arm: 2499 case llvm::Triple::thumb: 2500 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs)); 2501 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples)); 2502 break; 2503 case llvm::Triple::x86_64: 2504 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 2505 TripleAliases.append(begin(X86_64AndroidTriples), 2506 end(X86_64AndroidTriples)); 2507 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 2508 BiarchTripleAliases.append(begin(X86AndroidTriples), 2509 end(X86AndroidTriples)); 2510 break; 2511 case llvm::Triple::x86: 2512 LibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 2513 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples)); 2514 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 2515 BiarchTripleAliases.append(begin(X86_64AndroidTriples), 2516 end(X86_64AndroidTriples)); 2517 break; 2518 default: 2519 break; 2520 } 2521 2522 return; 2523 } 2524 2525 switch (TargetTriple.getArch()) { 2526 case llvm::Triple::aarch64: 2527 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 2528 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 2529 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 2530 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 2531 break; 2532 case llvm::Triple::aarch64_be: 2533 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 2534 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 2535 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 2536 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 2537 break; 2538 case llvm::Triple::arm: 2539 case llvm::Triple::thumb: 2540 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs)); 2541 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 2542 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples)); 2543 } else { 2544 TripleAliases.append(begin(ARMTriples), end(ARMTriples)); 2545 } 2546 break; 2547 case llvm::Triple::armeb: 2548 case llvm::Triple::thumbeb: 2549 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs)); 2550 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 2551 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples)); 2552 } else { 2553 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples)); 2554 } 2555 break; 2556 case llvm::Triple::avr: 2557 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs)); 2558 TripleAliases.append(begin(AVRTriples), end(AVRTriples)); 2559 break; 2560 case llvm::Triple::csky: 2561 LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs)); 2562 TripleAliases.append(begin(CSKYTriples), end(CSKYTriples)); 2563 break; 2564 case llvm::Triple::x86_64: 2565 if (TargetTriple.isX32()) { 2566 LibDirs.append(begin(X32LibDirs), end(X32LibDirs)); 2567 TripleAliases.append(begin(X32Triples), end(X32Triples)); 2568 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 2569 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 2570 } else { 2571 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 2572 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 2573 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs)); 2574 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples)); 2575 } 2576 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 2577 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples)); 2578 break; 2579 case llvm::Triple::x86: 2580 LibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 2581 // MCU toolchain is 32 bit only and its triple alias is TargetTriple 2582 // itself, which will be appended below. 2583 if (!TargetTriple.isOSIAMCU()) { 2584 TripleAliases.append(begin(X86Triples), end(X86Triples)); 2585 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 2586 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 2587 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs)); 2588 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples)); 2589 } 2590 break; 2591 // TODO: Handle loongarch32. 2592 case llvm::Triple::loongarch64: 2593 LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs)); 2594 TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples)); 2595 break; 2596 case llvm::Triple::m68k: 2597 LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs)); 2598 TripleAliases.append(begin(M68kTriples), end(M68kTriples)); 2599 break; 2600 case llvm::Triple::mips: 2601 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 2602 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 2603 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 2604 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 2605 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs)); 2606 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples)); 2607 break; 2608 case llvm::Triple::mipsel: 2609 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 2610 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 2611 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 2612 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 2613 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 2614 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs)); 2615 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples)); 2616 break; 2617 case llvm::Triple::mips64: 2618 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 2619 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 2620 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 2621 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 2622 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs)); 2623 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples)); 2624 break; 2625 case llvm::Triple::mips64el: 2626 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 2627 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 2628 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 2629 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 2630 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs)); 2631 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples)); 2632 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 2633 break; 2634 case llvm::Triple::msp430: 2635 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs)); 2636 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples)); 2637 break; 2638 case llvm::Triple::ppc: 2639 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 2640 TripleAliases.append(begin(PPCTriples), end(PPCTriples)); 2641 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 2642 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 2643 break; 2644 case llvm::Triple::ppcle: 2645 LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs)); 2646 TripleAliases.append(begin(PPCLETriples), end(PPCLETriples)); 2647 BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs)); 2648 BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples)); 2649 break; 2650 case llvm::Triple::ppc64: 2651 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 2652 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 2653 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 2654 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples)); 2655 break; 2656 case llvm::Triple::ppc64le: 2657 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs)); 2658 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples)); 2659 BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs)); 2660 BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples)); 2661 break; 2662 case llvm::Triple::riscv32: 2663 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs)); 2664 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples)); 2665 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs)); 2666 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples)); 2667 break; 2668 case llvm::Triple::riscv64: 2669 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs)); 2670 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples)); 2671 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs)); 2672 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples)); 2673 break; 2674 case llvm::Triple::sparc: 2675 case llvm::Triple::sparcel: 2676 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 2677 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 2678 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 2679 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 2680 break; 2681 case llvm::Triple::sparcv9: 2682 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 2683 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 2684 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 2685 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 2686 break; 2687 case llvm::Triple::systemz: 2688 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs)); 2689 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples)); 2690 break; 2691 default: 2692 // By default, just rely on the standard lib directories and the original 2693 // triple. 2694 break; 2695 } 2696 2697 // Also include the multiarch variant if it's different. 2698 if (TargetTriple.str() != BiarchTriple.str()) 2699 BiarchTripleAliases.push_back(BiarchTriple.str()); 2700 } 2701 2702 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs( 2703 const llvm::Triple &TargetTriple, const ArgList &Args, 2704 StringRef Path, bool NeedsBiarchSuffix) { 2705 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 2706 DetectedMultilibs Detected; 2707 2708 // Android standalone toolchain could have multilibs for ARM and Thumb. 2709 // Debian mips multilibs behave more like the rest of the biarch ones, 2710 // so handle them there 2711 if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) { 2712 // It should also work without multilibs in a simplified toolchain. 2713 findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected); 2714 } else if (TargetTriple.isCSKY()) { 2715 findCSKYMultilibs(D, TargetTriple, Path, Args, Detected); 2716 } else if (TargetTriple.isMIPS()) { 2717 if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected)) 2718 return false; 2719 } else if (TargetTriple.isRISCV()) { 2720 findRISCVMultilibs(D, TargetTriple, Path, Args, Detected); 2721 } else if (isMSP430(TargetArch)) { 2722 findMSP430Multilibs(D, TargetTriple, Path, Args, Detected); 2723 } else if (TargetArch == llvm::Triple::avr) { 2724 // AVR has no multilibs. 2725 } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args, 2726 NeedsBiarchSuffix, Detected)) { 2727 return false; 2728 } 2729 2730 Multilibs = Detected.Multilibs; 2731 SelectedMultilib = Detected.SelectedMultilibs.empty() 2732 ? Multilib() 2733 : Detected.SelectedMultilibs.back(); 2734 BiarchSibling = Detected.BiarchSibling; 2735 2736 return true; 2737 } 2738 2739 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( 2740 const llvm::Triple &TargetTriple, const ArgList &Args, 2741 const std::string &LibDir, StringRef CandidateTriple, 2742 bool NeedsBiarchSuffix, bool GCCDirExists, bool GCCCrossDirExists) { 2743 // Locations relative to the system lib directory where GCC's triple-specific 2744 // directories might reside. 2745 struct GCCLibSuffix { 2746 // Path from system lib directory to GCC triple-specific directory. 2747 std::string LibSuffix; 2748 // Path from GCC triple-specific directory back to system lib directory. 2749 // This is one '..' component per component in LibSuffix. 2750 StringRef ReversePath; 2751 // Whether this library suffix is relevant for the triple. 2752 bool Active; 2753 } Suffixes[] = { 2754 // This is the normal place. 2755 {"gcc/" + CandidateTriple.str(), "../..", GCCDirExists}, 2756 2757 // Debian puts cross-compilers in gcc-cross. 2758 {"gcc-cross/" + CandidateTriple.str(), "../..", GCCCrossDirExists}, 2759 2760 // The Freescale PPC SDK has the gcc libraries in 2761 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do 2762 // this on Freescale triples, though, since some systems put a *lot* of 2763 // files in that location, not just GCC installation data. 2764 {CandidateTriple.str(), "..", 2765 TargetTriple.getVendor() == llvm::Triple::Freescale || 2766 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}}; 2767 2768 for (auto &Suffix : Suffixes) { 2769 if (!Suffix.Active) 2770 continue; 2771 2772 StringRef LibSuffix = Suffix.LibSuffix; 2773 std::error_code EC; 2774 for (llvm::vfs::directory_iterator 2775 LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC), 2776 LE; 2777 !EC && LI != LE; LI = LI.increment(EC)) { 2778 StringRef VersionText = llvm::sys::path::filename(LI->path()); 2779 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2780 if (CandidateVersion.Major != -1) // Filter obviously bad entries. 2781 if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second) 2782 continue; // Saw this path before; no need to look at it again. 2783 if (CandidateVersion.isOlderThan(4, 1, 1)) 2784 continue; 2785 if (CandidateVersion <= Version) 2786 continue; 2787 2788 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(), 2789 NeedsBiarchSuffix)) 2790 continue; 2791 2792 Version = CandidateVersion; 2793 GCCTriple.setTriple(CandidateTriple); 2794 // FIXME: We hack together the directory name here instead of 2795 // using LI to ensure stable path separators across Windows and 2796 // Linux. 2797 GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str(); 2798 GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str(); 2799 IsValid = true; 2800 } 2801 } 2802 } 2803 2804 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs( 2805 const llvm::Triple &TargetTriple, const ArgList &Args, 2806 const SmallVectorImpl<StringRef> &CandidateTriples, 2807 const SmallVectorImpl<StringRef> &CandidateBiarchTriples) { 2808 if (!D.getVFS().exists(concat(D.SysRoot, GentooConfigDir))) 2809 return false; 2810 2811 for (StringRef CandidateTriple : CandidateTriples) { 2812 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple)) 2813 return true; 2814 } 2815 2816 for (StringRef CandidateTriple : CandidateBiarchTriples) { 2817 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true)) 2818 return true; 2819 } 2820 return false; 2821 } 2822 2823 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig( 2824 const llvm::Triple &TargetTriple, const ArgList &Args, 2825 StringRef CandidateTriple, bool NeedsBiarchSuffix) { 2826 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File = 2827 D.getVFS().getBufferForFile(concat(D.SysRoot, GentooConfigDir, 2828 "/config-" + CandidateTriple.str())); 2829 if (File) { 2830 SmallVector<StringRef, 2> Lines; 2831 File.get()->getBuffer().split(Lines, "\n"); 2832 for (StringRef Line : Lines) { 2833 Line = Line.trim(); 2834 // CURRENT=triple-version 2835 if (!Line.consume_front("CURRENT=")) 2836 continue; 2837 // Process the config file pointed to by CURRENT. 2838 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile = 2839 D.getVFS().getBufferForFile( 2840 concat(D.SysRoot, GentooConfigDir, "/" + Line)); 2841 std::pair<StringRef, StringRef> ActiveVersion = Line.rsplit('-'); 2842 // List of paths to scan for libraries. 2843 SmallVector<StringRef, 4> GentooScanPaths; 2844 // Scan the Config file to find installed GCC libraries path. 2845 // Typical content of the GCC config file: 2846 // LDPATH="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x:/usr/lib/gcc/ 2847 // (continued from previous line) x86_64-pc-linux-gnu/4.9.x/32" 2848 // MANPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/man" 2849 // INFOPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/info" 2850 // STDCXX_INCDIR="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x/include/g++-v4" 2851 // We are looking for the paths listed in LDPATH=... . 2852 if (ConfigFile) { 2853 SmallVector<StringRef, 2> ConfigLines; 2854 ConfigFile.get()->getBuffer().split(ConfigLines, "\n"); 2855 for (StringRef ConfLine : ConfigLines) { 2856 ConfLine = ConfLine.trim(); 2857 if (ConfLine.consume_front("LDPATH=")) { 2858 // Drop '"' from front and back if present. 2859 ConfLine.consume_back("\""); 2860 ConfLine.consume_front("\""); 2861 // Get all paths sperated by ':' 2862 ConfLine.split(GentooScanPaths, ':', -1, /*AllowEmpty*/ false); 2863 } 2864 } 2865 } 2866 // Test the path based on the version in /etc/env.d/gcc/config-{tuple}. 2867 std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/" 2868 + ActiveVersion.second.str(); 2869 GentooScanPaths.push_back(StringRef(basePath)); 2870 2871 // Scan all paths for GCC libraries. 2872 for (const auto &GentooScanPath : GentooScanPaths) { 2873 std::string GentooPath = concat(D.SysRoot, GentooScanPath); 2874 if (D.getVFS().exists(GentooPath + "/crtbegin.o")) { 2875 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath, 2876 NeedsBiarchSuffix)) 2877 continue; 2878 2879 Version = GCCVersion::Parse(ActiveVersion.second); 2880 GCCInstallPath = GentooPath; 2881 GCCParentLibPath = GentooPath + std::string("/../../.."); 2882 GCCTriple.setTriple(ActiveVersion.first); 2883 IsValid = true; 2884 return true; 2885 } 2886 } 2887 } 2888 } 2889 2890 return false; 2891 } 2892 2893 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple, 2894 const ArgList &Args) 2895 : ToolChain(D, Triple, Args), GCCInstallation(D), 2896 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) { 2897 getProgramPaths().push_back(getDriver().getInstalledDir()); 2898 if (getDriver().getInstalledDir() != getDriver().Dir) 2899 getProgramPaths().push_back(getDriver().Dir); 2900 } 2901 2902 Generic_GCC::~Generic_GCC() {} 2903 2904 Tool *Generic_GCC::getTool(Action::ActionClass AC) const { 2905 switch (AC) { 2906 case Action::PreprocessJobClass: 2907 if (!Preprocess) 2908 Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this)); 2909 return Preprocess.get(); 2910 case Action::CompileJobClass: 2911 if (!Compile) 2912 Compile.reset(new tools::gcc::Compiler(*this)); 2913 return Compile.get(); 2914 default: 2915 return ToolChain::getTool(AC); 2916 } 2917 } 2918 2919 Tool *Generic_GCC::buildAssembler() const { 2920 return new tools::gnutools::Assembler(*this); 2921 } 2922 2923 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); } 2924 2925 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const { 2926 // Print the information about how we detected the GCC installation. 2927 GCCInstallation.print(OS); 2928 CudaInstallation->print(OS); 2929 RocmInstallation->print(OS); 2930 } 2931 2932 ToolChain::UnwindTableLevel 2933 Generic_GCC::getDefaultUnwindTableLevel(const ArgList &Args) const { 2934 switch (getArch()) { 2935 case llvm::Triple::aarch64: 2936 case llvm::Triple::aarch64_be: 2937 case llvm::Triple::ppc: 2938 case llvm::Triple::ppcle: 2939 case llvm::Triple::ppc64: 2940 case llvm::Triple::ppc64le: 2941 case llvm::Triple::riscv32: 2942 case llvm::Triple::riscv64: 2943 case llvm::Triple::x86: 2944 case llvm::Triple::x86_64: 2945 return UnwindTableLevel::Asynchronous; 2946 default: 2947 return UnwindTableLevel::None; 2948 } 2949 } 2950 2951 bool Generic_GCC::isPICDefault() const { 2952 switch (getArch()) { 2953 case llvm::Triple::x86_64: 2954 return getTriple().isOSWindows(); 2955 case llvm::Triple::mips64: 2956 case llvm::Triple::mips64el: 2957 return true; 2958 default: 2959 return false; 2960 } 2961 } 2962 2963 bool Generic_GCC::isPIEDefault(const llvm::opt::ArgList &Args) const { 2964 return false; 2965 } 2966 2967 bool Generic_GCC::isPICDefaultForced() const { 2968 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows(); 2969 } 2970 2971 bool Generic_GCC::IsIntegratedAssemblerDefault() const { 2972 switch (getTriple().getArch()) { 2973 case llvm::Triple::nvptx: 2974 case llvm::Triple::nvptx64: 2975 case llvm::Triple::xcore: 2976 return false; 2977 default: 2978 return true; 2979 } 2980 } 2981 2982 void Generic_GCC::PushPPaths(ToolChain::path_list &PPaths) { 2983 // Cross-compiling binutils and GCC installations (vanilla and openSUSE at 2984 // least) put various tools in a triple-prefixed directory off of the parent 2985 // of the GCC installation. We use the GCC triple here to ensure that we end 2986 // up with tools that support the same amount of cross compiling as the 2987 // detected GCC installation. For example, if we find a GCC installation 2988 // targeting x86_64, but it is a bi-arch GCC installation, it can also be 2989 // used to target i386. 2990 if (GCCInstallation.isValid()) { 2991 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" + 2992 GCCInstallation.getTriple().str() + "/bin") 2993 .str()); 2994 } 2995 } 2996 2997 void Generic_GCC::AddMultilibPaths(const Driver &D, 2998 const std::string &SysRoot, 2999 const std::string &OSLibDir, 3000 const std::string &MultiarchTriple, 3001 path_list &Paths) { 3002 // Add the multilib suffixed paths where they are available. 3003 if (GCCInstallation.isValid()) { 3004 assert(!SelectedMultilibs.empty()); 3005 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 3006 const std::string &LibPath = 3007 std::string(GCCInstallation.getParentLibPath()); 3008 3009 // Sourcery CodeBench MIPS toolchain holds some libraries under 3010 // a biarch-like suffix of the GCC installation. 3011 if (const auto &PathsCallback = Multilibs.filePathsCallback()) 3012 for (const auto &Path : PathsCallback(SelectedMultilibs.back())) 3013 addPathIfExists(D, GCCInstallation.getInstallPath() + Path, Paths); 3014 3015 // Add lib/gcc/$triple/$version, with an optional /multilib suffix. 3016 addPathIfExists(D, 3017 GCCInstallation.getInstallPath() + 3018 SelectedMultilibs.back().gccSuffix(), 3019 Paths); 3020 3021 // Add lib/gcc/$triple/$libdir 3022 // For GCC built with --enable-version-specific-runtime-libs. 3023 addPathIfExists(D, GCCInstallation.getInstallPath() + "/../" + OSLibDir, 3024 Paths); 3025 3026 // GCC cross compiling toolchains will install target libraries which ship 3027 // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as 3028 // any part of the GCC installation in 3029 // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat 3030 // debatable, but is the reality today. We need to search this tree even 3031 // when we have a sysroot somewhere else. It is the responsibility of 3032 // whomever is doing the cross build targeting a sysroot using a GCC 3033 // installation that is *not* within the system root to ensure two things: 3034 // 3035 // 1) Any DSOs that are linked in from this tree or from the install path 3036 // above must be present on the system root and found via an 3037 // appropriate rpath. 3038 // 2) There must not be libraries installed into 3039 // <prefix>/<triple>/<libdir> unless they should be preferred over 3040 // those within the system root. 3041 // 3042 // Note that this matches the GCC behavior. See the below comment for where 3043 // Clang diverges from GCC's behavior. 3044 addPathIfExists(D, 3045 LibPath + "/../" + GCCTriple.str() + "/lib/../" + OSLibDir + 3046 SelectedMultilibs.back().osSuffix(), 3047 Paths); 3048 3049 // If the GCC installation we found is inside of the sysroot, we want to 3050 // prefer libraries installed in the parent prefix of the GCC installation. 3051 // It is important to *not* use these paths when the GCC installation is 3052 // outside of the system root as that can pick up unintended libraries. 3053 // This usually happens when there is an external cross compiler on the 3054 // host system, and a more minimal sysroot available that is the target of 3055 // the cross. Note that GCC does include some of these directories in some 3056 // configurations but this seems somewhere between questionable and simply 3057 // a bug. 3058 if (StringRef(LibPath).starts_with(SysRoot)) 3059 addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths); 3060 } 3061 } 3062 3063 void Generic_GCC::AddMultiarchPaths(const Driver &D, 3064 const std::string &SysRoot, 3065 const std::string &OSLibDir, 3066 path_list &Paths) { 3067 if (GCCInstallation.isValid()) { 3068 const std::string &LibPath = 3069 std::string(GCCInstallation.getParentLibPath()); 3070 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 3071 const Multilib &Multilib = GCCInstallation.getMultilib(); 3072 addPathIfExists( 3073 D, LibPath + "/../" + GCCTriple.str() + "/lib" + Multilib.osSuffix(), 3074 Paths); 3075 } 3076 } 3077 3078 void Generic_GCC::AddMultilibIncludeArgs(const ArgList &DriverArgs, 3079 ArgStringList &CC1Args) const { 3080 // Add include directories specific to the selected multilib set and multilib. 3081 if (!GCCInstallation.isValid()) 3082 return; 3083 // gcc TOOL_INCLUDE_DIR. 3084 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 3085 std::string LibPath(GCCInstallation.getParentLibPath()); 3086 addSystemInclude(DriverArgs, CC1Args, 3087 Twine(LibPath) + "/../" + GCCTriple.str() + "/include"); 3088 3089 const auto &Callback = Multilibs.includeDirsCallback(); 3090 if (Callback) { 3091 for (const auto &Path : Callback(GCCInstallation.getMultilib())) 3092 addExternCSystemIncludeIfExists(DriverArgs, CC1Args, 3093 GCCInstallation.getInstallPath() + Path); 3094 } 3095 } 3096 3097 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 3098 ArgStringList &CC1Args) const { 3099 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx, 3100 options::OPT_nostdlibinc)) 3101 return; 3102 3103 switch (GetCXXStdlibType(DriverArgs)) { 3104 case ToolChain::CST_Libcxx: 3105 addLibCxxIncludePaths(DriverArgs, CC1Args); 3106 break; 3107 3108 case ToolChain::CST_Libstdcxx: 3109 addLibStdCxxIncludePaths(DriverArgs, CC1Args); 3110 break; 3111 } 3112 } 3113 3114 void 3115 Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 3116 llvm::opt::ArgStringList &CC1Args) const { 3117 const Driver &D = getDriver(); 3118 std::string SysRoot = computeSysRoot(); 3119 if (SysRoot.empty()) 3120 SysRoot = llvm::sys::path::get_separator(); 3121 3122 auto AddIncludePath = [&](StringRef Path, bool TargetDirRequired = false) { 3123 std::string Version = detectLibcxxVersion(Path); 3124 if (Version.empty()) 3125 return false; 3126 3127 // First add the per-target include path if it exists. 3128 bool TargetDirExists = false; 3129 std::optional<std::string> TargetIncludeDir = getTargetSubDirPath(Path); 3130 if (TargetIncludeDir) { 3131 SmallString<128> TargetDir(*TargetIncludeDir); 3132 llvm::sys::path::append(TargetDir, "c++", Version); 3133 if (D.getVFS().exists(TargetDir)) { 3134 addSystemInclude(DriverArgs, CC1Args, TargetDir); 3135 TargetDirExists = true; 3136 } 3137 } 3138 if (TargetDirRequired && !TargetDirExists) 3139 return false; 3140 3141 // Second add the generic one. 3142 SmallString<128> GenericDir(Path); 3143 llvm::sys::path::append(GenericDir, "c++", Version); 3144 addSystemInclude(DriverArgs, CC1Args, GenericDir); 3145 return true; 3146 }; 3147 3148 // Android only uses the libc++ headers installed alongside the toolchain if 3149 // they contain an Android-specific target include path, otherwise they're 3150 // incompatible with the NDK libraries. 3151 SmallString<128> DriverIncludeDir(getDriver().Dir); 3152 llvm::sys::path::append(DriverIncludeDir, "..", "include"); 3153 if (AddIncludePath(DriverIncludeDir, 3154 /*TargetDirRequired=*/getTriple().isAndroid())) 3155 return; 3156 // If this is a development, non-installed, clang, libcxx will 3157 // not be found at ../include/c++ but it likely to be found at 3158 // one of the following two locations: 3159 SmallString<128> UsrLocalIncludeDir(SysRoot); 3160 llvm::sys::path::append(UsrLocalIncludeDir, "usr", "local", "include"); 3161 if (AddIncludePath(UsrLocalIncludeDir)) 3162 return; 3163 SmallString<128> UsrIncludeDir(SysRoot); 3164 llvm::sys::path::append(UsrIncludeDir, "usr", "include"); 3165 if (AddIncludePath(UsrIncludeDir)) 3166 return; 3167 } 3168 3169 bool Generic_GCC::addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, 3170 Twine IncludeSuffix, 3171 const llvm::opt::ArgList &DriverArgs, 3172 llvm::opt::ArgStringList &CC1Args, 3173 bool DetectDebian) const { 3174 if (!getVFS().exists(IncludeDir)) 3175 return false; 3176 3177 // Debian native gcc uses g++-multiarch-incdir.diff which uses 3178 // include/x86_64-linux-gnu/c++/10$IncludeSuffix instead of 3179 // include/c++/10/x86_64-linux-gnu$IncludeSuffix. 3180 std::string Dir = IncludeDir.str(); 3181 StringRef Include = 3182 llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir)); 3183 std::string Path = 3184 (Include + "/" + Triple + Dir.substr(Include.size()) + IncludeSuffix) 3185 .str(); 3186 if (DetectDebian && !getVFS().exists(Path)) 3187 return false; 3188 3189 // GPLUSPLUS_INCLUDE_DIR 3190 addSystemInclude(DriverArgs, CC1Args, IncludeDir); 3191 // GPLUSPLUS_TOOL_INCLUDE_DIR. If Triple is not empty, add a target-dependent 3192 // include directory. 3193 if (DetectDebian) 3194 addSystemInclude(DriverArgs, CC1Args, Path); 3195 else if (!Triple.empty()) 3196 addSystemInclude(DriverArgs, CC1Args, 3197 IncludeDir + "/" + Triple + IncludeSuffix); 3198 // GPLUSPLUS_BACKWARD_INCLUDE_DIR 3199 addSystemInclude(DriverArgs, CC1Args, IncludeDir + "/backward"); 3200 return true; 3201 } 3202 3203 bool Generic_GCC::addGCCLibStdCxxIncludePaths( 3204 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, 3205 StringRef DebianMultiarch) const { 3206 assert(GCCInstallation.isValid()); 3207 3208 // By default, look for the C++ headers in an include directory adjacent to 3209 // the lib directory of the GCC installation. Note that this is expect to be 3210 // equivalent to '/usr/include/c++/X.Y' in almost all cases. 3211 StringRef LibDir = GCCInstallation.getParentLibPath(); 3212 StringRef InstallDir = GCCInstallation.getInstallPath(); 3213 StringRef TripleStr = GCCInstallation.getTriple().str(); 3214 const Multilib &Multilib = GCCInstallation.getMultilib(); 3215 const GCCVersion &Version = GCCInstallation.getVersion(); 3216 3217 // Try /../$triple/include/c++/$version (gcc --print-multiarch is not empty). 3218 if (addLibStdCXXIncludePaths( 3219 LibDir.str() + "/../" + TripleStr + "/include/c++/" + Version.Text, 3220 TripleStr, Multilib.includeSuffix(), DriverArgs, CC1Args)) 3221 return true; 3222 3223 // Try /gcc/$triple/$version/include/c++/ (gcc --print-multiarch is not 3224 // empty). Like above but for GCC built with 3225 // --enable-version-specific-runtime-libs. 3226 if (addLibStdCXXIncludePaths(LibDir.str() + "/gcc/" + TripleStr + "/" + 3227 Version.Text + "/include/c++/", 3228 TripleStr, Multilib.includeSuffix(), DriverArgs, 3229 CC1Args)) 3230 return true; 3231 3232 // Detect Debian g++-multiarch-incdir.diff. 3233 if (addLibStdCXXIncludePaths(LibDir.str() + "/../include/c++/" + Version.Text, 3234 DebianMultiarch, Multilib.includeSuffix(), 3235 DriverArgs, CC1Args, /*Debian=*/true)) 3236 return true; 3237 3238 // Try /../include/c++/$version (gcc --print-multiarch is empty). 3239 if (addLibStdCXXIncludePaths(LibDir.str() + "/../include/c++/" + Version.Text, 3240 TripleStr, Multilib.includeSuffix(), DriverArgs, 3241 CC1Args)) 3242 return true; 3243 3244 // Otherwise, fall back on a bunch of options which don't use multiarch 3245 // layouts for simplicity. 3246 const std::string LibStdCXXIncludePathCandidates[] = { 3247 // Gentoo is weird and places its headers inside the GCC install, 3248 // so if the first attempt to find the headers fails, try these patterns. 3249 InstallDir.str() + "/include/g++-v" + Version.Text, 3250 InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." + 3251 Version.MinorStr, 3252 InstallDir.str() + "/include/g++-v" + Version.MajorStr, 3253 }; 3254 3255 for (const auto &IncludePath : LibStdCXXIncludePathCandidates) { 3256 if (addLibStdCXXIncludePaths(IncludePath, TripleStr, 3257 Multilib.includeSuffix(), DriverArgs, CC1Args)) 3258 return true; 3259 } 3260 return false; 3261 } 3262 3263 void 3264 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 3265 llvm::opt::ArgStringList &CC1Args) const { 3266 if (GCCInstallation.isValid()) { 3267 addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args, 3268 GCCInstallation.getTriple().str()); 3269 } 3270 } 3271 3272 llvm::opt::DerivedArgList * 3273 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef, 3274 Action::OffloadKind DeviceOffloadKind) const { 3275 3276 // If this tool chain is used for an OpenMP offloading device we have to make 3277 // sure we always generate a shared library regardless of the commands the 3278 // user passed to the host. This is required because the runtime library 3279 // is required to load the device image dynamically at run time. 3280 if (DeviceOffloadKind == Action::OFK_OpenMP) { 3281 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 3282 const OptTable &Opts = getDriver().getOpts(); 3283 3284 // Request the shared library. Given that these options are decided 3285 // implicitly, they do not refer to any base argument. 3286 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared)); 3287 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC)); 3288 3289 // Filter all the arguments we don't care passing to the offloading 3290 // toolchain as they can mess up with the creation of a shared library. 3291 for (auto *A : Args) { 3292 switch ((options::ID)A->getOption().getID()) { 3293 default: 3294 DAL->append(A); 3295 break; 3296 case options::OPT_shared: 3297 case options::OPT_dynamic: 3298 case options::OPT_static: 3299 case options::OPT_fPIC: 3300 case options::OPT_fno_PIC: 3301 case options::OPT_fpic: 3302 case options::OPT_fno_pic: 3303 case options::OPT_fPIE: 3304 case options::OPT_fno_PIE: 3305 case options::OPT_fpie: 3306 case options::OPT_fno_pie: 3307 break; 3308 } 3309 } 3310 return DAL; 3311 } 3312 return nullptr; 3313 } 3314 3315 void Generic_ELF::anchor() {} 3316 3317 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs, 3318 ArgStringList &CC1Args, 3319 Action::OffloadKind) const { 3320 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 3321 options::OPT_fno_use_init_array, true)) 3322 CC1Args.push_back("-fno-use-init-array"); 3323 } 3324