Gnu.cpp revision 321238
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 30using namespace clang::driver; 31using namespace clang::driver::toolchains; 32using namespace clang; 33using namespace llvm::opt; 34 35void tools::GnuTool::anchor() {} 36 37static 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 44void 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 168void tools::gcc::Preprocessor::RenderExtraToolArgs( 169 const JobAction &JA, ArgStringList &CmdArgs) const { 170 CmdArgs.push_back("-E"); 171} 172 173void 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 201void 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. 212static 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 282 // Put each target binary into a separate section. 283 for (const auto &BI : InputBinaryInfo) { 284 LksStream << " .omp_offloading." << BI.first << " :\n"; 285 LksStream << " ALIGN(0x10)\n"; 286 LksStream << " {\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 LksStream << " }\n"; 293 } 294 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 331static 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 343static 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 354static 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 404void 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 647void 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 const auto &D = getToolChain().getDriver(); 654 655 claimNoWarnArgs(Args); 656 657 ArgStringList CmdArgs; 658 659 llvm::Reloc::Model RelocationModel; 660 unsigned PICLevel; 661 bool IsPIE; 662 std::tie(RelocationModel, PICLevel, IsPIE) = 663 ParsePICArgs(getToolChain(), Args); 664 665 if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) { 666 if (A->getOption().getID() == options::OPT_gz) { 667 CmdArgs.push_back("-compress-debug-sections"); 668 } else { 669 StringRef Value = A->getValue(); 670 if (Value == "none") { 671 CmdArgs.push_back("-compress-debug-sections=none"); 672 } else if (Value == "zlib" || Value == "zlib-gnu") { 673 CmdArgs.push_back( 674 Args.MakeArgString("-compress-debug-sections=" + Twine(Value))); 675 } else { 676 D.Diag(diag::err_drv_unsupported_option_argument) 677 << A->getOption().getName() << Value; 678 } 679 } 680 } 681 682 switch (getToolChain().getArch()) { 683 default: 684 break; 685 // Add --32/--64 to make sure we get the format we want. 686 // This is incomplete 687 case llvm::Triple::x86: 688 CmdArgs.push_back("--32"); 689 break; 690 case llvm::Triple::x86_64: 691 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32) 692 CmdArgs.push_back("--x32"); 693 else 694 CmdArgs.push_back("--64"); 695 break; 696 case llvm::Triple::ppc: 697 CmdArgs.push_back("-a32"); 698 CmdArgs.push_back("-mppc"); 699 CmdArgs.push_back("-many"); 700 break; 701 case llvm::Triple::ppc64: 702 CmdArgs.push_back("-a64"); 703 CmdArgs.push_back("-mppc64"); 704 CmdArgs.push_back("-many"); 705 break; 706 case llvm::Triple::ppc64le: 707 CmdArgs.push_back("-a64"); 708 CmdArgs.push_back("-mppc64"); 709 CmdArgs.push_back("-many"); 710 CmdArgs.push_back("-mlittle-endian"); 711 break; 712 case llvm::Triple::sparc: 713 case llvm::Triple::sparcel: { 714 CmdArgs.push_back("-32"); 715 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 716 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 717 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 718 break; 719 } 720 case llvm::Triple::sparcv9: { 721 CmdArgs.push_back("-64"); 722 std::string CPU = getCPUName(Args, getToolChain().getTriple()); 723 CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple())); 724 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 725 break; 726 } 727 case llvm::Triple::arm: 728 case llvm::Triple::armeb: 729 case llvm::Triple::thumb: 730 case llvm::Triple::thumbeb: { 731 const llvm::Triple &Triple2 = getToolChain().getTriple(); 732 switch (Triple2.getSubArch()) { 733 case llvm::Triple::ARMSubArch_v7: 734 CmdArgs.push_back("-mfpu=neon"); 735 break; 736 case llvm::Triple::ARMSubArch_v8: 737 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8"); 738 break; 739 default: 740 break; 741 } 742 743 switch (arm::getARMFloatABI(getToolChain(), Args)) { 744 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!"); 745 case arm::FloatABI::Soft: 746 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft")); 747 break; 748 case arm::FloatABI::SoftFP: 749 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp")); 750 break; 751 case arm::FloatABI::Hard: 752 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard")); 753 break; 754 } 755 756 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 757 758 // FIXME: remove krait check when GNU tools support krait cpu 759 // for now replace it with -mcpu=cortex-a15 to avoid a lower 760 // march from being picked in the absence of a cpu flag. 761 Arg *A; 762 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) && 763 StringRef(A->getValue()).equals_lower("krait")) 764 CmdArgs.push_back("-mcpu=cortex-a15"); 765 else 766 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 767 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); 768 break; 769 } 770 case llvm::Triple::aarch64: 771 case llvm::Triple::aarch64_be: { 772 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 773 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 774 break; 775 } 776 case llvm::Triple::mips: 777 case llvm::Triple::mipsel: 778 case llvm::Triple::mips64: 779 case llvm::Triple::mips64el: { 780 StringRef CPUName; 781 StringRef ABIName; 782 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 783 ABIName = mips::getGnuCompatibleMipsABIName(ABIName); 784 785 CmdArgs.push_back("-march"); 786 CmdArgs.push_back(CPUName.data()); 787 788 CmdArgs.push_back("-mabi"); 789 CmdArgs.push_back(ABIName.data()); 790 791 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE, 792 // or -mshared (not implemented) is in effect. 793 if (RelocationModel == llvm::Reloc::Static) 794 CmdArgs.push_back("-mno-shared"); 795 796 // LLVM doesn't support -mplt yet and acts as if it is always given. 797 // However, -mplt has no effect with the N64 ABI. 798 if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls)) 799 CmdArgs.push_back("-call_nonpic"); 800 801 if (getToolChain().getArch() == llvm::Triple::mips || 802 getToolChain().getArch() == llvm::Triple::mips64) 803 CmdArgs.push_back("-EB"); 804 else 805 CmdArgs.push_back("-EL"); 806 807 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 808 if (StringRef(A->getValue()) == "2008") 809 CmdArgs.push_back(Args.MakeArgString("-mnan=2008")); 810 } 811 812 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default. 813 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx, 814 options::OPT_mfp64)) { 815 A->claim(); 816 A->render(Args, CmdArgs); 817 } else if (mips::shouldUseFPXX( 818 Args, getToolChain().getTriple(), CPUName, ABIName, 819 mips::getMipsFloatABI(getToolChain().getDriver(), Args))) 820 CmdArgs.push_back("-mfpxx"); 821 822 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of 823 // -mno-mips16 is actually -no-mips16. 824 if (Arg *A = 825 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) { 826 if (A->getOption().matches(options::OPT_mips16)) { 827 A->claim(); 828 A->render(Args, CmdArgs); 829 } else { 830 A->claim(); 831 CmdArgs.push_back("-no-mips16"); 832 } 833 } 834 835 Args.AddLastArg(CmdArgs, options::OPT_mmicromips, 836 options::OPT_mno_micromips); 837 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp); 838 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2); 839 840 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) { 841 // Do not use AddLastArg because not all versions of MIPS assembler 842 // support -mmsa / -mno-msa options. 843 if (A->getOption().matches(options::OPT_mmsa)) 844 CmdArgs.push_back(Args.MakeArgString("-mmsa")); 845 } 846 847 Args.AddLastArg(CmdArgs, options::OPT_mhard_float, 848 options::OPT_msoft_float); 849 850 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float, 851 options::OPT_msingle_float); 852 853 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg, 854 options::OPT_mno_odd_spreg); 855 856 AddAssemblerKPIC(getToolChain(), Args, CmdArgs); 857 break; 858 } 859 case llvm::Triple::systemz: { 860 // Always pass an -march option, since our default of z10 is later 861 // than the GNU assembler's default. 862 StringRef CPUName = systemz::getSystemZTargetCPU(Args); 863 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName)); 864 break; 865 } 866 } 867 868 Args.AddAllArgs(CmdArgs, options::OPT_I); 869 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 870 871 CmdArgs.push_back("-o"); 872 CmdArgs.push_back(Output.getFilename()); 873 874 for (const auto &II : Inputs) 875 CmdArgs.push_back(II.getFilename()); 876 877 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); 878 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 879 880 // Handle the debug info splitting at object creation time if we're 881 // creating an object. 882 // TODO: Currently only works on linux with newer objcopy. 883 if (Args.hasArg(options::OPT_gsplit_dwarf) && 884 getToolChain().getTriple().isOSLinux()) 885 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, 886 SplitDebugName(Args, Inputs[0])); 887} 888 889namespace { 890// Filter to remove Multilibs that don't exist as a suffix to Path 891class FilterNonExistent { 892 StringRef Base, File; 893 vfs::FileSystem &VFS; 894 895public: 896 FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS) 897 : Base(Base), File(File), VFS(VFS) {} 898 bool operator()(const Multilib &M) { 899 return !VFS.exists(Base + M.gccSuffix() + File); 900 } 901}; 902} // end anonymous namespace 903 904static bool isSoftFloatABI(const ArgList &Args) { 905 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, 906 options::OPT_mfloat_abi_EQ); 907 if (!A) 908 return false; 909 910 return A->getOption().matches(options::OPT_msoft_float) || 911 (A->getOption().matches(options::OPT_mfloat_abi_EQ) && 912 A->getValue() == StringRef("soft")); 913} 914 915/// \p Flag must be a flag accepted by the driver with its leading '-' removed, 916// otherwise '-print-multi-lib' will not emit them correctly. 917static void addMultilibFlag(bool Enabled, const char *const Flag, 918 std::vector<std::string> &Flags) { 919 if (Enabled) 920 Flags.push_back(std::string("+") + Flag); 921 else 922 Flags.push_back(std::string("-") + Flag); 923} 924 925static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) { 926 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb; 927} 928 929static bool isMips32(llvm::Triple::ArchType Arch) { 930 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel; 931} 932 933static bool isMips64(llvm::Triple::ArchType Arch) { 934 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el; 935} 936 937static bool isMipsEL(llvm::Triple::ArchType Arch) { 938 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el; 939} 940 941static bool isMips16(const ArgList &Args) { 942 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16); 943 return A && A->getOption().matches(options::OPT_mips16); 944} 945 946static bool isMicroMips(const ArgList &Args) { 947 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips); 948 return A && A->getOption().matches(options::OPT_mmicromips); 949} 950 951static Multilib makeMultilib(StringRef commonSuffix) { 952 return Multilib(commonSuffix, commonSuffix, commonSuffix); 953} 954 955static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, 956 FilterNonExistent &NonExistent, 957 DetectedMultilibs &Result) { 958 // Check for Code Sourcery toolchain multilibs 959 MultilibSet CSMipsMultilibs; 960 { 961 auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16"); 962 963 auto MArchMicroMips = 964 makeMultilib("/micromips").flag("+m32").flag("+mmicromips"); 965 966 auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips"); 967 968 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); 969 970 auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float"); 971 972 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); 973 974 auto DefaultFloat = 975 makeMultilib("").flag("-msoft-float").flag("-mnan=2008"); 976 977 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); 978 979 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 980 981 // Note that this one's osSuffix is "" 982 auto MAbi64 = makeMultilib("") 983 .gccSuffix("/64") 984 .includeSuffix("/64") 985 .flag("+mabi=n64") 986 .flag("-mabi=n32") 987 .flag("-m32"); 988 989 CSMipsMultilibs = 990 MultilibSet() 991 .Either(MArchMips16, MArchMicroMips, MArchDefault) 992 .Maybe(UCLibc) 993 .Either(SoftFloat, Nan2008, DefaultFloat) 994 .FilterOut("/micromips/nan2008") 995 .FilterOut("/mips16/nan2008") 996 .Either(BigEndian, LittleEndian) 997 .Maybe(MAbi64) 998 .FilterOut("/mips16.*/64") 999 .FilterOut("/micromips.*/64") 1000 .FilterOut(NonExistent) 1001 .setIncludeDirsCallback([](const Multilib &M) { 1002 std::vector<std::string> Dirs({"/include"}); 1003 if (StringRef(M.includeSuffix()).startswith("/uclibc")) 1004 Dirs.push_back( 1005 "/../../../../mips-linux-gnu/libc/uclibc/usr/include"); 1006 else 1007 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include"); 1008 return Dirs; 1009 }); 1010 } 1011 1012 MultilibSet DebianMipsMultilibs; 1013 { 1014 Multilib MAbiN32 = 1015 Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32"); 1016 1017 Multilib M64 = Multilib() 1018 .gccSuffix("/64") 1019 .includeSuffix("/64") 1020 .flag("+m64") 1021 .flag("-m32") 1022 .flag("-mabi=n32"); 1023 1024 Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32"); 1025 1026 DebianMipsMultilibs = 1027 MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent); 1028 } 1029 1030 // Sort candidates. Toolchain that best meets the directories tree goes first. 1031 // Then select the first toolchains matches command line flags. 1032 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs}; 1033 if (CSMipsMultilibs.size() < DebianMipsMultilibs.size()) 1034 std::iter_swap(Candidates, Candidates + 1); 1035 for (const MultilibSet *Candidate : Candidates) { 1036 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1037 if (Candidate == &DebianMipsMultilibs) 1038 Result.BiarchSibling = Multilib(); 1039 Result.Multilibs = *Candidate; 1040 return true; 1041 } 1042 } 1043 return false; 1044} 1045 1046static bool findMipsAndroidMultilibs(vfs::FileSystem &VFS, StringRef Path, 1047 const Multilib::flags_list &Flags, 1048 FilterNonExistent &NonExistent, 1049 DetectedMultilibs &Result) { 1050 1051 MultilibSet AndroidMipsMultilibs = 1052 MultilibSet() 1053 .Maybe(Multilib("/mips-r2").flag("+march=mips32r2")) 1054 .Maybe(Multilib("/mips-r6").flag("+march=mips32r6")) 1055 .FilterOut(NonExistent); 1056 1057 MultilibSet AndroidMipselMultilibs = 1058 MultilibSet() 1059 .Either(Multilib().flag("+march=mips32"), 1060 Multilib("/mips-r2", "", "/mips-r2").flag("+march=mips32r2"), 1061 Multilib("/mips-r6", "", "/mips-r6").flag("+march=mips32r6")) 1062 .FilterOut(NonExistent); 1063 1064 MultilibSet AndroidMips64elMultilibs = 1065 MultilibSet() 1066 .Either( 1067 Multilib().flag("+march=mips64r6"), 1068 Multilib("/32/mips-r1", "", "/mips-r1").flag("+march=mips32"), 1069 Multilib("/32/mips-r2", "", "/mips-r2").flag("+march=mips32r2"), 1070 Multilib("/32/mips-r6", "", "/mips-r6").flag("+march=mips32r6")) 1071 .FilterOut(NonExistent); 1072 1073 MultilibSet *MS = &AndroidMipsMultilibs; 1074 if (VFS.exists(Path + "/mips-r6")) 1075 MS = &AndroidMipselMultilibs; 1076 else if (VFS.exists(Path + "/32")) 1077 MS = &AndroidMips64elMultilibs; 1078 if (MS->select(Flags, Result.SelectedMultilib)) { 1079 Result.Multilibs = *MS; 1080 return true; 1081 } 1082 return false; 1083} 1084 1085static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, 1086 FilterNonExistent &NonExistent, 1087 DetectedMultilibs &Result) { 1088 // Musl toolchain multilibs 1089 MultilibSet MuslMipsMultilibs; 1090 { 1091 auto MArchMipsR2 = makeMultilib("") 1092 .osSuffix("/mips-r2-hard-musl") 1093 .flag("+EB") 1094 .flag("-EL") 1095 .flag("+march=mips32r2"); 1096 1097 auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl") 1098 .flag("-EB") 1099 .flag("+EL") 1100 .flag("+march=mips32r2"); 1101 1102 MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2); 1103 1104 // Specify the callback that computes the include directories. 1105 MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) { 1106 return std::vector<std::string>( 1107 {"/../sysroot" + M.osSuffix() + "/usr/include"}); 1108 }); 1109 } 1110 if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) { 1111 Result.Multilibs = MuslMipsMultilibs; 1112 return true; 1113 } 1114 return false; 1115} 1116 1117static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, 1118 FilterNonExistent &NonExistent, 1119 DetectedMultilibs &Result) { 1120 // CodeScape MTI toolchain v1.2 and early. 1121 MultilibSet MtiMipsMultilibsV1; 1122 { 1123 auto MArchMips32 = makeMultilib("/mips32") 1124 .flag("+m32") 1125 .flag("-m64") 1126 .flag("-mmicromips") 1127 .flag("+march=mips32"); 1128 1129 auto MArchMicroMips = makeMultilib("/micromips") 1130 .flag("+m32") 1131 .flag("-m64") 1132 .flag("+mmicromips"); 1133 1134 auto MArchMips64r2 = makeMultilib("/mips64r2") 1135 .flag("-m32") 1136 .flag("+m64") 1137 .flag("+march=mips64r2"); 1138 1139 auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag( 1140 "-march=mips64r2"); 1141 1142 auto MArchDefault = makeMultilib("") 1143 .flag("+m32") 1144 .flag("-m64") 1145 .flag("-mmicromips") 1146 .flag("+march=mips32r2"); 1147 1148 auto Mips16 = makeMultilib("/mips16").flag("+mips16"); 1149 1150 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); 1151 1152 auto MAbi64 = 1153 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); 1154 1155 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); 1156 1157 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 1158 1159 auto SoftFloat = makeMultilib("/sof").flag("+msoft-float"); 1160 1161 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); 1162 1163 MtiMipsMultilibsV1 = 1164 MultilibSet() 1165 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64, 1166 MArchDefault) 1167 .Maybe(UCLibc) 1168 .Maybe(Mips16) 1169 .FilterOut("/mips64/mips16") 1170 .FilterOut("/mips64r2/mips16") 1171 .FilterOut("/micromips/mips16") 1172 .Maybe(MAbi64) 1173 .FilterOut("/micromips/64") 1174 .FilterOut("/mips32/64") 1175 .FilterOut("^/64") 1176 .FilterOut("/mips16/64") 1177 .Either(BigEndian, LittleEndian) 1178 .Maybe(SoftFloat) 1179 .Maybe(Nan2008) 1180 .FilterOut(".*sof/nan2008") 1181 .FilterOut(NonExistent) 1182 .setIncludeDirsCallback([](const Multilib &M) { 1183 std::vector<std::string> Dirs({"/include"}); 1184 if (StringRef(M.includeSuffix()).startswith("/uclibc")) 1185 Dirs.push_back("/../../../../sysroot/uclibc/usr/include"); 1186 else 1187 Dirs.push_back("/../../../../sysroot/usr/include"); 1188 return Dirs; 1189 }); 1190 } 1191 1192 // CodeScape IMG toolchain starting from v1.3. 1193 MultilibSet MtiMipsMultilibsV2; 1194 { 1195 auto BeHard = makeMultilib("/mips-r2-hard") 1196 .flag("+EB") 1197 .flag("-msoft-float") 1198 .flag("-mnan=2008") 1199 .flag("-muclibc"); 1200 auto BeSoft = makeMultilib("/mips-r2-soft") 1201 .flag("+EB") 1202 .flag("+msoft-float") 1203 .flag("-mnan=2008"); 1204 auto ElHard = makeMultilib("/mipsel-r2-hard") 1205 .flag("+EL") 1206 .flag("-msoft-float") 1207 .flag("-mnan=2008") 1208 .flag("-muclibc"); 1209 auto ElSoft = makeMultilib("/mipsel-r2-soft") 1210 .flag("+EL") 1211 .flag("+msoft-float") 1212 .flag("-mnan=2008") 1213 .flag("-mmicromips"); 1214 auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008") 1215 .flag("+EB") 1216 .flag("-msoft-float") 1217 .flag("+mnan=2008") 1218 .flag("-muclibc"); 1219 auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008") 1220 .flag("+EL") 1221 .flag("-msoft-float") 1222 .flag("+mnan=2008") 1223 .flag("-muclibc") 1224 .flag("-mmicromips"); 1225 auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc") 1226 .flag("+EB") 1227 .flag("-msoft-float") 1228 .flag("+mnan=2008") 1229 .flag("+muclibc"); 1230 auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc") 1231 .flag("+EL") 1232 .flag("-msoft-float") 1233 .flag("+mnan=2008") 1234 .flag("+muclibc"); 1235 auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc") 1236 .flag("+EB") 1237 .flag("-msoft-float") 1238 .flag("-mnan=2008") 1239 .flag("+muclibc"); 1240 auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc") 1241 .flag("+EL") 1242 .flag("-msoft-float") 1243 .flag("-mnan=2008") 1244 .flag("+muclibc"); 1245 auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008") 1246 .flag("+EL") 1247 .flag("-msoft-float") 1248 .flag("+mnan=2008") 1249 .flag("+mmicromips"); 1250 auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft") 1251 .flag("+EL") 1252 .flag("+msoft-float") 1253 .flag("-mnan=2008") 1254 .flag("+mmicromips"); 1255 1256 auto O32 = 1257 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64"); 1258 auto N32 = 1259 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64"); 1260 auto N64 = 1261 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64"); 1262 1263 MtiMipsMultilibsV2 = 1264 MultilibSet() 1265 .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan, 1266 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc, 1267 ElHardUclibc, ElMicroHardNan, ElMicroSoft}) 1268 .Either(O32, N32, N64) 1269 .FilterOut(NonExistent) 1270 .setIncludeDirsCallback([](const Multilib &M) { 1271 return std::vector<std::string>({"/../../../../sysroot" + 1272 M.includeSuffix() + 1273 "/../usr/include"}); 1274 }) 1275 .setFilePathsCallback([](const Multilib &M) { 1276 return std::vector<std::string>( 1277 {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()}); 1278 }); 1279 } 1280 for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) { 1281 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1282 Result.Multilibs = *Candidate; 1283 return true; 1284 } 1285 } 1286 return false; 1287} 1288 1289static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, 1290 FilterNonExistent &NonExistent, 1291 DetectedMultilibs &Result) { 1292 // CodeScape IMG toolchain v1.2 and early. 1293 MultilibSet ImgMultilibsV1; 1294 { 1295 auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32"); 1296 1297 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); 1298 1299 auto MAbi64 = 1300 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); 1301 1302 ImgMultilibsV1 = 1303 MultilibSet() 1304 .Maybe(Mips64r6) 1305 .Maybe(MAbi64) 1306 .Maybe(LittleEndian) 1307 .FilterOut(NonExistent) 1308 .setIncludeDirsCallback([](const Multilib &M) { 1309 return std::vector<std::string>( 1310 {"/include", "/../../../../sysroot/usr/include"}); 1311 }); 1312 } 1313 1314 // CodeScape IMG toolchain starting from v1.3. 1315 MultilibSet ImgMultilibsV2; 1316 { 1317 auto BeHard = makeMultilib("/mips-r6-hard") 1318 .flag("+EB") 1319 .flag("-msoft-float") 1320 .flag("-mmicromips"); 1321 auto BeSoft = makeMultilib("/mips-r6-soft") 1322 .flag("+EB") 1323 .flag("+msoft-float") 1324 .flag("-mmicromips"); 1325 auto ElHard = makeMultilib("/mipsel-r6-hard") 1326 .flag("+EL") 1327 .flag("-msoft-float") 1328 .flag("-mmicromips"); 1329 auto ElSoft = makeMultilib("/mipsel-r6-soft") 1330 .flag("+EL") 1331 .flag("+msoft-float") 1332 .flag("-mmicromips"); 1333 auto BeMicroHard = makeMultilib("/micromips-r6-hard") 1334 .flag("+EB") 1335 .flag("-msoft-float") 1336 .flag("+mmicromips"); 1337 auto BeMicroSoft = makeMultilib("/micromips-r6-soft") 1338 .flag("+EB") 1339 .flag("+msoft-float") 1340 .flag("+mmicromips"); 1341 auto ElMicroHard = makeMultilib("/micromipsel-r6-hard") 1342 .flag("+EL") 1343 .flag("-msoft-float") 1344 .flag("+mmicromips"); 1345 auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft") 1346 .flag("+EL") 1347 .flag("+msoft-float") 1348 .flag("+mmicromips"); 1349 1350 auto O32 = 1351 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64"); 1352 auto N32 = 1353 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64"); 1354 auto N64 = 1355 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64"); 1356 1357 ImgMultilibsV2 = 1358 MultilibSet() 1359 .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft, 1360 ElMicroHard, ElMicroSoft}) 1361 .Either(O32, N32, N64) 1362 .FilterOut(NonExistent) 1363 .setIncludeDirsCallback([](const Multilib &M) { 1364 return std::vector<std::string>({"/../../../../sysroot" + 1365 M.includeSuffix() + 1366 "/../usr/include"}); 1367 }) 1368 .setFilePathsCallback([](const Multilib &M) { 1369 return std::vector<std::string>( 1370 {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()}); 1371 }); 1372 } 1373 for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) { 1374 if (Candidate->select(Flags, Result.SelectedMultilib)) { 1375 Result.Multilibs = *Candidate; 1376 return true; 1377 } 1378 } 1379 return false; 1380} 1381 1382bool clang::driver::findMIPSMultilibs(const Driver &D, 1383 const llvm::Triple &TargetTriple, 1384 StringRef Path, const ArgList &Args, 1385 DetectedMultilibs &Result) { 1386 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1387 1388 StringRef CPUName; 1389 StringRef ABIName; 1390 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName); 1391 1392 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 1393 1394 Multilib::flags_list Flags; 1395 addMultilibFlag(isMips32(TargetArch), "m32", Flags); 1396 addMultilibFlag(isMips64(TargetArch), "m64", Flags); 1397 addMultilibFlag(isMips16(Args), "mips16", Flags); 1398 addMultilibFlag(CPUName == "mips32", "march=mips32", Flags); 1399 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" || 1400 CPUName == "mips32r5" || CPUName == "p5600", 1401 "march=mips32r2", Flags); 1402 addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags); 1403 addMultilibFlag(CPUName == "mips64", "march=mips64", Flags); 1404 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" || 1405 CPUName == "mips64r5" || CPUName == "octeon", 1406 "march=mips64r2", Flags); 1407 addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags); 1408 addMultilibFlag(isMicroMips(Args), "mmicromips", Flags); 1409 addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags); 1410 addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008", 1411 Flags); 1412 addMultilibFlag(ABIName == "n32", "mabi=n32", Flags); 1413 addMultilibFlag(ABIName == "n64", "mabi=n64", Flags); 1414 addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags); 1415 addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags); 1416 addMultilibFlag(isMipsEL(TargetArch), "EL", Flags); 1417 addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags); 1418 1419 if (TargetTriple.isAndroid()) 1420 return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent, 1421 Result); 1422 1423 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1424 TargetTriple.getOS() == llvm::Triple::Linux && 1425 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) 1426 return findMipsMuslMultilibs(Flags, NonExistent, Result); 1427 1428 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && 1429 TargetTriple.getOS() == llvm::Triple::Linux && 1430 TargetTriple.getEnvironment() == llvm::Triple::GNU) 1431 return findMipsMtiMultilibs(Flags, NonExistent, Result); 1432 1433 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies && 1434 TargetTriple.getOS() == llvm::Triple::Linux && 1435 TargetTriple.getEnvironment() == llvm::Triple::GNU) 1436 return findMipsImgMultilibs(Flags, NonExistent, Result); 1437 1438 if (findMipsCsMultilibs(Flags, NonExistent, Result)) 1439 return true; 1440 1441 // Fallback to the regular toolchain-tree structure. 1442 Multilib Default; 1443 Result.Multilibs.push_back(Default); 1444 Result.Multilibs.FilterOut(NonExistent); 1445 1446 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) { 1447 Result.BiarchSibling = Multilib(); 1448 return true; 1449 } 1450 1451 return false; 1452} 1453 1454static void findAndroidArmMultilibs(const Driver &D, 1455 const llvm::Triple &TargetTriple, 1456 StringRef Path, const ArgList &Args, 1457 DetectedMultilibs &Result) { 1458 // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb. 1459 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS()); 1460 Multilib ArmV7Multilib = makeMultilib("/armv7-a") 1461 .flag("+march=armv7-a") 1462 .flag("-mthumb"); 1463 Multilib ThumbMultilib = makeMultilib("/thumb") 1464 .flag("-march=armv7-a") 1465 .flag("+mthumb"); 1466 Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb") 1467 .flag("+march=armv7-a") 1468 .flag("+mthumb"); 1469 Multilib DefaultMultilib = makeMultilib("") 1470 .flag("-march=armv7-a") 1471 .flag("-mthumb"); 1472 MultilibSet AndroidArmMultilibs = 1473 MultilibSet() 1474 .Either(ThumbMultilib, ArmV7Multilib, 1475 ArmV7ThumbMultilib, DefaultMultilib) 1476 .FilterOut(NonExistent); 1477 1478 Multilib::flags_list Flags; 1479 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ); 1480 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm; 1481 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb; 1482 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7; 1483 bool IsThumbMode = IsThumbArch || 1484 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) || 1485 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB); 1486 bool IsArmV7Mode = (IsArmArch || IsThumbArch) && 1487 (llvm::ARM::parseArchVersion(Arch) == 7 || 1488 (IsArmArch && Arch == "" && IsV7SubArch)); 1489 addMultilibFlag(IsArmV7Mode, "march=armv7-a", Flags); 1490 addMultilibFlag(IsThumbMode, "mthumb", Flags); 1491 1492 if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib)) 1493 Result.Multilibs = AndroidArmMultilibs; 1494} 1495 1496static bool findBiarchMultilibs(const Driver &D, 1497 const llvm::Triple &TargetTriple, 1498 StringRef Path, const ArgList &Args, 1499 bool NeedsBiarchSuffix, 1500 DetectedMultilibs &Result) { 1501 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs 1502 // in what would normally be GCCInstallPath and put the 64-bit 1503 // libs in a subdirectory named 64. The simple logic we follow is that 1504 // *if* there is a subdirectory of the right name with crtbegin.o in it, 1505 // we use that. If not, and if not a biarch triple alias, we look for 1506 // crtbegin.o without the subdirectory. 1507 1508 Multilib Default; 1509 Multilib Alt64 = Multilib() 1510 .gccSuffix("/64") 1511 .includeSuffix("/64") 1512 .flag("-m32") 1513 .flag("+m64") 1514 .flag("-mx32"); 1515 Multilib Alt32 = Multilib() 1516 .gccSuffix("/32") 1517 .includeSuffix("/32") 1518 .flag("+m32") 1519 .flag("-m64") 1520 .flag("-mx32"); 1521 Multilib Altx32 = Multilib() 1522 .gccSuffix("/x32") 1523 .includeSuffix("/x32") 1524 .flag("-m32") 1525 .flag("-m64") 1526 .flag("+mx32"); 1527 1528 // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a. 1529 FilterNonExistent NonExistent( 1530 Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS()); 1531 1532 // Determine default multilib from: 32, 64, x32 1533 // Also handle cases such as 64 on 32, 32 on 64, etc. 1534 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN; 1535 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32; 1536 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32)) 1537 Want = WANT64; 1538 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32)) 1539 Want = WANT64; 1540 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64)) 1541 Want = WANT32; 1542 else { 1543 if (TargetTriple.isArch32Bit()) 1544 Want = NeedsBiarchSuffix ? WANT64 : WANT32; 1545 else if (IsX32) 1546 Want = NeedsBiarchSuffix ? WANT64 : WANTX32; 1547 else 1548 Want = NeedsBiarchSuffix ? WANT32 : WANT64; 1549 } 1550 1551 if (Want == WANT32) 1552 Default.flag("+m32").flag("-m64").flag("-mx32"); 1553 else if (Want == WANT64) 1554 Default.flag("-m32").flag("+m64").flag("-mx32"); 1555 else if (Want == WANTX32) 1556 Default.flag("-m32").flag("-m64").flag("+mx32"); 1557 else 1558 return false; 1559 1560 Result.Multilibs.push_back(Default); 1561 Result.Multilibs.push_back(Alt64); 1562 Result.Multilibs.push_back(Alt32); 1563 Result.Multilibs.push_back(Altx32); 1564 1565 Result.Multilibs.FilterOut(NonExistent); 1566 1567 Multilib::flags_list Flags; 1568 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags); 1569 addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags); 1570 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags); 1571 1572 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib)) 1573 return false; 1574 1575 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 || 1576 Result.SelectedMultilib == Altx32) 1577 Result.BiarchSibling = Default; 1578 1579 return true; 1580} 1581 1582/// Generic_GCC - A tool chain using the 'gcc' command to perform 1583/// all subcommands; this relies on gcc translating the majority of 1584/// command line options. 1585 1586/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering. 1587bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor, 1588 int RHSPatch, 1589 StringRef RHSPatchSuffix) const { 1590 if (Major != RHSMajor) 1591 return Major < RHSMajor; 1592 if (Minor != RHSMinor) 1593 return Minor < RHSMinor; 1594 if (Patch != RHSPatch) { 1595 // Note that versions without a specified patch sort higher than those with 1596 // a patch. 1597 if (RHSPatch == -1) 1598 return true; 1599 if (Patch == -1) 1600 return false; 1601 1602 // Otherwise just sort on the patch itself. 1603 return Patch < RHSPatch; 1604 } 1605 if (PatchSuffix != RHSPatchSuffix) { 1606 // Sort empty suffixes higher. 1607 if (RHSPatchSuffix.empty()) 1608 return true; 1609 if (PatchSuffix.empty()) 1610 return false; 1611 1612 // Provide a lexicographic sort to make this a total ordering. 1613 return PatchSuffix < RHSPatchSuffix; 1614 } 1615 1616 // The versions are equal. 1617 return false; 1618} 1619 1620/// \brief Parse a GCCVersion object out of a string of text. 1621/// 1622/// This is the primary means of forming GCCVersion objects. 1623/*static*/ 1624Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) { 1625 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; 1626 std::pair<StringRef, StringRef> First = VersionText.split('.'); 1627 std::pair<StringRef, StringRef> Second = First.second.split('.'); 1628 1629 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; 1630 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0) 1631 return BadVersion; 1632 GoodVersion.MajorStr = First.first.str(); 1633 if (First.second.empty()) 1634 return GoodVersion; 1635 if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0) 1636 return BadVersion; 1637 GoodVersion.MinorStr = Second.first.str(); 1638 1639 // First look for a number prefix and parse that if present. Otherwise just 1640 // stash the entire patch string in the suffix, and leave the number 1641 // unspecified. This covers versions strings such as: 1642 // 5 (handled above) 1643 // 4.4 1644 // 4.4.0 1645 // 4.4.x 1646 // 4.4.2-rc4 1647 // 4.4.x-patched 1648 // And retains any patch number it finds. 1649 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str(); 1650 if (!PatchText.empty()) { 1651 if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) { 1652 // Try to parse the number and any suffix. 1653 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) || 1654 GoodVersion.Patch < 0) 1655 return BadVersion; 1656 GoodVersion.PatchSuffix = PatchText.substr(EndNumber); 1657 } 1658 } 1659 1660 return GoodVersion; 1661} 1662 1663static llvm::StringRef getGCCToolchainDir(const ArgList &Args) { 1664 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain); 1665 if (A) 1666 return A->getValue(); 1667 return GCC_INSTALL_PREFIX; 1668} 1669 1670/// \brief Initialize a GCCInstallationDetector from the driver. 1671/// 1672/// This performs all of the autodetection and sets up the various paths. 1673/// Once constructed, a GCCInstallationDetector is essentially immutable. 1674/// 1675/// FIXME: We shouldn't need an explicit TargetTriple parameter here, and 1676/// should instead pull the target out of the driver. This is currently 1677/// necessary because the driver doesn't store the final version of the target 1678/// triple. 1679void Generic_GCC::GCCInstallationDetector::init( 1680 const llvm::Triple &TargetTriple, const ArgList &Args, 1681 ArrayRef<std::string> ExtraTripleAliases) { 1682 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit() 1683 ? TargetTriple.get64BitArchVariant() 1684 : TargetTriple.get32BitArchVariant(); 1685 // The library directories which may contain GCC installations. 1686 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs; 1687 // The compatible GCC triples for this particular architecture. 1688 SmallVector<StringRef, 16> CandidateTripleAliases; 1689 SmallVector<StringRef, 16> CandidateBiarchTripleAliases; 1690 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs, 1691 CandidateTripleAliases, CandidateBiarchLibDirs, 1692 CandidateBiarchTripleAliases); 1693 1694 // Compute the set of prefixes for our search. 1695 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(), 1696 D.PrefixDirs.end()); 1697 1698 StringRef GCCToolchainDir = getGCCToolchainDir(Args); 1699 if (GCCToolchainDir != "") { 1700 if (GCCToolchainDir.back() == '/') 1701 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the / 1702 1703 Prefixes.push_back(GCCToolchainDir); 1704 } else { 1705 // If we have a SysRoot, try that first. 1706 if (!D.SysRoot.empty()) { 1707 Prefixes.push_back(D.SysRoot); 1708 Prefixes.push_back(D.SysRoot + "/usr"); 1709 } 1710 1711 // Then look for gcc installed alongside clang. 1712 Prefixes.push_back(D.InstalledDir + "/.."); 1713 1714 // Then look for distribution supplied gcc installations. 1715 if (D.SysRoot.empty()) { 1716 // Look for RHEL devtoolsets. 1717 Prefixes.push_back("/opt/rh/devtoolset-6/root/usr"); 1718 Prefixes.push_back("/opt/rh/devtoolset-4/root/usr"); 1719 Prefixes.push_back("/opt/rh/devtoolset-3/root/usr"); 1720 Prefixes.push_back("/opt/rh/devtoolset-2/root/usr"); 1721 // And finally in /usr. 1722 Prefixes.push_back("/usr"); 1723 } 1724 } 1725 1726 // Try to respect gcc-config on Gentoo. However, do that only 1727 // if --gcc-toolchain is not provided or equal to the Gentoo install 1728 // in /usr. This avoids accidentally enforcing the system GCC version 1729 // when using a custom toolchain. 1730 if (GCCToolchainDir == "" || GCCToolchainDir == D.SysRoot + "/usr") { 1731 for (StringRef CandidateTriple : ExtraTripleAliases) { 1732 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple)) 1733 return; 1734 } 1735 for (StringRef CandidateTriple : CandidateTripleAliases) { 1736 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple)) 1737 return; 1738 } 1739 for (StringRef CandidateTriple : CandidateBiarchTripleAliases) { 1740 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true)) 1741 return; 1742 } 1743 } 1744 1745 // Loop over the various components which exist and select the best GCC 1746 // installation available. GCC installs are ranked by version number. 1747 Version = GCCVersion::Parse("0.0.0"); 1748 for (const std::string &Prefix : Prefixes) { 1749 if (!D.getVFS().exists(Prefix)) 1750 continue; 1751 for (StringRef Suffix : CandidateLibDirs) { 1752 const std::string LibDir = Prefix + Suffix.str(); 1753 if (!D.getVFS().exists(LibDir)) 1754 continue; 1755 for (StringRef Candidate : ExtraTripleAliases) // Try these first. 1756 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate); 1757 for (StringRef Candidate : CandidateTripleAliases) 1758 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate); 1759 } 1760 for (StringRef Suffix : CandidateBiarchLibDirs) { 1761 const std::string LibDir = Prefix + Suffix.str(); 1762 if (!D.getVFS().exists(LibDir)) 1763 continue; 1764 for (StringRef Candidate : CandidateBiarchTripleAliases) 1765 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, 1766 /*NeedsBiarchSuffix=*/ true); 1767 } 1768 } 1769} 1770 1771void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const { 1772 for (const auto &InstallPath : CandidateGCCInstallPaths) 1773 OS << "Found candidate GCC installation: " << InstallPath << "\n"; 1774 1775 if (!GCCInstallPath.empty()) 1776 OS << "Selected GCC installation: " << GCCInstallPath << "\n"; 1777 1778 for (const auto &Multilib : Multilibs) 1779 OS << "Candidate multilib: " << Multilib << "\n"; 1780 1781 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault()) 1782 OS << "Selected multilib: " << SelectedMultilib << "\n"; 1783} 1784 1785bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const { 1786 if (BiarchSibling.hasValue()) { 1787 M = BiarchSibling.getValue(); 1788 return true; 1789 } 1790 return false; 1791} 1792 1793/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples( 1794 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple, 1795 SmallVectorImpl<StringRef> &LibDirs, 1796 SmallVectorImpl<StringRef> &TripleAliases, 1797 SmallVectorImpl<StringRef> &BiarchLibDirs, 1798 SmallVectorImpl<StringRef> &BiarchTripleAliases) { 1799 // Declare a bunch of static data sets that we'll select between below. These 1800 // are specifically designed to always refer to string literals to avoid any 1801 // lifetime or initialization issues. 1802 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; 1803 static const char *const AArch64Triples[] = { 1804 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android", 1805 "aarch64-redhat-linux", "aarch64-suse-linux"}; 1806 static const char *const AArch64beLibDirs[] = {"/lib"}; 1807 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", 1808 "aarch64_be-linux-gnu"}; 1809 1810 static const char *const ARMLibDirs[] = {"/lib"}; 1811 static const char *const ARMTriples[] = {"arm-linux-gnueabi", 1812 "arm-linux-androideabi"}; 1813 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf", 1814 "armv7hl-redhat-linux-gnueabi", 1815 "armv6hl-suse-linux-gnueabi", 1816 "armv7hl-suse-linux-gnueabi"}; 1817 static const char *const ARMebLibDirs[] = {"/lib"}; 1818 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi", 1819 "armeb-linux-androideabi"}; 1820 static const char *const ARMebHFTriples[] = { 1821 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"}; 1822 1823 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"}; 1824 static const char *const X86_64Triples[] = { 1825 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", 1826 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E", 1827 "x86_64-redhat-linux", "x86_64-suse-linux", 1828 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", 1829 "x86_64-slackware-linux", "x86_64-linux-android", 1830 "x86_64-unknown-linux"}; 1831 static const char *const X32LibDirs[] = {"/libx32"}; 1832 static const char *const X86LibDirs[] = {"/lib32", "/lib"}; 1833 static const char *const X86Triples[] = { 1834 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", 1835 "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux", 1836 "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux", 1837 "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android", 1838 "i586-linux-gnu"}; 1839 1840 static const char *const MIPSLibDirs[] = {"/lib"}; 1841 static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux", 1842 "mips-mti-linux-gnu", 1843 "mips-img-linux-gnu"}; 1844 static const char *const MIPSELLibDirs[] = {"/lib"}; 1845 static const char *const MIPSELTriples[] = {"mipsel-linux-gnu", 1846 "mips-img-linux-gnu"}; 1847 1848 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"}; 1849 static const char *const MIPS64Triples[] = { 1850 "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", 1851 "mips64-linux-gnuabi64"}; 1852 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"}; 1853 static const char *const MIPS64ELTriples[] = { 1854 "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", 1855 "mips64el-linux-gnuabi64"}; 1856 1857 static const char *const MIPSELAndroidLibDirs[] = {"/lib", "/libr2", 1858 "/libr6"}; 1859 static const char *const MIPSELAndroidTriples[] = {"mipsel-linux-android"}; 1860 static const char *const MIPS64ELAndroidLibDirs[] = {"/lib64", "/lib", 1861 "/libr2", "/libr6"}; 1862 static const char *const MIPS64ELAndroidTriples[] = { 1863 "mips64el-linux-android"}; 1864 1865 static const char *const PPCLibDirs[] = {"/lib32", "/lib"}; 1866 static const char *const PPCTriples[] = { 1867 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe", 1868 "powerpc-suse-linux", "powerpc-montavista-linuxspe"}; 1869 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"}; 1870 static const char *const PPC64Triples[] = { 1871 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu", 1872 "powerpc64-suse-linux", "ppc64-redhat-linux"}; 1873 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"}; 1874 static const char *const PPC64LETriples[] = { 1875 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu", 1876 "powerpc64le-suse-linux", "ppc64le-redhat-linux"}; 1877 1878 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"}; 1879 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu", 1880 "sparcv8-linux-gnu"}; 1881 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"}; 1882 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu", 1883 "sparcv9-linux-gnu"}; 1884 1885 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"}; 1886 static const char *const SystemZTriples[] = { 1887 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu", 1888 "s390x-suse-linux", "s390x-redhat-linux"}; 1889 1890 // Solaris. 1891 static const char *const SolarisSPARCLibDirs[] = {"/gcc"}; 1892 static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11", 1893 "i386-pc-solaris2.11"}; 1894 1895 using std::begin; 1896 using std::end; 1897 1898 if (TargetTriple.getOS() == llvm::Triple::Solaris) { 1899 LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs)); 1900 TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples)); 1901 return; 1902 } 1903 1904 switch (TargetTriple.getArch()) { 1905 case llvm::Triple::aarch64: 1906 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 1907 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 1908 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs)); 1909 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples)); 1910 break; 1911 case llvm::Triple::aarch64_be: 1912 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 1913 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 1914 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs)); 1915 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples)); 1916 break; 1917 case llvm::Triple::arm: 1918 case llvm::Triple::thumb: 1919 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs)); 1920 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 1921 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples)); 1922 } else { 1923 TripleAliases.append(begin(ARMTriples), end(ARMTriples)); 1924 } 1925 break; 1926 case llvm::Triple::armeb: 1927 case llvm::Triple::thumbeb: 1928 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs)); 1929 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 1930 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples)); 1931 } else { 1932 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples)); 1933 } 1934 break; 1935 case llvm::Triple::x86_64: 1936 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 1937 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1938 // x32 is always available when x86_64 is available, so adding it as 1939 // secondary arch with x86_64 triples 1940 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) { 1941 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs)); 1942 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1943 } else { 1944 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 1945 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples)); 1946 } 1947 break; 1948 case llvm::Triple::x86: 1949 LibDirs.append(begin(X86LibDirs), end(X86LibDirs)); 1950 // MCU toolchain is 32 bit only and its triple alias is TargetTriple 1951 // itself, which will be appended below. 1952 if (!TargetTriple.isOSIAMCU()) { 1953 TripleAliases.append(begin(X86Triples), end(X86Triples)); 1954 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs)); 1955 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples)); 1956 } 1957 break; 1958 case llvm::Triple::mips: 1959 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 1960 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1961 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 1962 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 1963 break; 1964 case llvm::Triple::mipsel: 1965 if (TargetTriple.isAndroid()) { 1966 LibDirs.append(begin(MIPSELAndroidLibDirs), end(MIPSELAndroidLibDirs)); 1967 TripleAliases.append(begin(MIPSELAndroidTriples), 1968 end(MIPSELAndroidTriples)); 1969 BiarchLibDirs.append(begin(MIPS64ELAndroidLibDirs), 1970 end(MIPS64ELAndroidLibDirs)); 1971 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples), 1972 end(MIPS64ELAndroidTriples)); 1973 1974 } else { 1975 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 1976 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 1977 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1978 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 1979 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 1980 } 1981 break; 1982 case llvm::Triple::mips64: 1983 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs)); 1984 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples)); 1985 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs)); 1986 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 1987 break; 1988 case llvm::Triple::mips64el: 1989 if (TargetTriple.isAndroid()) { 1990 LibDirs.append(begin(MIPS64ELAndroidLibDirs), 1991 end(MIPS64ELAndroidLibDirs)); 1992 TripleAliases.append(begin(MIPS64ELAndroidTriples), 1993 end(MIPS64ELAndroidTriples)); 1994 BiarchLibDirs.append(begin(MIPSELAndroidLibDirs), 1995 end(MIPSELAndroidLibDirs)); 1996 BiarchTripleAliases.append(begin(MIPSELAndroidTriples), 1997 end(MIPSELAndroidTriples)); 1998 1999 } else { 2000 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs)); 2001 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples)); 2002 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs)); 2003 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples)); 2004 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples)); 2005 } 2006 break; 2007 case llvm::Triple::ppc: 2008 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 2009 TripleAliases.append(begin(PPCTriples), end(PPCTriples)); 2010 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 2011 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 2012 break; 2013 case llvm::Triple::ppc64: 2014 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs)); 2015 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples)); 2016 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs)); 2017 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples)); 2018 break; 2019 case llvm::Triple::ppc64le: 2020 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs)); 2021 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples)); 2022 break; 2023 case llvm::Triple::sparc: 2024 case llvm::Triple::sparcel: 2025 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 2026 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 2027 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 2028 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 2029 break; 2030 case llvm::Triple::sparcv9: 2031 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs)); 2032 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples)); 2033 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs)); 2034 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples)); 2035 break; 2036 case llvm::Triple::systemz: 2037 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs)); 2038 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples)); 2039 break; 2040 default: 2041 // By default, just rely on the standard lib directories and the original 2042 // triple. 2043 break; 2044 } 2045 2046 // Always append the drivers target triple to the end, in case it doesn't 2047 // match any of our aliases. 2048 TripleAliases.push_back(TargetTriple.str()); 2049 2050 // Also include the multiarch variant if it's different. 2051 if (TargetTriple.str() != BiarchTriple.str()) 2052 BiarchTripleAliases.push_back(BiarchTriple.str()); 2053} 2054 2055void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris( 2056 const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args, 2057 const std::string &LibDir, StringRef CandidateTriple, 2058 bool NeedsBiarchSuffix) { 2059 // Solaris is a special case. The GCC installation is under 2060 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we 2061 // need to iterate twice. 2062 std::error_code EC; 2063 for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE; 2064 !EC && LI != LE; LI = LI.increment(EC)) { 2065 StringRef VersionText = llvm::sys::path::filename(LI->getName()); 2066 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2067 2068 if (CandidateVersion.Major != -1) // Filter obviously bad entries. 2069 if (!CandidateGCCInstallPaths.insert(LI->getName()).second) 2070 continue; // Saw this path before; no need to look at it again. 2071 if (CandidateVersion.isOlderThan(4, 1, 1)) 2072 continue; 2073 if (CandidateVersion <= Version) 2074 continue; 2075 2076 GCCInstallPath = 2077 LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str(); 2078 if (!D.getVFS().exists(GCCInstallPath)) 2079 continue; 2080 2081 // If we make it here there has to be at least one GCC version, let's just 2082 // use the latest one. 2083 std::error_code EEC; 2084 for (vfs::directory_iterator 2085 LLI = D.getVFS().dir_begin(GCCInstallPath, EEC), 2086 LLE; 2087 !EEC && LLI != LLE; LLI = LLI.increment(EEC)) { 2088 2089 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName()); 2090 GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText); 2091 2092 if (CandidateSubVersion > Version) 2093 Version = CandidateSubVersion; 2094 } 2095 2096 GCCTriple.setTriple(CandidateTriple); 2097 2098 GCCInstallPath += "/" + Version.Text; 2099 GCCParentLibPath = GCCInstallPath + "/../../../../"; 2100 2101 IsValid = true; 2102 } 2103} 2104 2105bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs( 2106 const llvm::Triple &TargetTriple, const ArgList &Args, 2107 StringRef Path, bool NeedsBiarchSuffix) { 2108 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 2109 DetectedMultilibs Detected; 2110 2111 // Android standalone toolchain could have multilibs for ARM and Thumb. 2112 // Debian mips multilibs behave more like the rest of the biarch ones, 2113 // so handle them there 2114 if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) { 2115 // It should also work without multilibs in a simplified toolchain. 2116 findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected); 2117 } else if (tools::isMipsArch(TargetArch)) { 2118 if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected)) 2119 return false; 2120 } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args, 2121 NeedsBiarchSuffix, Detected)) { 2122 return false; 2123 } 2124 2125 Multilibs = Detected.Multilibs; 2126 SelectedMultilib = Detected.SelectedMultilib; 2127 BiarchSibling = Detected.BiarchSibling; 2128 2129 return true; 2130} 2131 2132void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( 2133 const llvm::Triple &TargetTriple, const ArgList &Args, 2134 const std::string &LibDir, StringRef CandidateTriple, 2135 bool NeedsBiarchSuffix) { 2136 if (TargetTriple.getOS() == llvm::Triple::Solaris) { 2137 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple, 2138 NeedsBiarchSuffix); 2139 return; 2140 } 2141 2142 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 2143 // Locations relative to the system lib directory where GCC's triple-specific 2144 // directories might reside. 2145 struct GCCLibSuffix { 2146 // Path from system lib directory to GCC triple-specific directory. 2147 std::string LibSuffix; 2148 // Path from GCC triple-specific directory back to system lib directory. 2149 // This is one '..' component per component in LibSuffix. 2150 StringRef ReversePath; 2151 // Whether this library suffix is relevant for the triple. 2152 bool Active; 2153 } Suffixes[] = { 2154 // This is the normal place. 2155 {"gcc/" + CandidateTriple.str(), "../..", true}, 2156 2157 // Debian puts cross-compilers in gcc-cross. 2158 {"gcc-cross/" + CandidateTriple.str(), "../..", true}, 2159 2160 // The Freescale PPC SDK has the gcc libraries in 2161 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do 2162 // this on Freescale triples, though, since some systems put a *lot* of 2163 // files in that location, not just GCC installation data. 2164 {CandidateTriple.str(), "..", 2165 TargetTriple.getVendor() == llvm::Triple::Freescale}, 2166 2167 // Natively multiarch systems sometimes put the GCC triple-specific 2168 // directory within their multiarch lib directory, resulting in the 2169 // triple appearing twice. 2170 {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..", true}, 2171 2172 // Deal with cases (on Ubuntu) where the system architecture could be i386 2173 // but the GCC target architecture could be (say) i686. 2174 // FIXME: It may be worthwhile to generalize this and look for a second 2175 // triple. 2176 {"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..", 2177 TargetArch == llvm::Triple::x86} 2178 }; 2179 2180 for (auto &Suffix : Suffixes) { 2181 if (!Suffix.Active) 2182 continue; 2183 2184 StringRef LibSuffix = Suffix.LibSuffix; 2185 std::error_code EC; 2186 for (vfs::directory_iterator 2187 LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC), 2188 LE; 2189 !EC && LI != LE; LI = LI.increment(EC)) { 2190 StringRef VersionText = llvm::sys::path::filename(LI->getName()); 2191 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 2192 if (CandidateVersion.Major != -1) // Filter obviously bad entries. 2193 if (!CandidateGCCInstallPaths.insert(LI->getName()).second) 2194 continue; // Saw this path before; no need to look at it again. 2195 if (CandidateVersion.isOlderThan(4, 1, 1)) 2196 continue; 2197 if (CandidateVersion <= Version) 2198 continue; 2199 2200 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->getName(), 2201 NeedsBiarchSuffix)) 2202 continue; 2203 2204 Version = CandidateVersion; 2205 GCCTriple.setTriple(CandidateTriple); 2206 // FIXME: We hack together the directory name here instead of 2207 // using LI to ensure stable path separators across Windows and 2208 // Linux. 2209 GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str(); 2210 GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str(); 2211 IsValid = true; 2212 } 2213 } 2214} 2215 2216bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig( 2217 const llvm::Triple &TargetTriple, const ArgList &Args, 2218 StringRef CandidateTriple, bool NeedsBiarchSuffix) { 2219 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File = 2220 D.getVFS().getBufferForFile(D.SysRoot + "/etc/env.d/gcc/config-" + 2221 CandidateTriple.str()); 2222 if (File) { 2223 SmallVector<StringRef, 2> Lines; 2224 File.get()->getBuffer().split(Lines, "\n"); 2225 for (StringRef Line : Lines) { 2226 Line = Line.trim(); 2227 // CURRENT=triple-version 2228 if (Line.consume_front("CURRENT=")) { 2229 const std::pair<StringRef, StringRef> ActiveVersion = 2230 Line.rsplit('-'); 2231 // Note: Strictly speaking, we should be reading 2232 // /etc/env.d/gcc/${CURRENT} now. However, the file doesn't 2233 // contain anything new or especially useful to us. 2234 const std::string GentooPath = D.SysRoot + "/usr/lib/gcc/" + 2235 ActiveVersion.first.str() + "/" + 2236 ActiveVersion.second.str(); 2237 if (D.getVFS().exists(GentooPath + "/crtbegin.o")) { 2238 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath, 2239 NeedsBiarchSuffix)) 2240 return false; 2241 2242 Version = GCCVersion::Parse(ActiveVersion.second); 2243 GCCInstallPath = GentooPath; 2244 GCCParentLibPath = GentooPath + "/../../.."; 2245 GCCTriple.setTriple(ActiveVersion.first); 2246 IsValid = true; 2247 return true; 2248 } 2249 } 2250 } 2251 } 2252 2253 return false; 2254} 2255 2256Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple, 2257 const ArgList &Args) 2258 : ToolChain(D, Triple, Args), GCCInstallation(D), 2259 CudaInstallation(D, Triple, Args) { 2260 getProgramPaths().push_back(getDriver().getInstalledDir()); 2261 if (getDriver().getInstalledDir() != getDriver().Dir) 2262 getProgramPaths().push_back(getDriver().Dir); 2263} 2264 2265Generic_GCC::~Generic_GCC() {} 2266 2267Tool *Generic_GCC::getTool(Action::ActionClass AC) const { 2268 switch (AC) { 2269 case Action::PreprocessJobClass: 2270 if (!Preprocess) 2271 Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this)); 2272 return Preprocess.get(); 2273 case Action::CompileJobClass: 2274 if (!Compile) 2275 Compile.reset(new tools::gcc::Compiler(*this)); 2276 return Compile.get(); 2277 default: 2278 return ToolChain::getTool(AC); 2279 } 2280} 2281 2282Tool *Generic_GCC::buildAssembler() const { 2283 return new tools::gnutools::Assembler(*this); 2284} 2285 2286Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); } 2287 2288void Generic_GCC::printVerboseInfo(raw_ostream &OS) const { 2289 // Print the information about how we detected the GCC installation. 2290 GCCInstallation.print(OS); 2291 CudaInstallation.print(OS); 2292} 2293 2294bool Generic_GCC::IsUnwindTablesDefault() const { 2295 return getArch() == llvm::Triple::x86_64; 2296} 2297 2298bool Generic_GCC::isPICDefault() const { 2299 switch (getArch()) { 2300 case llvm::Triple::x86_64: 2301 return getTriple().isOSWindows(); 2302 case llvm::Triple::ppc64: 2303 case llvm::Triple::ppc64le: 2304 return !getTriple().isOSBinFormatMachO() && !getTriple().isMacOSX(); 2305 case llvm::Triple::mips64: 2306 case llvm::Triple::mips64el: 2307 return true; 2308 default: 2309 return false; 2310 } 2311} 2312 2313bool Generic_GCC::isPIEDefault() const { return false; } 2314 2315bool Generic_GCC::isPICDefaultForced() const { 2316 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows(); 2317} 2318 2319bool Generic_GCC::IsIntegratedAssemblerDefault() const { 2320 switch (getTriple().getArch()) { 2321 case llvm::Triple::x86: 2322 case llvm::Triple::x86_64: 2323 case llvm::Triple::aarch64: 2324 case llvm::Triple::aarch64_be: 2325 case llvm::Triple::arm: 2326 case llvm::Triple::armeb: 2327 case llvm::Triple::avr: 2328 case llvm::Triple::bpfel: 2329 case llvm::Triple::bpfeb: 2330 case llvm::Triple::thumb: 2331 case llvm::Triple::thumbeb: 2332 case llvm::Triple::ppc: 2333 case llvm::Triple::ppc64: 2334 case llvm::Triple::ppc64le: 2335 case llvm::Triple::systemz: 2336 case llvm::Triple::mips: 2337 case llvm::Triple::mipsel: 2338 return true; 2339 case llvm::Triple::mips64: 2340 case llvm::Triple::mips64el: 2341 // Enabled for Debian and Android mips64/mipsel, as they can precisely 2342 // identify the ABI in use (Debian) or only use N64 for MIPS64 (Android). 2343 // Other targets are unable to distinguish N32 from N64. 2344 if (getTriple().getEnvironment() == llvm::Triple::GNUABI64 || 2345 getTriple().isAndroid()) 2346 return true; 2347 return false; 2348 default: 2349 return false; 2350 } 2351} 2352 2353void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 2354 ArgStringList &CC1Args) const { 2355 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 2356 DriverArgs.hasArg(options::OPT_nostdincxx)) 2357 return; 2358 2359 switch (GetCXXStdlibType(DriverArgs)) { 2360 case ToolChain::CST_Libcxx: { 2361 std::string Path = findLibCxxIncludePath(); 2362 if (!Path.empty()) 2363 addSystemInclude(DriverArgs, CC1Args, Path); 2364 break; 2365 } 2366 2367 case ToolChain::CST_Libstdcxx: 2368 addLibStdCxxIncludePaths(DriverArgs, CC1Args); 2369 break; 2370 } 2371} 2372 2373std::string Generic_GCC::findLibCxxIncludePath() const { 2374 // FIXME: The Linux behavior would probaby be a better approach here. 2375 return getDriver().SysRoot + "/usr/include/c++/v1"; 2376} 2377 2378void 2379Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 2380 llvm::opt::ArgStringList &CC1Args) const { 2381 // By default, we don't assume we know where libstdc++ might be installed. 2382 // FIXME: If we have a valid GCCInstallation, use it. 2383} 2384 2385/// \brief Helper to add the variant paths of a libstdc++ installation. 2386bool Generic_GCC::addLibStdCXXIncludePaths( 2387 Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, 2388 StringRef TargetMultiarchTriple, Twine IncludeSuffix, 2389 const ArgList &DriverArgs, ArgStringList &CC1Args) const { 2390 if (!getVFS().exists(Base + Suffix)) 2391 return false; 2392 2393 addSystemInclude(DriverArgs, CC1Args, Base + Suffix); 2394 2395 // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If 2396 // that path exists or we have neither a GCC nor target multiarch triple, use 2397 // this vanilla search path. 2398 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) || 2399 getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) { 2400 addSystemInclude(DriverArgs, CC1Args, 2401 Base + Suffix + "/" + GCCTriple + IncludeSuffix); 2402 } else { 2403 // Otherwise try to use multiarch naming schemes which have normalized the 2404 // triples and put the triple before the suffix. 2405 // 2406 // GCC surprisingly uses *both* the GCC triple with a multilib suffix and 2407 // the target triple, so we support that here. 2408 addSystemInclude(DriverArgs, CC1Args, 2409 Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix); 2410 addSystemInclude(DriverArgs, CC1Args, 2411 Base + "/" + TargetMultiarchTriple + Suffix); 2412 } 2413 2414 addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward"); 2415 return true; 2416} 2417 2418llvm::opt::DerivedArgList * 2419Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef, 2420 Action::OffloadKind DeviceOffloadKind) const { 2421 2422 // If this tool chain is used for an OpenMP offloading device we have to make 2423 // sure we always generate a shared library regardless of the commands the 2424 // user passed to the host. This is required because the runtime library 2425 // is required to load the device image dynamically at run time. 2426 if (DeviceOffloadKind == Action::OFK_OpenMP) { 2427 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 2428 const OptTable &Opts = getDriver().getOpts(); 2429 2430 // Request the shared library. Given that these options are decided 2431 // implicitly, they do not refer to any base argument. 2432 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared)); 2433 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC)); 2434 2435 // Filter all the arguments we don't care passing to the offloading 2436 // toolchain as they can mess up with the creation of a shared library. 2437 for (auto *A : Args) { 2438 switch ((options::ID)A->getOption().getID()) { 2439 default: 2440 DAL->append(A); 2441 break; 2442 case options::OPT_shared: 2443 case options::OPT_dynamic: 2444 case options::OPT_static: 2445 case options::OPT_fPIC: 2446 case options::OPT_fno_PIC: 2447 case options::OPT_fpic: 2448 case options::OPT_fno_pic: 2449 case options::OPT_fPIE: 2450 case options::OPT_fno_PIE: 2451 case options::OPT_fpie: 2452 case options::OPT_fno_pie: 2453 break; 2454 } 2455 } 2456 return DAL; 2457 } 2458 return nullptr; 2459} 2460 2461void Generic_ELF::anchor() {} 2462 2463void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs, 2464 ArgStringList &CC1Args, 2465 Action::OffloadKind) const { 2466 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion(); 2467 bool UseInitArrayDefault = 2468 getTriple().getArch() == llvm::Triple::aarch64 || 2469 getTriple().getArch() == llvm::Triple::aarch64_be || 2470 (getTriple().getOS() == llvm::Triple::Linux && 2471 (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) || 2472 getTriple().getOS() == llvm::Triple::NaCl || 2473 (getTriple().getVendor() == llvm::Triple::MipsTechnologies && 2474 !getTriple().hasEnvironment()) || 2475 getTriple().getOS() == llvm::Triple::Solaris; 2476 2477 if (DriverArgs.hasFlag(options::OPT_fuse_init_array, 2478 options::OPT_fno_use_init_array, UseInitArrayDefault)) 2479 CC1Args.push_back("-fuse-init-array"); 2480} 2481