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