1 //===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "Gnu.h" 11 #include "Linux.h" 12 #include "Arch/ARM.h" 13 #include "Arch/Mips.h" 14 #include "Arch/Sparc.h" 15 #include "Arch/SystemZ.h" 16 #include "CommonArgs.h" 17 #include "clang/Basic/VirtualFileSystem.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 "llvm/Option/ArgList.h" 25 #include "llvm/Support/CodeGen.h" 26 #include "llvm/Support/Path.h" 27 #include "llvm/Support/TargetParser.h" 28 #include <system_error> 29 30 using namespace clang::driver; 31 using namespace clang::driver::toolchains; 32 using namespace clang; 33 using namespace llvm::opt; 34 35 void tools::GnuTool::anchor() {} 36 37 static bool forwardToGCC(const Option &O) { 38 // Don't forward inputs from the original command line. They are added from 39 // InputInfoList. 40 return O.getKind() != Option::InputClass && 41 !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput); 42 } 43 44 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 45 const InputInfo &Output, 46 const InputInfoList &Inputs, 47 const ArgList &Args, 48 const char *LinkingOutput) const { 49 const Driver &D = getToolChain().getDriver(); 50 ArgStringList CmdArgs; 51 52 for (const auto &A : Args) { 53 if (forwardToGCC(A->getOption())) { 54 // It is unfortunate that we have to claim here, as this means 55 // we will basically never report anything interesting for 56 // platforms using a generic gcc, even if we are just using gcc 57 // to get to the assembler. 58 A->claim(); 59 60 // Don't forward any -g arguments to assembly steps. 61 if (isa<AssembleJobAction>(JA) && 62 A->getOption().matches(options::OPT_g_Group)) 63 continue; 64 65 // Don't forward any -W arguments to assembly and link steps. 66 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) && 67 A->getOption().matches(options::OPT_W_Group)) 68 continue; 69 70 A->render(Args, CmdArgs); 71 } 72 } 73 74 RenderExtraToolArgs(JA, CmdArgs); 75 76 // If using a driver driver, force the arch. 77 if (getToolChain().getTriple().isOSDarwin()) { 78 CmdArgs.push_back("-arch"); 79 CmdArgs.push_back( 80 Args.MakeArgString(getToolChain().getDefaultUniversalArchName())); 81 } 82 83 // Try to force gcc to match the tool chain we want, if we recognize 84 // the arch. 85 // 86 // FIXME: The triple class should directly provide the information we want 87 // here. 88 switch (getToolChain().getArch()) { 89 default: 90 break; 91 case llvm::Triple::x86: 92 case llvm::Triple::ppc: 93 CmdArgs.push_back("-m32"); 94 break; 95 case llvm::Triple::x86_64: 96 case llvm::Triple::ppc64: 97 case llvm::Triple::ppc64le: 98 CmdArgs.push_back("-m64"); 99 break; 100 case llvm::Triple::sparcel: 101 CmdArgs.push_back("-EL"); 102 break; 103 } 104 105 if (Output.isFilename()) { 106 CmdArgs.push_back("-o"); 107 CmdArgs.push_back(Output.getFilename()); 108 } else { 109 assert(Output.isNothing() && "Unexpected output"); 110 CmdArgs.push_back("-fsyntax-only"); 111 } 112 113 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 114 115 // Only pass -x if gcc will understand it; otherwise hope gcc 116 // understands the suffix correctly. The main use case this would go 117 // wrong in is for linker inputs if they happened to have an odd 118 // suffix; really the only way to get this to happen is a command 119 // like '-x foobar a.c' which will treat a.c like a linker input. 120 // 121 // FIXME: For the linker case specifically, can we safely convert 122 // inputs into '-Wl,' options? 123 for (const auto &II : Inputs) { 124 // Don't try to pass LLVM or AST inputs to a generic gcc. 125 if (types::isLLVMIR(II.getType())) 126 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 127 << getToolChain().getTripleString(); 128 else if (II.getType() == types::TY_AST) 129 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString(); 130 else if (II.getType() == types::TY_ModuleFile) 131 D.Diag(diag::err_drv_no_module_support) 132 << getToolChain().getTripleString(); 133 134 if (types::canTypeBeUserSpecified(II.getType())) { 135 CmdArgs.push_back("-x"); 136 CmdArgs.push_back(types::getTypeName(II.getType())); 137 } 138 139 if (II.isFilename()) 140 CmdArgs.push_back(II.getFilename()); 141 else { 142 const Arg &A = II.getInputArg(); 143 144 // Reverse translate some rewritten options. 145 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 146 CmdArgs.push_back("-lstdc++"); 147 continue; 148 } 149 150 // Don't render as input, we need gcc to do the translations. 151 A.render(Args, CmdArgs); 152 } 153 } 154 155 const std::string &customGCCName = D.getCCCGenericGCCName(); 156 const char *GCCName; 157 if (!customGCCName.empty()) 158 GCCName = customGCCName.c_str(); 159 else if (D.CCCIsCXX()) { 160 GCCName = "g++"; 161 } else 162 GCCName = "gcc"; 163 164 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 165 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 166 } 167 168 void tools::gcc::Preprocessor::RenderExtraToolArgs( 169 const JobAction &JA, ArgStringList &CmdArgs) const { 170 CmdArgs.push_back("-E"); 171 } 172 173 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA, 174 ArgStringList &CmdArgs) const { 175 const Driver &D = getToolChain().getDriver(); 176 177 switch (JA.getType()) { 178 // If -flto, etc. are present then make sure not to force assembly output. 179 case types::TY_LLVM_IR: 180 case types::TY_LTO_IR: 181 case types::TY_LLVM_BC: 182 case types::TY_LTO_BC: 183 CmdArgs.push_back("-c"); 184 break; 185 // We assume we've got an "integrated" assembler in that gcc will produce an 186 // object file itself. 187 case types::TY_Object: 188 CmdArgs.push_back("-c"); 189 break; 190 case types::TY_PP_Asm: 191 CmdArgs.push_back("-S"); 192 break; 193 case types::TY_Nothing: 194 CmdArgs.push_back("-fsyntax-only"); 195 break; 196 default: 197 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType()); 198 } 199 } 200 201 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA, 202 ArgStringList &CmdArgs) const { 203 // The types are (hopefully) good enough. 204 } 205 206 /// Add OpenMP linker script arguments at the end of the argument list so that 207 /// the fat binary is built by embedding each of the device images into the 208 /// host. The linker script also defines a few symbols required by the code 209 /// generation so that the images can be easily retrieved at runtime by the 210 /// offloading library. This should be used only in tool chains that support 211 /// linker scripts. 212 static void AddOpenMPLinkerScript(const ToolChain &TC, Compilation &C, 213 const InputInfo &Output, 214 const InputInfoList &Inputs, 215 const ArgList &Args, ArgStringList &CmdArgs, 216 const JobAction &JA) { 217 218 // If this is not an OpenMP host toolchain, we don't need to do anything. 219 if (!JA.isHostOffloading(Action::OFK_OpenMP)) 220 return; 221 222 // Create temporary linker script. Keep it if save-temps is enabled. 223 const char *LKS; 224 SmallString<256> Name = llvm::sys::path::filename(Output.getFilename()); 225 if (C.getDriver().isSaveTempsEnabled()) { 226 llvm::sys::path::replace_extension(Name, "lk"); 227 LKS = C.getArgs().MakeArgString(Name.c_str()); 228 } else { 229 llvm::sys::path::replace_extension(Name, ""); 230 Name = C.getDriver().GetTemporaryPath(Name, "lk"); 231 LKS = C.addTempFile(C.getArgs().MakeArgString(Name.c_str())); 232 } 233 234 // Add linker script option to the command. 235 CmdArgs.push_back("-T"); 236 CmdArgs.push_back(LKS); 237 238 // Create a buffer to write the contents of the linker script. 239 std::string LksBuffer; 240 llvm::raw_string_ostream LksStream(LksBuffer); 241 242 // Get the OpenMP offload tool chains so that we can extract the triple 243 // associated with each device input. 244 auto OpenMPToolChains = C.getOffloadToolChains<Action::OFK_OpenMP>(); 245 assert(OpenMPToolChains.first != OpenMPToolChains.second && 246 "No OpenMP toolchains??"); 247 248 // Track the input file name and device triple in order to build the script, 249 // inserting binaries in the designated sections. 250 SmallVector<std::pair<std::string, const char *>, 8> InputBinaryInfo; 251 252 // Add commands to embed target binaries. We ensure that each section and 253 // image is 16-byte aligned. This is not mandatory, but increases the 254 // likelihood of data to be aligned with a cache block in several main host 255 // machines. 256 LksStream << "/*\n"; 257 LksStream << " OpenMP Offload Linker Script\n"; 258 LksStream << " *** Automatically generated by Clang ***\n"; 259 LksStream << "*/\n"; 260 LksStream << "TARGET(binary)\n"; 261 auto DTC = OpenMPToolChains.first; 262 for (auto &II : Inputs) { 263 const Action *A = II.getAction(); 264 // Is this a device linking action? 265 if (A && isa<LinkJobAction>(A) && 266 A->isDeviceOffloading(Action::OFK_OpenMP)) { 267 assert(DTC != OpenMPToolChains.second && 268 "More device inputs than device toolchains??"); 269 InputBinaryInfo.push_back(std::make_pair( 270 DTC->second->getTriple().normalize(), II.getFilename())); 271 ++DTC; 272 LksStream << "INPUT(" << II.getFilename() << ")\n"; 273 } 274 } 275 276 assert(DTC == OpenMPToolChains.second && 277 "Less device inputs than device toolchains??"); 278 279 LksStream << "SECTIONS\n"; 280 LksStream << "{\n"; 281 LksStream << " .omp_offloading :\n"; 282 LksStream << " ALIGN(0x10)\n"; 283 LksStream << " {\n"; 284 285 for (auto &BI : InputBinaryInfo) { 286 LksStream << " . = ALIGN(0x10);\n"; 287 LksStream << " PROVIDE_HIDDEN(.omp_offloading.img_start." << BI.first 288 << " = .);\n"; 289 LksStream << " " << BI.second << "\n"; 290 LksStream << " PROVIDE_HIDDEN(.omp_offloading.img_end." << BI.first 291 << " = .);\n"; 292 } 293 294 LksStream << " }\n"; 295 // Add commands to define host entries begin and end. We use 1-byte subalign 296 // so that the linker does not add any padding and the elements in this 297 // section form an array. 298 LksStream << " .omp_offloading.entries :\n"; 299 LksStream << " ALIGN(0x10)\n"; 300 LksStream << " SUBALIGN(0x01)\n"; 301 LksStream << " {\n"; 302 LksStream << " PROVIDE_HIDDEN(.omp_offloading.entries_begin = .);\n"; 303 LksStream << " *(.omp_offloading.entries)\n"; 304 LksStream << " PROVIDE_HIDDEN(.omp_offloading.entries_end = .);\n"; 305 LksStream << " }\n"; 306 LksStream << "}\n"; 307 LksStream << "INSERT BEFORE .data\n"; 308 LksStream.flush(); 309 310 // Dump the contents of the linker script if the user requested that. We 311 // support this option to enable testing of behavior with -###. 312 if (C.getArgs().hasArg(options::OPT_fopenmp_dump_offload_linker_script)) 313 llvm::errs() << LksBuffer; 314 315 // If this is a dry run, do not create the linker script file. 316 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) 317 return; 318 319 // Open script file and write the contents. 320 std::error_code EC; 321 llvm::raw_fd_ostream Lksf(LKS, EC, llvm::sys::fs::F_None); 322 323 if (EC) { 324 C.getDriver().Diag(clang::diag::err_unable_to_make_temp) << EC.message(); 325 return; 326 } 327 328 Lksf << LksBuffer; 329 } 330 331 static bool addXRayRuntime(const ToolChain &TC, const ArgList &Args, 332 ArgStringList &CmdArgs) { 333 if (Args.hasFlag(options::OPT_fxray_instrument, 334 options::OPT_fnoxray_instrument, false)) { 335 CmdArgs.push_back("-whole-archive"); 336 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray", false)); 337 CmdArgs.push_back("-no-whole-archive"); 338 return true; 339 } 340 return false; 341 } 342 343 static void linkXRayRuntimeDeps(const ToolChain &TC, const ArgList &Args, 344 ArgStringList &CmdArgs) { 345 CmdArgs.push_back("--no-as-needed"); 346 CmdArgs.push_back("-lpthread"); 347 CmdArgs.push_back("-lrt"); 348 CmdArgs.push_back("-lm"); 349 350 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD) 351 CmdArgs.push_back("-ldl"); 352 } 353 354 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) { 355 switch (T.getArch()) { 356 case llvm::Triple::x86: 357 if (T.isOSIAMCU()) 358 return "elf_iamcu"; 359 return "elf_i386"; 360 case llvm::Triple::aarch64: 361 return "aarch64linux"; 362 case llvm::Triple::aarch64_be: 363 return "aarch64_be_linux"; 364 case llvm::Triple::arm: 365 case llvm::Triple::thumb: 366 return "armelf_linux_eabi"; 367 case llvm::Triple::armeb: 368 case llvm::Triple::thumbeb: 369 return "armelfb_linux_eabi"; 370 case llvm::Triple::ppc: 371 return "elf32ppclinux"; 372 case llvm::Triple::ppc64: 373 return "elf64ppc"; 374 case llvm::Triple::ppc64le: 375 return "elf64lppc"; 376 case llvm::Triple::sparc: 377 case llvm::Triple::sparcel: 378 return "elf32_sparc"; 379 case llvm::Triple::sparcv9: 380 return "elf64_sparc"; 381 case llvm::Triple::mips: 382 return "elf32btsmip"; 383 case llvm::Triple::mipsel: 384 return "elf32ltsmip"; 385 case llvm::Triple::mips64: 386 if (tools::mips::hasMipsAbiArg(Args, "n32")) 387 return "elf32btsmipn32"; 388 return "elf64btsmip"; 389 case llvm::Triple::mips64el: 390 if (tools::mips::hasMipsAbiArg(Args, "n32")) 391 return "elf32ltsmipn32"; 392 return "elf64ltsmip"; 393 case llvm::Triple::systemz: 394 return "elf64_s390"; 395 case llvm::Triple::x86_64: 396 if (T.getEnvironment() == llvm::Triple::GNUX32) 397 return "elf32_x86_64"; 398 return "elf_x86_64"; 399 default: 400 return nullptr; 401 } 402 } 403 404 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, 405 const InputInfo &Output, 406 const InputInfoList &Inputs, 407 const ArgList &Args, 408 const char *LinkingOutput) const { 409 const toolchains::Linux &ToolChain = 410 static_cast<const toolchains::Linux &>(getToolChain()); 411 const Driver &D = ToolChain.getDriver(); 412 413 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 414 415 const llvm::Triple::ArchType Arch = ToolChain.getArch(); 416 const bool isAndroid = ToolChain.getTriple().isAndroid(); 417 const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU(); 418 const bool IsPIE = 419 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) && 420 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault()); 421 const bool HasCRTBeginEndFiles = 422 ToolChain.getTriple().hasEnvironment() || 423 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies); 424 425 ArgStringList CmdArgs; 426 427 // Silence warning for "clang -g foo.o -o foo" 428 Args.ClaimAllArgs(options::OPT_g_Group); 429 // and "clang -emit-llvm foo.o -o foo" 430 Args.ClaimAllArgs(options::OPT_emit_llvm); 431 // and for "clang -w foo.o -o foo". Other warning options are already 432 // handled somewhere else. 433 Args.ClaimAllArgs(options::OPT_w); 434 435 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); 436 if (llvm::sys::path::stem(Exec) == "lld") { 437 CmdArgs.push_back("-flavor"); 438 CmdArgs.push_back("old-gnu"); 439 CmdArgs.push_back("-target"); 440 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString())); 441 } 442 443 if (!D.SysRoot.empty()) 444 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 445 446 if (IsPIE) 447 CmdArgs.push_back("-pie"); 448 449 if (Args.hasArg(options::OPT_rdynamic)) 450 CmdArgs.push_back("-export-dynamic"); 451 452 if (Args.hasArg(options::OPT_s)) 453 CmdArgs.push_back("-s"); 454 455 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) 456 arm::appendEBLinkFlags(Args, CmdArgs, Triple); 457 458 // Most Android ARM64 targets should enable the linker fix for erratum 459 // 843419. Only non-Cortex-A53 devices are allowed to skip this flag. 460 if (Arch == llvm::Triple::aarch64 && isAndroid) { 461 std::string CPU = getCPUName(Args, Triple); 462 if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53") 463 CmdArgs.push_back("--fix-cortex-a53-843419"); 464 } 465 466 for (const auto &Opt : ToolChain.ExtraOpts) 467 CmdArgs.push_back(Opt.c_str()); 468 469 if (!Args.hasArg(options::OPT_static)) { 470 CmdArgs.push_back("--eh-frame-hdr"); 471 } 472 473 if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) { 474 CmdArgs.push_back("-m"); 475 CmdArgs.push_back(LDMOption); 476 } else { 477 D.Diag(diag::err_target_unknown_triple) << Triple.str(); 478 return; 479 } 480 481 if (Args.hasArg(options::OPT_static)) { 482 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb || 483 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb) 484 CmdArgs.push_back("-Bstatic"); 485 else 486 CmdArgs.push_back("-static"); 487 } else if (Args.hasArg(options::OPT_shared)) { 488 CmdArgs.push_back("-shared"); 489 } 490 491 if (!Args.hasArg(options::OPT_static)) { 492 if (Args.hasArg(options::OPT_rdynamic)) 493 CmdArgs.push_back("-export-dynamic"); 494 495 if (!Args.hasArg(options::OPT_shared)) { 496 const std::string Loader = 497 D.DyldPrefix + ToolChain.getDynamicLinker(Args); 498 CmdArgs.push_back("-dynamic-linker"); 499 CmdArgs.push_back(Args.MakeArgString(Loader)); 500 } 501 } 502 503 CmdArgs.push_back("-o"); 504 CmdArgs.push_back(Output.getFilename()); 505 506 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 507 if (!isAndroid && !IsIAMCU) { 508 const char *crt1 = nullptr; 509 if (!Args.hasArg(options::OPT_shared)) { 510 if (Args.hasArg(options::OPT_pg)) 511 crt1 = "gcrt1.o"; 512 else if (IsPIE) 513 crt1 = "Scrt1.o"; 514 else 515 crt1 = "crt1.o"; 516 } 517 if (crt1) 518 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 519 520 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 521 } 522 523 if (IsIAMCU) 524 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o"))); 525 else { 526 const char *crtbegin; 527 if (Args.hasArg(options::OPT_static)) 528 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o"; 529 else if (Args.hasArg(options::OPT_shared)) 530 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o"; 531 else if (IsPIE) 532 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o"; 533 else 534 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o"; 535 536 if (HasCRTBeginEndFiles) 537 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 538 } 539 540 // Add crtfastmath.o if available and fast math is enabled. 541 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs); 542 } 543 544 Args.AddAllArgs(CmdArgs, options::OPT_L); 545 Args.AddAllArgs(CmdArgs, options::OPT_u); 546 547 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 548 549 if (D.isUsingLTO()) 550 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin, D); 551 552 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 553 CmdArgs.push_back("--no-demangle"); 554 555 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); 556 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs); 557 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 558 // The profile runtime also needs access to system libraries. 559 getToolChain().addProfileRTLibs(Args, CmdArgs); 560 561 if (D.CCCIsCXX() && 562 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 563 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 564 !Args.hasArg(options::OPT_static); 565 if (OnlyLibstdcxxStatic) 566 CmdArgs.push_back("-Bstatic"); 567 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 568 if (OnlyLibstdcxxStatic) 569 CmdArgs.push_back("-Bdynamic"); 570 CmdArgs.push_back("-lm"); 571 } 572 // Silence warnings when linking C code with a C++ '-stdlib' argument. 573 Args.ClaimAllArgs(options::OPT_stdlib_EQ); 574 575 if (!Args.hasArg(options::OPT_nostdlib)) { 576 if (!Args.hasArg(options::OPT_nodefaultlibs)) { 577 if (Args.hasArg(options::OPT_static)) 578 CmdArgs.push_back("--start-group"); 579 580 if (NeedsSanitizerDeps) 581 linkSanitizerRuntimeDeps(ToolChain, CmdArgs); 582 583 if (NeedsXRayDeps) 584 linkXRayRuntimeDeps(ToolChain, Args, CmdArgs); 585 586 bool WantPthread = Args.hasArg(options::OPT_pthread) || 587 Args.hasArg(options::OPT_pthreads); 588 589 // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that 590 // require librt. Most modern Linux platforms do, but some may not. 591 if (addOpenMPRuntime(CmdArgs, ToolChain, Args, 592 JA.isHostOffloading(Action::OFK_OpenMP), 593 /* GompNeedsRT= */ true)) 594 // OpenMP runtimes implies pthreads when using the GNU toolchain. 595 // FIXME: Does this really make sense for all GNU toolchains? 596 WantPthread = true; 597 598 AddRunTimeLibs(ToolChain, D, CmdArgs, Args); 599 600 if (WantPthread && !isAndroid) 601 CmdArgs.push_back("-lpthread"); 602 603 if (Args.hasArg(options::OPT_fsplit_stack)) 604 CmdArgs.push_back("--wrap=pthread_create"); 605 606 CmdArgs.push_back("-lc"); 607 608 // Add IAMCU specific libs, if needed. 609 if (IsIAMCU) 610 CmdArgs.push_back("-lgloss"); 611 612 if (Args.hasArg(options::OPT_static)) 613 CmdArgs.push_back("--end-group"); 614 else 615 AddRunTimeLibs(ToolChain, D, CmdArgs, Args); 616 617 // Add IAMCU specific libs (outside the group), if needed. 618 if (IsIAMCU) { 619 CmdArgs.push_back("--as-needed"); 620 CmdArgs.push_back("-lsoftfp"); 621 CmdArgs.push_back("--no-as-needed"); 622 } 623 } 624 625 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) { 626 const char *crtend; 627 if (Args.hasArg(options::OPT_shared)) 628 crtend = isAndroid ? "crtend_so.o" : "crtendS.o"; 629 else if (IsPIE) 630 crtend = isAndroid ? "crtend_android.o" : "crtendS.o"; 631 else 632 crtend = isAndroid ? "crtend_android.o" : "crtend.o"; 633 634 if (HasCRTBeginEndFiles) 635 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 636 if (!isAndroid) 637 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 638 } 639 } 640 641 // Add OpenMP offloading linker script args if required. 642 AddOpenMPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA); 643 644 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 645 } 646 647 void tools::gnutools::Assembler::ConstructJob(Compilation &C, 648 const JobAction &JA, 649 const InputInfo &Output, 650 const InputInfoList &Inputs, 651 const ArgList &Args, 652 const char *LinkingOutput) const { 653 claimNoWarnArgs(Args); 654 655 ArgStringList CmdArgs; 656 657 llvm::Reloc::Model RelocationModel; 658 unsigned PICLevel; 659 bool IsPIE; 660 std::tie(RelocationModel, PICLevel, IsPIE) = 661 ParsePICArgs(getToolChain(), Args); 662 663 switch (getToolChain().getArch()) { 664 default: 665 break; 666 // Add --32/--64 to make sure we get the format we want. 667 // This is incomplete 668 case llvm::Triple::x86: 669 CmdArgs.push_back("--32"); 670 break; 671 case llvm::Triple::x86_64: 672 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32) 673 CmdArgs.push_back("--x32"); 674 else 675 CmdArgs.push_back("--64"); 676 break; 677 case llvm::Triple::ppc: 678 CmdArgs.push_back("-a32"); 679 CmdArgs.push_back("-mppc"); 680 CmdArgs.push_back("-many"); 681 break; 682 case llvm::Triple::ppc64: 683 CmdArgs.push_back("-a64"); 684 CmdArgs.push_back("-mppc64"); 685 CmdArgs.push_back("-many"); 686 break; 687 case llvm::Triple::ppc64le: 688 CmdArgs.push_back("-a64"); 689 CmdArgs.push_back("-mppc64"); 690 CmdArgs.push_back("-many"); 691 CmdArgs.push_back("-mlittle-endian"); 692 break; 693 case llvm::Triple::sparc: 694 case llvm::Triple::sparcel: { 695 CmdArgs.push_back("-32"); 696 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 697 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 698 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 699 break; 700 } 701 case llvm::Triple::sparcv9: { 702 CmdArgs.push_back("-64"); 703 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 704 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 705 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 706 break; 707 } 708 case llvm::Triple::arm: 709 case llvm::Triple::armeb: 710 case llvm::Triple::thumb: 711 case llvm::Triple::thumbeb: { 712 const llvm::Triple &Triple2 = getToolChain().getTriple(); 713 switch (Triple2.getSubArch()) { 714 case llvm::Triple::ARMSubArch_v7: 715 CmdArgs.push_back("-mfpu=neon"); 716 break; 717 case llvm::Triple::ARMSubArch_v8: 718 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8"); 719 break; 720 default: 721 break; 722 } 723 724 switch (arm::getARMFloatABI(getToolChain(), Args)) { 725 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!"); 726 case arm::FloatABI::Soft: 727 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft")); 728 break; 729 case arm::FloatABI::SoftFP: 730 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp")); 731 break; 732 case arm::FloatABI::Hard: 733 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard")); 734 break; 735 } 736 737 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 738 739 // FIXME: remove krait check when GNU tools support krait cpu 740 // for now replace it with -mcpu=cortex-a15 to avoid a lower 741 // march from being picked in the absence of a cpu flag. 742 Arg *A; 743 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) && 744 StringRef(A->getValue()).equals_lower("krait")) 745 CmdArgs.push_back("-mcpu=cortex-a15"); 746 else 747 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 748 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); 749 break; 750 } 751 case llvm::Triple::aarch64: 752 case llvm::Triple::aarch64_be: { 753 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 754 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 755 break; 756 } 757 case llvm::Triple::mips: 758 case llvm::Triple::mipsel: 759 case llvm::Triple::mips64: 760 case llvm::Triple::mips64el: { 761 StringRef CPUName; 762 StringRef ABIName; 763 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 764 ABIName = mips::getGnuCompatibleMipsABIName(ABIName); 765 766 CmdArgs.push_back("-march"); 767 CmdArgs.push_back(CPUName.data()); 768 769 CmdArgs.push_back("-mabi"); 770 CmdArgs.push_back(ABIName.data()); 771 772 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE, 773 // or -mshared (not implemented) is in effect. 774 if (RelocationModel == llvm::Reloc::Static) 775 CmdArgs.push_back("-mno-shared"); 776 777 // LLVM doesn't support -mplt yet and acts as if it is always given. 778 // However, -mplt has no effect with the N64 ABI. 779 if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls)) 780 CmdArgs.push_back("-call_nonpic"); 781 782 if (getToolChain().getArch() == llvm::Triple::mips || 783 getToolChain().getArch() == llvm::Triple::mips64) 784 CmdArgs.push_back("-EB"); 785 else 786 CmdArgs.push_back("-EL"); 787 788 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 789 if (StringRef(A->getValue()) == "2008") 790 CmdArgs.push_back(Args.MakeArgString("-mnan=2008")); 791 } 792 793 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default. 794 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx, 795 options::OPT_mfp64)) { 796 A->claim(); 797 A->render(Args, CmdArgs); 798 } else if (mips::shouldUseFPXX( 799 Args, getToolChain().getTriple(), CPUName, ABIName, 800 mips::getMipsFloatABI(getToolChain().getDriver(), Args))) 801 CmdArgs.push_back("-mfpxx"); 802 803 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of 804 // -mno-mips16 is actually -no-mips16. 805 if (Arg *A = 806 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) { 807 if (A->getOption().matches(options::OPT_mips16)) { 808 A->claim(); 809 A->render(Args, CmdArgs); 810 } else { 811 A->claim(); 812 CmdArgs.push_back("-no-mips16"); 813 } 814 } 815 816 Args.AddLastArg(CmdArgs, options::OPT_mmicromips, 817 options::OPT_mno_micromips); 818 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp); 819 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2); 820 821 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) { 822 // Do not use AddLastArg because not all versions of MIPS assembler 823 // support -mmsa / -mno-msa options. 824 if (A->getOption().matches(options::OPT_mmsa)) 825 CmdArgs.push_back(Args.MakeArgString("-mmsa")); 826 } 827 828 Args.AddLastArg(CmdArgs, options::OPT_mhard_float, 829 options::OPT_msoft_float); 830 831 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float, 832 options::OPT_msingle_float); 833 834 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg, 835 options::OPT_mno_odd_spreg); 836 837 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 838 break; 839 } 840 case llvm::Triple::systemz: { 841 // Always pass an -march option, since our default of z10 is later 842 // than the GNU assembler's default. 843 StringRef CPUName = systemz::getSystemZTargetCPU(Args); 844 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName)); 845 break; 846 } 847 } 848 849 Args.AddAllArgs(CmdArgs, options::OPT_I); 850 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 851 852 CmdArgs.push_back("-o"); 853 CmdArgs.push_back(Output.getFilename()); 854 855 for (const auto &II : Inputs) 856 CmdArgs.push_back(II.getFilename()); 857 858 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); 859 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 860 861 // Handle the debug info splitting at object creation time if we're 862 // creating an object. 863 // TODO: Currently only works on linux with newer objcopy. 864 if (Args.hasArg(options::OPT_gsplit_dwarf) && 865 getToolChain().getTriple().isOSLinux()) 866 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, 867 SplitDebugName(Args, Inputs[0])); 868 } 869 870 namespace { 871 // Filter to remove Multilibs that don't exist as a suffix to Path 872 class FilterNonExistent { 873 StringRef Base, File; 874 vfs::FileSystem &VFS; 875 876 public: 877 FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS) 878 : Base(Base), File(File), VFS(VFS) {} 879 bool operator()(const Multilib &M) { 880 return !VFS.exists(Base + M.gccSuffix() + File); 881 } 882 }; 883 } // end anonymous namespace 884 885 static bool isSoftFloatABI(const ArgList &Args) { 886 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, 887 options::OPT_mfloat_abi_EQ); 888 if (!A) 889 return false; 890 891 return A->getOption().matches(options::OPT_msoft_float) || 892 (A->getOption().matches(options::OPT_mfloat_abi_EQ) && 893 A->getValue() == StringRef("soft")); 894 } 895 896 static void addMultilibFlag(bool Enabled, const char *const Flag, 897 std::vector<std::string> &Flags) { 898 if (Enabled) 899 Flags.push_back(std::string("+") + Flag); 900 else 901 Flags.push_back(std::string("-") + Flag); 902 } 903 904 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) { 905 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb; 906 } 907 908 static bool isMips32(llvm::Triple::ArchType Arch) { 909 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel; 910 } 911 912 static bool isMips64(llvm::Triple::ArchType Arch) { 913 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el; 914 } 915 916 static bool isMipsEL(llvm::Triple::ArchType Arch) { 917 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el; 918 } 919 920 static bool isMips16(const ArgList &Args) { 921 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16); 922 return A && A->getOption().matches(options::OPT_mips16); 923 } 924 925 static bool isMicroMips(const ArgList &Args) { 926 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips); 927 return A && A->getOption().matches(options::OPT_mmicromips); 928 } 929 930 static Multilib makeMultilib(StringRef commonSuffix) { 931 return Multilib(commonSuffix, commonSuffix, commonSuffix); 932 } 933 934 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, 935 FilterNonExistent &NonExistent, 936 DetectedMultilibs &Result) { 937 // Check for Code Sourcery toolchain multilibs 938 MultilibSet CSMipsMultilibs; 939 { 940 auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16"); 941 942 auto MArchMicroMips = 943 makeMultilib("/micromips").flag("+m32").flag("+mmicromips"); 944 945 auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips"); 946 947 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); 948 949 auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float"); 950 951 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); 952 953 auto DefaultFloat = 954 makeMultilib("").flag("-msoft-float").flag("-mnan=2008"); 955 956 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); 957 958 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 959 960 // Note that this one's osSuffix is "" 961 auto MAbi64 = makeMultilib("") 962 .gccSuffix("/64") 963 .includeSuffix("/64") 964 .flag("+mabi=n64") 965 .flag("-mabi=n32") 966 .flag("-m32"); 967 968 CSMipsMultilibs = 969 MultilibSet() 970 .Either(MArchMips16, MArchMicroMips, MArchDefault) 971 .Maybe(UCLibc) 972 .Either(SoftFloat, Nan2008, DefaultFloat) 973 .FilterOut("/micromips/nan2008") 974 .FilterOut("/mips16/nan2008") 975 .Either(BigEndian, LittleEndian) 976 .Maybe(MAbi64) 977 .FilterOut("/mips16.*/64") 978 .FilterOut("/micromips.*/64") 979 .FilterOut(NonExistent) 980 .setIncludeDirsCallback([](const Multilib &M) { 981 std::vector<std::string> Dirs({"/include"}); 982 if (StringRef(M.includeSuffix()).startswith("/uclibc")) 983 Dirs.push_back( 984 "/../../../../mips-linux-gnu/libc/uclibc/usr/include"); 985 else 986 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include"); 987 return Dirs; 988 }); 989 } 990 991 MultilibSet DebianMipsMultilibs; 992 { 993 Multilib MAbiN32 = 994 Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32"); 995 996 Multilib M64 = Multilib() 997 .gccSuffix("/64") 998 .includeSuffix("/64") 999 .flag("+m64") 1000 .flag("-m32") 1001 .flag("-mabi=n32"); 1002 1003 Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32"); 1004 1005 DebianMipsMultilibs = 1006 MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent); 1007 } 1008 1009 // Sort candidates. Toolchain that best meets the directories tree goes first. 1010 // Then select the first toolchains matches command line flags. 1011 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs}; 1012 if (CSMipsMultilibs.size() < DebianMipsMultilibs.size()) 1013 std::iter_swap(Candidates, Candidates + 1); 1014 for (const MultilibSet *Candidate : Candidates) { 1015 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1016 if (Candidate == &DebianMipsMultilibs) 1017 Result.BiarchSibling = Multilib(); 1018 Result.Multilibs = *Candidate; 1019 return true; 1020 } 1021 } 1022 return false; 1023 } 1024 1025 static bool findMipsAndroidMultilibs(vfs::FileSystem &VFS, StringRef Path, 1026 const Multilib::flags_list &Flags, 1027 FilterNonExistent &NonExistent, 1028 DetectedMultilibs &Result) { 1029 1030 MultilibSet AndroidMipsMultilibs = 1031 MultilibSet() 1032 .Maybe(Multilib("/mips-r2").flag("+march=mips32r2")) 1033 .Maybe(Multilib("/mips-r6").flag("+march=mips32r6")) 1034 .FilterOut(NonExistent); 1035 1036 MultilibSet AndroidMipselMultilibs = 1037 MultilibSet() 1038 .Either(Multilib().flag("+march=mips32"), 1039 Multilib("/mips-r2", "", "/mips-r2").flag("+march=mips32r2"), 1040 Multilib("/mips-r6", "", "/mips-r6").flag("+march=mips32r6")) 1041 .FilterOut(NonExistent); 1042 1043 MultilibSet AndroidMips64elMultilibs = 1044 MultilibSet() 1045 .Either( 1046 Multilib().flag("+march=mips64r6"), 1047 Multilib("/32/mips-r1", "", "/mips-r1").flag("+march=mips32"), 1048 Multilib("/32/mips-r2", "", "/mips-r2").flag("+march=mips32r2"), 1049 Multilib("/32/mips-r6", "", "/mips-r6").flag("+march=mips32r6")) 1050 .FilterOut(NonExistent); 1051 1052 MultilibSet *MS = &AndroidMipsMultilibs; 1053 if (VFS.exists(Path + "/mips-r6")) 1054 MS = &AndroidMipselMultilibs; 1055 else if (VFS.exists(Path + "/32")) 1056 MS = &AndroidMips64elMultilibs; 1057 if (MS->select(Flags, Result.SelectedMultilib)) { 1058 Result.Multilibs = *MS; 1059 return true; 1060 } 1061 return false; 1062 } 1063 1064 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, 1065 FilterNonExistent &NonExistent, 1066 DetectedMultilibs &Result) { 1067 // Musl toolchain multilibs 1068 MultilibSet MuslMipsMultilibs; 1069 { 1070 auto MArchMipsR2 = makeMultilib("") 1071 .osSuffix("/mips-r2-hard-musl") 1072 .flag("+EB") 1073 .flag("-EL") 1074 .flag("+march=mips32r2"); 1075 1076 auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl") 1077 .flag("-EB") 1078 .flag("+EL") 1079 .flag("+march=mips32r2"); 1080 1081 MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2); 1082 1083 // Specify the callback that computes the include directories. 1084 MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) { 1085 return std::vector<std::string>( 1086 {"/../sysroot" + M.osSuffix() + "/usr/include"}); 1087 }); 1088 } 1089 if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) { 1090 Result.Multilibs = MuslMipsMultilibs; 1091 return true; 1092 } 1093 return false; 1094 } 1095 1096 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, 1097 FilterNonExistent &NonExistent, 1098 DetectedMultilibs &Result) { 1099 // CodeScape MTI toolchain v1.2 and early. 1100 MultilibSet MtiMipsMultilibsV1; 1101 { 1102 auto MArchMips32 = makeMultilib("/mips32") 1103 .flag("+m32") 1104 .flag("-m64") 1105 .flag("-mmicromips") 1106 .flag("+march=mips32"); 1107 1108 auto MArchMicroMips = makeMultilib("/micromips") 1109 .flag("+m32") 1110 .flag("-m64") 1111 .flag("+mmicromips"); 1112 1113 auto MArchMips64r2 = makeMultilib("/mips64r2") 1114 .flag("-m32") 1115 .flag("+m64") 1116 .flag("+march=mips64r2"); 1117 1118 auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag( 1119 "-march=mips64r2"); 1120 1121 auto MArchDefault = makeMultilib("") 1122 .flag("+m32") 1123 .flag("-m64") 1124 .flag("-mmicromips") 1125 .flag("+march=mips32r2"); 1126 1127 auto Mips16 = makeMultilib("/mips16").flag("+mips16"); 1128 1129 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); 1130 1131 auto MAbi64 = 1132 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); 1133 1134 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); 1135 1136 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 1137 1138 auto SoftFloat = makeMultilib("/sof").flag("+msoft-float"); 1139 1140 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); 1141 1142 MtiMipsMultilibsV1 = 1143 MultilibSet() 1144 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64, 1145 MArchDefault) 1146 .Maybe(UCLibc) 1147 .Maybe(Mips16) 1148 .FilterOut("/mips64/mips16") 1149 .FilterOut("/mips64r2/mips16") 1150 .FilterOut("/micromips/mips16") 1151 .Maybe(MAbi64) 1152 .FilterOut("/micromips/64") 1153 .FilterOut("/mips32/64") 1154 .FilterOut("^/64") 1155 .FilterOut("/mips16/64") 1156 .Either(BigEndian, LittleEndian) 1157 .Maybe(SoftFloat) 1158 .Maybe(Nan2008) 1159 .FilterOut(".*sof/nan2008") 1160 .FilterOut(NonExistent) 1161 .setIncludeDirsCallback([](const Multilib &M) { 1162 std::vector<std::string> Dirs({"/include"}); 1163 if (StringRef(M.includeSuffix()).startswith("/uclibc")) 1164 Dirs.push_back("/../../../../sysroot/uclibc/usr/include"); 1165 else 1166 Dirs.push_back("/../../../../sysroot/usr/include"); 1167 return Dirs; 1168 }); 1169 } 1170 1171 // CodeScape IMG toolchain starting from v1.3. 1172 MultilibSet MtiMipsMultilibsV2; 1173 { 1174 auto BeHard = makeMultilib("/mips-r2-hard") 1175 .flag("+EB") 1176 .flag("-msoft-float") 1177 .flag("-mnan=2008") 1178 .flag("-muclibc"); 1179 auto BeSoft = makeMultilib("/mips-r2-soft") 1180 .flag("+EB") 1181 .flag("+msoft-float") 1182 .flag("-mnan=2008"); 1183 auto ElHard = makeMultilib("/mipsel-r2-hard") 1184 .flag("+EL") 1185 .flag("-msoft-float") 1186 .flag("-mnan=2008") 1187 .flag("-muclibc"); 1188 auto ElSoft = makeMultilib("/mipsel-r2-soft") 1189 .flag("+EL") 1190 .flag("+msoft-float") 1191 .flag("-mnan=2008") 1192 .flag("-mmicromips"); 1193 auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008") 1194 .flag("+EB") 1195 .flag("-msoft-float") 1196 .flag("+mnan=2008") 1197 .flag("-muclibc"); 1198 auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008") 1199 .flag("+EL") 1200 .flag("-msoft-float") 1201 .flag("+mnan=2008") 1202 .flag("-muclibc") 1203 .flag("-mmicromips"); 1204 auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc") 1205 .flag("+EB") 1206 .flag("-msoft-float") 1207 .flag("+mnan=2008") 1208 .flag("+muclibc"); 1209 auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc") 1210 .flag("+EL") 1211 .flag("-msoft-float") 1212 .flag("+mnan=2008") 1213 .flag("+muclibc"); 1214 auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc") 1215 .flag("+EB") 1216 .flag("-msoft-float") 1217 .flag("-mnan=2008") 1218 .flag("+muclibc"); 1219 auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc") 1220 .flag("+EL") 1221 .flag("-msoft-float") 1222 .flag("-mnan=2008") 1223 .flag("+muclibc"); 1224 auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008") 1225 .flag("+EL") 1226 .flag("-msoft-float") 1227 .flag("+mnan=2008") 1228 .flag("+mmicromips"); 1229 auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft") 1230 .flag("+EL") 1231 .flag("+msoft-float") 1232 .flag("-mnan=2008") 1233 .flag("+mmicromips"); 1234 1235 auto O32 = 1236 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64"); 1237 auto N32 = 1238 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64"); 1239 auto N64 = 1240 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64"); 1241 1242 MtiMipsMultilibsV2 = 1243 MultilibSet() 1244 .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan, 1245 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc, 1246 ElHardUclibc, ElMicroHardNan, ElMicroSoft}) 1247 .Either(O32, N32, N64) 1248 .FilterOut(NonExistent) 1249 .setIncludeDirsCallback([](const Multilib &M) { 1250 return std::vector<std::string>({"/../../../../sysroot" + 1251 M.includeSuffix() + 1252 "/../usr/include"}); 1253 }) 1254 .setFilePathsCallback([](const Multilib &M) { 1255 return std::vector<std::string>( 1256 {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()}); 1257 }); 1258 } 1259 for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) { 1260 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1261 Result.Multilibs = *Candidate; 1262 return true; 1263 } 1264 } 1265 return false; 1266 } 1267 1268 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, 1269 FilterNonExistent &NonExistent, 1270 DetectedMultilibs &Result) { 1271 // CodeScape IMG toolchain v1.2 and early. 1272 MultilibSet ImgMultilibsV1; 1273 { 1274 auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32"); 1275 1276 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 1277 1278 auto MAbi64 = 1279 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); 1280 1281 ImgMultilibsV1 = 1282 MultilibSet() 1283 .Maybe(Mips64r6) 1284 .Maybe(MAbi64) 1285 .Maybe(LittleEndian) 1286 .FilterOut(NonExistent) 1287 .setIncludeDirsCallback([](const Multilib &M) { 1288 return std::vector<std::string>( 1289 {"/include", "/../../../../sysroot/usr/include"}); 1290 }); 1291 } 1292 1293 // CodeScape IMG toolchain starting from v1.3. 1294 MultilibSet ImgMultilibsV2; 1295 { 1296 auto BeHard = makeMultilib("/mips-r6-hard") 1297 .flag("+EB") 1298 .flag("-msoft-float") 1299 .flag("-mmicromips"); 1300 auto BeSoft = makeMultilib("/mips-r6-soft") 1301 .flag("+EB") 1302 .flag("+msoft-float") 1303 .flag("-mmicromips"); 1304 auto ElHard = makeMultilib("/mipsel-r6-hard") 1305 .flag("+EL") 1306 .flag("-msoft-float") 1307 .flag("-mmicromips"); 1308 auto ElSoft = makeMultilib("/mipsel-r6-soft") 1309 .flag("+EL") 1310 .flag("+msoft-float") 1311 .flag("-mmicromips"); 1312 auto BeMicroHard = makeMultilib("/micromips-r6-hard") 1313 .flag("+EB") 1314 .flag("-msoft-float") 1315 .flag("+mmicromips"); 1316 auto BeMicroSoft = makeMultilib("/micromips-r6-soft") 1317 .flag("+EB") 1318 .flag("+msoft-float") 1319 .flag("+mmicromips"); 1320 auto ElMicroHard = makeMultilib("/micromipsel-r6-hard") 1321 .flag("+EL") 1322 .flag("-msoft-float") 1323 .flag("+mmicromips"); 1324 auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft") 1325 .flag("+EL") 1326 .flag("+msoft-float") 1327 .flag("+mmicromips"); 1328 1329 auto O32 = 1330 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64"); 1331 auto N32 = 1332 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64"); 1333 auto N64 = 1334 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64"); 1335 1336 ImgMultilibsV2 = 1337 MultilibSet() 1338 .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft, 1339 ElMicroHard, ElMicroSoft}) 1340 .Either(O32, N32, N64) 1341 .FilterOut(NonExistent) 1342 .setIncludeDirsCallback([](const Multilib &M) { 1343 return std::vector<std::string>({"/../../../../sysroot" + 1344 M.includeSuffix() + 1345 "/../usr/include"}); 1346 }) 1347 .setFilePathsCallback([](const Multilib &M) { 1348 return std::vector<std::string>( 1349 {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()}); 1350 }); 1351 } 1352 for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) { 1353 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1354 Result.Multilibs = *Candidate; 1355 return true; 1356 } 1357 } 1358 return false; 1359 } 1360 1361 bool clang::driver::findMIPSMultilibs(const Driver &D, 1362 const llvm::Triple &TargetTriple, 1363 StringRef Path, const ArgList &Args, 1364 DetectedMultilibs &Result) { 1365 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1366 1367 StringRef CPUName; 1368 StringRef ABIName; 1369 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName); 1370 1371 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 1372 1373 Multilib::flags_list Flags; 1374 addMultilibFlag(isMips32(TargetArch), "m32", Flags); 1375 addMultilibFlag(isMips64(TargetArch), "m64", Flags); 1376 addMultilibFlag(isMips16(Args), "mips16", Flags); 1377 addMultilibFlag(CPUName == "mips32", "march=mips32", Flags); 1378 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" || 1379 CPUName == "mips32r5" || CPUName == "p5600", 1380 "march=mips32r2", Flags); 1381 addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags); 1382 addMultilibFlag(CPUName == "mips64", "march=mips64", Flags); 1383 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" || 1384 CPUName == "mips64r5" || CPUName == "octeon", 1385 "march=mips64r2", Flags); 1386 addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags); 1387 addMultilibFlag(isMicroMips(Args), "mmicromips", Flags); 1388 addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags); 1389 addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008", 1390 Flags); 1391 addMultilibFlag(ABIName == "n32", "mabi=n32", Flags); 1392 addMultilibFlag(ABIName == "n64", "mabi=n64", Flags); 1393 addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags); 1394 addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags); 1395 addMultilibFlag(isMipsEL(TargetArch), "EL", Flags); 1396 addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags); 1397 1398 if (TargetTriple.isAndroid()) 1399 return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent, 1400 Result); 1401 1402 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1403 TargetTriple.getOS() == llvm::Triple::Linux && 1404 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) 1405 return findMipsMuslMultilibs(Flags, NonExistent, Result); 1406 1407 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1408 TargetTriple.getOS() == llvm::Triple::Linux && 1409 TargetTriple.getEnvironment() == llvm::Triple::GNU) 1410 return findMipsMtiMultilibs(Flags, NonExistent, Result); 1411 1412 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies && 1413 TargetTriple.getOS() == llvm::Triple::Linux && 1414 TargetTriple.getEnvironment() == llvm::Triple::GNU) 1415 return findMipsImgMultilibs(Flags, NonExistent, Result); 1416 1417 if (findMipsCsMultilibs(Flags, NonExistent, Result)) 1418 return true; 1419 1420 // Fallback to the regular toolchain-tree structure. 1421 Multilib Default; 1422 Result.Multilibs.push_back(Default); 1423 Result.Multilibs.FilterOut(NonExistent); 1424 1425 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) { 1426 Result.BiarchSibling = Multilib(); 1427 return true; 1428 } 1429 1430 return false; 1431 } 1432 1433 static void findAndroidArmMultilibs(const Driver &D, 1434 const llvm::Triple &TargetTriple, 1435 StringRef Path, const ArgList &Args, 1436 DetectedMultilibs &Result) { 1437 // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb. 1438 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1439 Multilib ArmV7Multilib = makeMultilib("/armv7-a") 1440 .flag("+armv7") 1441 .flag("-thumb"); 1442 Multilib ThumbMultilib = makeMultilib("/thumb") 1443 .flag("-armv7") 1444 .flag("+thumb"); 1445 Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb") 1446 .flag("+armv7") 1447 .flag("+thumb"); 1448 Multilib DefaultMultilib = makeMultilib("") 1449 .flag("-armv7") 1450 .flag("-thumb"); 1451 MultilibSet AndroidArmMultilibs = 1452 MultilibSet() 1453 .Either(ThumbMultilib, ArmV7Multilib, 1454 ArmV7ThumbMultilib, DefaultMultilib) 1455 .FilterOut(NonExistent); 1456 1457 Multilib::flags_list Flags; 1458 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ); 1459 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm; 1460 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb; 1461 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7; 1462 bool IsThumbMode = IsThumbArch || 1463 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) || 1464 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB); 1465 bool IsArmV7Mode = (IsArmArch || IsThumbArch) && 1466 (llvm::ARM::parseArchVersion(Arch) == 7 || 1467 (IsArmArch && Arch == "" && IsV7SubArch)); 1468 addMultilibFlag(IsArmV7Mode, "armv7", Flags); 1469 addMultilibFlag(IsThumbMode, "thumb", Flags); 1470 1471 if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib)) 1472 Result.Multilibs = AndroidArmMultilibs; 1473 } 1474 1475 static bool findBiarchMultilibs(const Driver &D, 1476 const llvm::Triple &TargetTriple, 1477 StringRef Path, const ArgList &Args, 1478 bool NeedsBiarchSuffix, 1479 DetectedMultilibs &Result) { 1480 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs 1481 // in what would normally be GCCInstallPath and put the 64-bit 1482 // libs in a subdirectory named 64. The simple logic we follow is that 1483 // *if* there is a subdirectory of the right name with crtbegin.o in it, 1484 // we use that. If not, and if not a biarch triple alias, we look for 1485 // crtbegin.o without the subdirectory. 1486 1487 Multilib Default; 1488 Multilib Alt64 = Multilib() 1489 .gccSuffix("/64") 1490 .includeSuffix("/64") 1491 .flag("-m32") 1492 .flag("+m64") 1493 .flag("-mx32"); 1494 Multilib Alt32 = Multilib() 1495 .gccSuffix("/32") 1496 .includeSuffix("/32") 1497 .flag("+m32") 1498 .flag("-m64") 1499 .flag("-mx32"); 1500 Multilib Altx32 = Multilib() 1501 .gccSuffix("/x32") 1502 .includeSuffix("/x32") 1503 .flag("-m32") 1504 .flag("-m64") 1505 .flag("+mx32"); 1506 1507 // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a. 1508 FilterNonExistent NonExistent( 1509 Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS()); 1510 1511 // Determine default multilib from: 32, 64, x32 1512 // Also handle cases such as 64 on 32, 32 on 64, etc. 1513 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN; 1514 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32; 1515 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32)) 1516 Want = WANT64; 1517 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32)) 1518 Want = WANT64; 1519 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64)) 1520 Want = WANT32; 1521 else { 1522 if (TargetTriple.isArch32Bit()) 1523 Want = NeedsBiarchSuffix ? WANT64 : WANT32; 1524 else if (IsX32) 1525 Want = NeedsBiarchSuffix ? WANT64 : WANTX32; 1526 else 1527 Want = NeedsBiarchSuffix ? WANT32 : WANT64; 1528 } 1529 1530 if (Want == WANT32) 1531 Default.flag("+m32").flag("-m64").flag("-mx32"); 1532 else if (Want == WANT64) 1533 Default.flag("-m32").flag("+m64").flag("-mx32"); 1534 else if (Want == WANTX32) 1535 Default.flag("-m32").flag("-m64").flag("+mx32"); 1536 else 1537 return false; 1538 1539 Result.Multilibs.push_back(Default); 1540 Result.Multilibs.push_back(Alt64); 1541 Result.Multilibs.push_back(Alt32); 1542 Result.Multilibs.push_back(Altx32); 1543 1544 Result.Multilibs.FilterOut(NonExistent); 1545 1546 Multilib::flags_list Flags; 1547 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags); 1548 addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags); 1549 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags); 1550 1551 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib)) 1552 return false; 1553 1554 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 || 1555 Result.SelectedMultilib == Altx32) 1556 Result.BiarchSibling = Default; 1557 1558 return true; 1559 } 1560 1561 /// Generic_GCC - A tool chain using the 'gcc' command to perform 1562 /// all subcommands; this relies on gcc translating the majority of 1563 /// command line options. 1564 1565 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering. 1566 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor, 1567 int RHSPatch, 1568 StringRef RHSPatchSuffix) const { 1569 if (Major != RHSMajor) 1570 return Major < RHSMajor; 1571 if (Minor != RHSMinor) 1572 return Minor < RHSMinor; 1573 if (Patch != RHSPatch) { 1574 // Note that versions without a specified patch sort higher than those with 1575 // a patch. 1576 if (RHSPatch == -1) 1577 return true; 1578 if (Patch == -1) 1579 return false; 1580 1581 // Otherwise just sort on the patch itself. 1582 return Patch < RHSPatch; 1583 } 1584 if (PatchSuffix != RHSPatchSuffix) { 1585 // Sort empty suffixes higher. 1586 if (RHSPatchSuffix.empty()) 1587 return true; 1588 if (PatchSuffix.empty()) 1589 return false; 1590 1591 // Provide a lexicographic sort to make this a total ordering. 1592 return PatchSuffix < RHSPatchSuffix; 1593 } 1594 1595 // The versions are equal. 1596 return false; 1597 } 1598 1599 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) { 1600 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain); 1601 if (A) 1602 return A->getValue(); 1603 return GCC_INSTALL_PREFIX; 1604 } 1605 1606 /// \brief Initialize a GCCInstallationDetector from the driver. 1607 /// 1608 /// This performs all of the autodetection and sets up the various paths. 1609 /// Once constructed, a GCCInstallationDetector is essentially immutable. 1610 /// 1611 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and 1612 /// should instead pull the target out of the driver. This is currently 1613 /// necessary because the driver doesn't store the final version of the target 1614 /// triple. 1615 void Generic_GCC::GCCInstallationDetector::init( 1616 const llvm::Triple &TargetTriple, const ArgList &Args, 1617 ArrayRef<std::string> ExtraTripleAliases) { 1618 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit() 1619 ? TargetTriple.get64BitArchVariant() 1620 : TargetTriple.get32BitArchVariant(); 1621 // The library directories which may contain GCC installations. 1622 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs; 1623 // The compatible GCC triples for this particular architecture. 1624 SmallVector<StringRef, 16> CandidateTripleAliases; 1625 SmallVector<StringRef, 16> CandidateBiarchTripleAliases; 1626 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs, 1627 CandidateTripleAliases, CandidateBiarchLibDirs, 1628 CandidateBiarchTripleAliases); 1629 1630 // Compute the set of prefixes for our search. 1631 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(), 1632 D.PrefixDirs.end()); 1633 1634 StringRef GCCToolchainDir = getGCCToolchainDir(Args); 1635 if (GCCToolchainDir != "") { 1636 if (GCCToolchainDir.back() == '/') 1637 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the / 1638 1639 Prefixes.push_back(GCCToolchainDir); 1640 } else { 1641 // If we have a SysRoot, try that first. 1642 if (!D.SysRoot.empty()) { 1643 Prefixes.push_back(D.SysRoot); 1644 Prefixes.push_back(D.SysRoot + "/usr"); 1645 } 1646 1647 // Then look for gcc installed alongside clang. 1648 Prefixes.push_back(D.InstalledDir + "/.."); 1649 1650 // Then look for distribution supplied gcc installations. 1651 if (D.SysRoot.empty()) { 1652 // Look for RHEL devtoolsets. 1653 Prefixes.push_back("/opt/rh/devtoolset-6/root/usr"); 1654 Prefixes.push_back("/opt/rh/devtoolset-4/root/usr"); 1655 Prefixes.push_back("/opt/rh/devtoolset-3/root/usr"); 1656 Prefixes.push_back("/opt/rh/devtoolset-2/root/usr"); 1657 // And finally in /usr. 1658 Prefixes.push_back("/usr"); 1659 } 1660 } 1661 1662 // Try to respect gcc-config on Gentoo. However, do that only 1663 // if --gcc-toolchain is not provided or equal to the Gentoo install 1664 // in /usr. This avoids accidentally enforcing the system GCC version 1665 // when using a custom toolchain. 1666 if (GCCToolchainDir == "" || GCCToolchainDir == D.SysRoot + "/usr") { 1667 for (StringRef CandidateTriple : ExtraTripleAliases) { 1668 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple)) 1669 return; 1670 } 1671 for (StringRef CandidateTriple : CandidateTripleAliases) { 1672 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple)) 1673 return; 1674 } 1675 for (StringRef CandidateTriple : CandidateBiarchTripleAliases) { 1676 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true)) 1677 return; 1678 } 1679 } 1680 1681 // Loop over the various components which exist and select the best GCC 1682 // installation available. GCC installs are ranked by version number. 1683 Version = GCCVersion::Parse("0.0.0"); 1684 for (const std::string &Prefix : Prefixes) { 1685 if (!D.getVFS().exists(Prefix)) 1686 continue; 1687 for (StringRef Suffix : CandidateLibDirs) { 1688 const std::string LibDir = Prefix + Suffix.str(); 1689 if (!D.getVFS().exists(LibDir)) 1690 continue; 1691 for (StringRef Candidate : ExtraTripleAliases) // Try these first. 1692 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate); 1693 for (StringRef Candidate : CandidateTripleAliases) 1694 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate); 1695 } 1696 for (StringRef Suffix : CandidateBiarchLibDirs) { 1697 const std::string LibDir = Prefix + Suffix.str(); 1698 if (!D.getVFS().exists(LibDir)) 1699 continue; 1700 for (StringRef Candidate : CandidateBiarchTripleAliases) 1701 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, 1702 /*NeedsBiarchSuffix=*/ true); 1703 } 1704 } 1705 } 1706 1707 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const { 1708 for (const auto &InstallPath : CandidateGCCInstallPaths) 1709 OS << "Found candidate GCC installation: " << InstallPath << "\n"; 1710 1711 if (!GCCInstallPath.empty()) 1712 OS << "Selected GCC installation: " << GCCInstallPath << "\n"; 1713 1714 for (const auto &Multilib : Multilibs) 1715 OS << "Candidate multilib: " << Multilib << "\n"; 1716 1717 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault()) 1718 OS << "Selected multilib: " << SelectedMultilib << "\n"; 1719 } 1720 1721 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const { 1722 if (BiarchSibling.hasValue()) { 1723 M = BiarchSibling.getValue(); 1724 return true; 1725 } 1726 return false; 1727 } 1728 1729 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples( 1730 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple, 1731 SmallVectorImpl<StringRef> &LibDirs, 1732 SmallVectorImpl<StringRef> &TripleAliases, 1733 SmallVectorImpl<StringRef> &BiarchLibDirs, 1734 SmallVectorImpl<StringRef> &BiarchTripleAliases) { 1735 // Declare a bunch of static data sets that we'll select between below. These 1736 // are specifically designed to always refer to string literals to avoid any 1737 // lifetime or initialization issues. 1738 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; 1739 static const char *const AArch64Triples[] = { 1740 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android", 1741 "aarch64-redhat-linux", "aarch64-suse-linux"}; 1742 static const char *const AArch64beLibDirs[] = {"/lib"}; 1743 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", 1744 "aarch64_be-linux-gnu"}; 1745 1746 static const char *const ARMLibDirs[] = {"/lib"}; 1747 static const char *const ARMTriples[] = {"arm-linux-gnueabi", 1748 "arm-linux-androideabi"}; 1749 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf", 1750 "armv7hl-redhat-linux-gnueabi", 1751 "armv6hl-suse-linux-gnueabi", 1752 "armv7hl-suse-linux-gnueabi"}; 1753 static const char *const ARMebLibDirs[] = {"/lib"}; 1754 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi", 1755 "armeb-linux-androideabi"}; 1756 static const char *const ARMebHFTriples[] = { 1757 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"}; 1758 1759 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"}; 1760 static const char *const X86_64Triples[] = { 1761 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", 1762 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E", 1763 "x86_64-redhat-linux", "x86_64-suse-linux", 1764 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", 1765 "x86_64-slackware-linux", "x86_64-linux-android", 1766 "x86_64-unknown-linux"}; 1767 static const char *const X32LibDirs[] = {"/libx32"}; 1768 static const char *const X86LibDirs[] = {"/lib32", "/lib"}; 1769 static const char *const X86Triples[] = { 1770 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", 1771 "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux", 1772 "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux", 1773 "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android", 1774 "i586-linux-gnu"}; 1775 1776 static const char *const MIPSLibDirs[] = {"/lib"}; 1777 static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux", 1778 "mips-mti-linux-gnu", 1779 "mips-img-linux-gnu"}; 1780 static const char *const MIPSELLibDirs[] = {"/lib"}; 1781 static const char *const MIPSELTriples[] = {"mipsel-linux-gnu", 1782 "mips-img-linux-gnu"}; 1783 1784 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"}; 1785 static const char *const MIPS64Triples[] = { 1786 "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", 1787 "mips64-linux-gnuabi64"}; 1788 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"}; 1789 static const char *const MIPS64ELTriples[] = { 1790 "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", 1791 "mips64el-linux-gnuabi64"}; 1792 1793 static const char *const MIPSELAndroidLibDirs[] = {"/lib", "/libr2", 1794 "/libr6"}; 1795 static const char *const MIPSELAndroidTriples[] = {"mipsel-linux-android"}; 1796 static const char *const MIPS64ELAndroidLibDirs[] = {"/lib64", "/lib", 1797 "/libr2", "/libr6"}; 1798 static const char *const MIPS64ELAndroidTriples[] = { 1799 "mips64el-linux-android"}; 1800 1801 static const char *const PPCLibDirs[] = {"/lib32", "/lib"}; 1802 static const char *const PPCTriples[] = { 1803 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe", 1804 "powerpc-suse-linux", "powerpc-montavista-linuxspe"}; 1805 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"}; 1806 static const char *const PPC64Triples[] = { 1807 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu", 1808 "powerpc64-suse-linux", "ppc64-redhat-linux"}; 1809 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"}; 1810 static const char *const PPC64LETriples[] = { 1811 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu", 1812 "powerpc64le-suse-linux", "ppc64le-redhat-linux"}; 1813 1814 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"}; 1815 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu", 1816 "sparcv8-linux-gnu"}; 1817 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"}; 1818 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu", 1819 "sparcv9-linux-gnu"}; 1820 1821 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"}; 1822 static const char *const SystemZTriples[] = { 1823 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu", 1824 "s390x-suse-linux", "s390x-redhat-linux"}; 1825 1826 // Solaris. 1827 static const char *const SolarisSPARCLibDirs[] = {"/gcc"}; 1828 static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11", 1829 "i386-pc-solaris2.11"}; 1830 1831 using std::begin; 1832 using std::end; 1833 1834 if (TargetTriple.getOS() == llvm::Triple::Solaris) { 1835 LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs)); 1836 TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples)); 1837 return; 1838 } 1839 1840 switch (TargetTriple.getArch()) { 1841 case llvm::Triple::aarch64: 1842 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 1843 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 1844 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 1845 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 1846 break; 1847 case llvm::Triple::aarch64_be: 1848 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 1849 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 1850 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 1851 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 1852 break; 1853 case llvm::Triple::arm: 1854 case llvm::Triple::thumb: 1855 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs)); 1856 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 1857 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples)); 1858 } else { 1859 TripleAliases.append(begin(ARMTriples), end(ARMTriples)); 1860 } 1861 break; 1862 case llvm::Triple::armeb: 1863 case llvm::Triple::thumbeb: 1864 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs)); 1865 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 1866 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples)); 1867 } else { 1868 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples)); 1869 } 1870 break; 1871 case llvm::Triple::x86_64: 1872 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 1873 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1874 // x32 is always available when x86_64 is available, so adding it as 1875 // secondary arch with x86_64 triples 1876 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) { 1877 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs)); 1878 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1879 } else { 1880 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 1881 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples)); 1882 } 1883 break; 1884 case llvm::Triple::x86: 1885 LibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 1886 // MCU toolchain is 32 bit only and its triple alias is TargetTriple 1887 // itself, which will be appended below. 1888 if (!TargetTriple.isOSIAMCU()) { 1889 TripleAliases.append(begin(X86Triples), end(X86Triples)); 1890 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 1891 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1892 } 1893 break; 1894 case llvm::Triple::mips: 1895 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 1896 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1897 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 1898 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 1899 break; 1900 case llvm::Triple::mipsel: 1901 if (TargetTriple.isAndroid()) { 1902 LibDirs.append(begin(MIPSELAndroidLibDirs), end(MIPSELAndroidLibDirs)); 1903 TripleAliases.append(begin(MIPSELAndroidTriples), 1904 end(MIPSELAndroidTriples)); 1905 BiarchLibDirs.append(begin(MIPS64ELAndroidLibDirs), 1906 end(MIPS64ELAndroidLibDirs)); 1907 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples), 1908 end(MIPS64ELAndroidTriples)); 1909 1910 } else { 1911 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 1912 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 1913 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1914 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 1915 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 1916 } 1917 break; 1918 case llvm::Triple::mips64: 1919 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 1920 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 1921 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 1922 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1923 break; 1924 case llvm::Triple::mips64el: 1925 if (TargetTriple.isAndroid()) { 1926 LibDirs.append(begin(MIPS64ELAndroidLibDirs), 1927 end(MIPS64ELAndroidLibDirs)); 1928 TripleAliases.append(begin(MIPS64ELAndroidTriples), 1929 end(MIPS64ELAndroidTriples)); 1930 BiarchLibDirs.append(begin(MIPSELAndroidLibDirs), 1931 end(MIPSELAndroidLibDirs)); 1932 BiarchTripleAliases.append(begin(MIPSELAndroidTriples), 1933 end(MIPSELAndroidTriples)); 1934 1935 } else { 1936 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 1937 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 1938 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 1939 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 1940 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1941 } 1942 break; 1943 case llvm::Triple::ppc: 1944 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 1945 TripleAliases.append(begin(PPCTriples), end(PPCTriples)); 1946 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 1947 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 1948 break; 1949 case llvm::Triple::ppc64: 1950 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 1951 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 1952 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 1953 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples)); 1954 break; 1955 case llvm::Triple::ppc64le: 1956 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs)); 1957 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples)); 1958 break; 1959 case llvm::Triple::sparc: 1960 case llvm::Triple::sparcel: 1961 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 1962 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 1963 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 1964 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 1965 break; 1966 case llvm::Triple::sparcv9: 1967 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 1968 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 1969 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 1970 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 1971 break; 1972 case llvm::Triple::systemz: 1973 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs)); 1974 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples)); 1975 break; 1976 default: 1977 // By default, just rely on the standard lib directories and the original 1978 // triple. 1979 break; 1980 } 1981 1982 // Always append the drivers target triple to the end, in case it doesn't 1983 // match any of our aliases. 1984 TripleAliases.push_back(TargetTriple.str()); 1985 1986 // Also include the multiarch variant if it's different. 1987 if (TargetTriple.str() != BiarchTriple.str()) 1988 BiarchTripleAliases.push_back(BiarchTriple.str()); 1989 } 1990 1991 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris( 1992 const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args, 1993 const std::string &LibDir, StringRef CandidateTriple, 1994 bool NeedsBiarchSuffix) { 1995 // Solaris is a special case. The GCC installation is under 1996 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we 1997 // need to iterate twice. 1998 std::error_code EC; 1999 for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE; 2000 !EC && LI != LE; LI = LI.increment(EC)) { 2001 StringRef VersionText = llvm::sys::path::filename(LI->getName()); 2002 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2003 2004 if (CandidateVersion.Major != -1) // Filter obviously bad entries. 2005 if (!CandidateGCCInstallPaths.insert(LI->getName()).second) 2006 continue; // Saw this path before; no need to look at it again. 2007 if (CandidateVersion.isOlderThan(4, 1, 1)) 2008 continue; 2009 if (CandidateVersion <= Version) 2010 continue; 2011 2012 GCCInstallPath = 2013 LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str(); 2014 if (!D.getVFS().exists(GCCInstallPath)) 2015 continue; 2016 2017 // If we make it here there has to be at least one GCC version, let's just 2018 // use the latest one. 2019 std::error_code EEC; 2020 for (vfs::directory_iterator 2021 LLI = D.getVFS().dir_begin(GCCInstallPath, EEC), 2022 LLE; 2023 !EEC && LLI != LLE; LLI = LLI.increment(EEC)) { 2024 2025 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName()); 2026 GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText); 2027 2028 if (CandidateSubVersion > Version) 2029 Version = CandidateSubVersion; 2030 } 2031 2032 GCCTriple.setTriple(CandidateTriple); 2033 2034 GCCInstallPath += "/" + Version.Text; 2035 GCCParentLibPath = GCCInstallPath + "/../../../../"; 2036 2037 IsValid = true; 2038 } 2039 } 2040 2041 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs( 2042 const llvm::Triple &TargetTriple, const ArgList &Args, 2043 StringRef Path, bool NeedsBiarchSuffix) { 2044 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 2045 DetectedMultilibs Detected; 2046 2047 // Android standalone toolchain could have multilibs for ARM and Thumb. 2048 // Debian mips multilibs behave more like the rest of the biarch ones, 2049 // so handle them there 2050 if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) { 2051 // It should also work without multilibs in a simplified toolchain. 2052 findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected); 2053 } else if (tools::isMipsArch(TargetArch)) { 2054 if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected)) 2055 return false; 2056 } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args, 2057 NeedsBiarchSuffix, Detected)) { 2058 return false; 2059 } 2060 2061 Multilibs = Detected.Multilibs; 2062 SelectedMultilib = Detected.SelectedMultilib; 2063 BiarchSibling = Detected.BiarchSibling; 2064 2065 return true; 2066 } 2067 2068 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( 2069 const llvm::Triple &TargetTriple, const ArgList &Args, 2070 const std::string &LibDir, StringRef CandidateTriple, 2071 bool NeedsBiarchSuffix) { 2072 if (TargetTriple.getOS() == llvm::Triple::Solaris) { 2073 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple, 2074 NeedsBiarchSuffix); 2075 return; 2076 } 2077 2078 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 2079 // Locations relative to the system lib directory where GCC's triple-specific 2080 // directories might reside. 2081 struct GCCLibSuffix { 2082 // Path from system lib directory to GCC triple-specific directory. 2083 std::string LibSuffix; 2084 // Path from GCC triple-specific directory back to system lib directory. 2085 // This is one '..' component per component in LibSuffix. 2086 StringRef ReversePath; 2087 // Whether this library suffix is relevant for the triple. 2088 bool Active; 2089 } Suffixes[] = { 2090 // This is the normal place. 2091 {"gcc/" + CandidateTriple.str(), "../..", true}, 2092 2093 // Debian puts cross-compilers in gcc-cross. 2094 {"gcc-cross/" + CandidateTriple.str(), "../..", true}, 2095 2096 // The Freescale PPC SDK has the gcc libraries in 2097 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do 2098 // this on Freescale triples, though, since some systems put a *lot* of 2099 // files in that location, not just GCC installation data. 2100 {CandidateTriple.str(), "..", 2101 TargetTriple.getVendor() == llvm::Triple::Freescale}, 2102 2103 // Natively multiarch systems sometimes put the GCC triple-specific 2104 // directory within their multiarch lib directory, resulting in the 2105 // triple appearing twice. 2106 {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..", true}, 2107 2108 // Deal with cases (on Ubuntu) where the system architecture could be i386 2109 // but the GCC target architecture could be (say) i686. 2110 // FIXME: It may be worthwhile to generalize this and look for a second 2111 // triple. 2112 {"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..", 2113 TargetArch == llvm::Triple::x86} 2114 }; 2115 2116 for (auto &Suffix : Suffixes) { 2117 if (!Suffix.Active) 2118 continue; 2119 2120 StringRef LibSuffix = Suffix.LibSuffix; 2121 std::error_code EC; 2122 for (vfs::directory_iterator 2123 LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC), 2124 LE; 2125 !EC && LI != LE; LI = LI.increment(EC)) { 2126 StringRef VersionText = llvm::sys::path::filename(LI->getName()); 2127 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2128 if (CandidateVersion.Major != -1) // Filter obviously bad entries. 2129 if (!CandidateGCCInstallPaths.insert(LI->getName()).second) 2130 continue; // Saw this path before; no need to look at it again. 2131 if (CandidateVersion.isOlderThan(4, 1, 1)) 2132 continue; 2133 if (CandidateVersion <= Version) 2134 continue; 2135 2136 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->getName(), 2137 NeedsBiarchSuffix)) 2138 continue; 2139 2140 Version = CandidateVersion; 2141 GCCTriple.setTriple(CandidateTriple); 2142 // FIXME: We hack together the directory name here instead of 2143 // using LI to ensure stable path separators across Windows and 2144 // Linux. 2145 GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str(); 2146 GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str(); 2147 IsValid = true; 2148 } 2149 } 2150 } 2151 2152 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig( 2153 const llvm::Triple &TargetTriple, const ArgList &Args, 2154 StringRef CandidateTriple, bool NeedsBiarchSuffix) { 2155 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File = 2156 D.getVFS().getBufferForFile(D.SysRoot + "/etc/env.d/gcc/config-" + 2157 CandidateTriple.str()); 2158 if (File) { 2159 SmallVector<StringRef, 2> Lines; 2160 File.get()->getBuffer().split(Lines, "\n"); 2161 for (StringRef Line : Lines) { 2162 Line = Line.trim(); 2163 // CURRENT=triple-version 2164 if (Line.consume_front("CURRENT=")) { 2165 const std::pair<StringRef, StringRef> ActiveVersion = 2166 Line.rsplit('-'); 2167 // Note: Strictly speaking, we should be reading 2168 // /etc/env.d/gcc/${CURRENT} now. However, the file doesn't 2169 // contain anything new or especially useful to us. 2170 const std::string GentooPath = D.SysRoot + "/usr/lib/gcc/" + 2171 ActiveVersion.first.str() + "/" + 2172 ActiveVersion.second.str(); 2173 if (D.getVFS().exists(GentooPath + "/crtbegin.o")) { 2174 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath, 2175 NeedsBiarchSuffix)) 2176 return false; 2177 2178 Version = GCCVersion::Parse(ActiveVersion.second); 2179 GCCInstallPath = GentooPath; 2180 GCCParentLibPath = GentooPath + "/../../.."; 2181 GCCTriple.setTriple(ActiveVersion.first); 2182 IsValid = true; 2183 return true; 2184 } 2185 } 2186 } 2187 } 2188 2189 return false; 2190 } 2191 2192 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple, 2193 const ArgList &Args) 2194 : ToolChain(D, Triple, Args), GCCInstallation(D), 2195 CudaInstallation(D, Triple, Args) { 2196 getProgramPaths().push_back(getDriver().getInstalledDir()); 2197 if (getDriver().getInstalledDir() != getDriver().Dir) 2198 getProgramPaths().push_back(getDriver().Dir); 2199 } 2200 2201 Generic_GCC::~Generic_GCC() {} 2202 2203 Tool *Generic_GCC::getTool(Action::ActionClass AC) const { 2204 switch (AC) { 2205 case Action::PreprocessJobClass: 2206 if (!Preprocess) 2207 Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this)); 2208 return Preprocess.get(); 2209 case Action::CompileJobClass: 2210 if (!Compile) 2211 Compile.reset(new tools::gcc::Compiler(*this)); 2212 return Compile.get(); 2213 default: 2214 return ToolChain::getTool(AC); 2215 } 2216 } 2217 2218 Tool *Generic_GCC::buildAssembler() const { 2219 return new tools::gnutools::Assembler(*this); 2220 } 2221 2222 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); } 2223 2224 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const { 2225 // Print the information about how we detected the GCC installation. 2226 GCCInstallation.print(OS); 2227 CudaInstallation.print(OS); 2228 } 2229 2230 bool Generic_GCC::IsUnwindTablesDefault() const { 2231 return getArch() == llvm::Triple::x86_64; 2232 } 2233 2234 bool Generic_GCC::isPICDefault() const { 2235 switch (getArch()) { 2236 case llvm::Triple::x86_64: 2237 return getTriple().isOSWindows(); 2238 case llvm::Triple::ppc64: 2239 case llvm::Triple::ppc64le: 2240 return !getTriple().isOSBinFormatMachO() && !getTriple().isMacOSX(); 2241 case llvm::Triple::mips64: 2242 case llvm::Triple::mips64el: 2243 return true; 2244 default: 2245 return false; 2246 } 2247 } 2248 2249 bool Generic_GCC::isPIEDefault() const { return false; } 2250 2251 bool Generic_GCC::isPICDefaultForced() const { 2252 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows(); 2253 } 2254 2255 bool Generic_GCC::IsIntegratedAssemblerDefault() const { 2256 switch (getTriple().getArch()) { 2257 case llvm::Triple::x86: 2258 case llvm::Triple::x86_64: 2259 case llvm::Triple::aarch64: 2260 case llvm::Triple::aarch64_be: 2261 case llvm::Triple::arm: 2262 case llvm::Triple::armeb: 2263 case llvm::Triple::avr: 2264 case llvm::Triple::bpfel: 2265 case llvm::Triple::bpfeb: 2266 case llvm::Triple::thumb: 2267 case llvm::Triple::thumbeb: 2268 case llvm::Triple::ppc: 2269 case llvm::Triple::ppc64: 2270 case llvm::Triple::ppc64le: 2271 case llvm::Triple::systemz: 2272 case llvm::Triple::mips: 2273 case llvm::Triple::mipsel: 2274 return true; 2275 case llvm::Triple::mips64: 2276 case llvm::Triple::mips64el: 2277 // Enabled for Debian mips64/mips64el only. Other targets are unable to 2278 // distinguish N32 from N64. 2279 if (getTriple().getEnvironment() == llvm::Triple::GNUABI64) 2280 return true; 2281 return false; 2282 default: 2283 return false; 2284 } 2285 } 2286 2287 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 2288 ArgStringList &CC1Args) const { 2289 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 2290 DriverArgs.hasArg(options::OPT_nostdincxx)) 2291 return; 2292 2293 switch (GetCXXStdlibType(DriverArgs)) { 2294 case ToolChain::CST_Libcxx: { 2295 std::string Path = findLibCxxIncludePath(); 2296 if (!Path.empty()) 2297 addSystemInclude(DriverArgs, CC1Args, Path); 2298 break; 2299 } 2300 2301 case ToolChain::CST_Libstdcxx: 2302 addLibStdCxxIncludePaths(DriverArgs, CC1Args); 2303 break; 2304 } 2305 } 2306 2307 std::string Generic_GCC::findLibCxxIncludePath() const { 2308 // FIXME: The Linux behavior would probaby be a better approach here. 2309 return getDriver().SysRoot + "/usr/include/c++/v1"; 2310 } 2311 2312 void 2313 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 2314 llvm::opt::ArgStringList &CC1Args) const { 2315 // By default, we don't assume we know where libstdc++ might be installed. 2316 // FIXME: If we have a valid GCCInstallation, use it. 2317 } 2318 2319 /// \brief Helper to add the variant paths of a libstdc++ installation. 2320 bool Generic_GCC::addLibStdCXXIncludePaths( 2321 Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, 2322 StringRef TargetMultiarchTriple, Twine IncludeSuffix, 2323 const ArgList &DriverArgs, ArgStringList &CC1Args) const { 2324 if (!getVFS().exists(Base + Suffix)) 2325 return false; 2326 2327 addSystemInclude(DriverArgs, CC1Args, Base + Suffix); 2328 2329 // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If 2330 // that path exists or we have neither a GCC nor target multiarch triple, use 2331 // this vanilla search path. 2332 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) || 2333 getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) { 2334 addSystemInclude(DriverArgs, CC1Args, 2335 Base + Suffix + "/" + GCCTriple + IncludeSuffix); 2336 } else { 2337 // Otherwise try to use multiarch naming schemes which have normalized the 2338 // triples and put the triple before the suffix. 2339 // 2340 // GCC surprisingly uses *both* the GCC triple with a multilib suffix and 2341 // the target triple, so we support that here. 2342 addSystemInclude(DriverArgs, CC1Args, 2343 Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix); 2344 addSystemInclude(DriverArgs, CC1Args, 2345 Base + "/" + TargetMultiarchTriple + Suffix); 2346 } 2347 2348 addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward"); 2349 return true; 2350 } 2351 2352 llvm::opt::DerivedArgList * 2353 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef, 2354 Action::OffloadKind DeviceOffloadKind) const { 2355 2356 // If this tool chain is used for an OpenMP offloading device we have to make 2357 // sure we always generate a shared library regardless of the commands the 2358 // user passed to the host. This is required because the runtime library 2359 // is required to load the device image dynamically at run time. 2360 if (DeviceOffloadKind == Action::OFK_OpenMP) { 2361 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 2362 const OptTable &Opts = getDriver().getOpts(); 2363 2364 // Request the shared library. Given that these options are decided 2365 // implicitly, they do not refer to any base argument. 2366 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared)); 2367 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC)); 2368 2369 // Filter all the arguments we don't care passing to the offloading 2370 // toolchain as they can mess up with the creation of a shared library. 2371 for (auto *A : Args) { 2372 switch ((options::ID)A->getOption().getID()) { 2373 default: 2374 DAL->append(A); 2375 break; 2376 case options::OPT_shared: 2377 case options::OPT_dynamic: 2378 case options::OPT_static: 2379 case options::OPT_fPIC: 2380 case options::OPT_fno_PIC: 2381 case options::OPT_fpic: 2382 case options::OPT_fno_pic: 2383 case options::OPT_fPIE: 2384 case options::OPT_fno_PIE: 2385 case options::OPT_fpie: 2386 case options::OPT_fno_pie: 2387 break; 2388 } 2389 } 2390 return DAL; 2391 } 2392 return nullptr; 2393 } 2394 2395 void Generic_ELF::anchor() {} 2396 2397 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs, 2398 ArgStringList &CC1Args) const { 2399 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion(); 2400 bool UseInitArrayDefault = 2401 getTriple().getArch() == llvm::Triple::aarch64 || 2402 getTriple().getArch() == llvm::Triple::aarch64_be || 2403 (getTriple().getOS() == llvm::Triple::Linux && 2404 (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) || 2405 getTriple().getOS() == llvm::Triple::NaCl || 2406 (getTriple().getVendor() == llvm::Triple::MipsTechnologies && 2407 !getTriple().hasEnvironment()); 2408 2409 if (DriverArgs.hasFlag(options::OPT_fuse_init_array, 2410 options::OPT_fno_use_init_array, UseInitArrayDefault)) 2411 CC1Args.push_back("-fuse-init-array"); 2412 } 2413