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