clang  3.9.0
ToolChains.cpp
Go to the documentation of this file.
1 //===--- ToolChains.cpp - 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 "ToolChains.h"
11 #include "clang/Basic/Cuda.h"
13 #include "clang/Basic/Version.h"
15 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
17 #include "clang/Driver/Driver.h"
19 #include "clang/Driver/Options.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Option/Arg.h"
26 #include "llvm/Option/ArgList.h"
27 #include "llvm/Option/OptTable.h"
28 #include "llvm/Option/Option.h"
29 #include "llvm/ProfileData/InstrProf.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/FileSystem.h"
32 #include "llvm/Support/MemoryBuffer.h"
33 #include "llvm/Support/Path.h"
34 #include "llvm/Support/Program.h"
35 #include "llvm/Support/TargetParser.h"
36 #include "llvm/Support/raw_ostream.h"
37 #include <cstdlib> // ::getenv
38 #include <system_error>
39 
40 using namespace clang::driver;
41 using namespace clang::driver::toolchains;
42 using namespace clang;
43 using namespace llvm::opt;
44 
45 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
46  : ToolChain(D, Triple, Args) {
47  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
48  getProgramPaths().push_back(getDriver().getInstalledDir());
49  if (getDriver().getInstalledDir() != getDriver().Dir)
50  getProgramPaths().push_back(getDriver().Dir);
51 }
52 
53 /// Darwin - Darwin tool chain for i386 and x86_64.
54 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
55  : MachO(D, Triple, Args), TargetInitialized(false) {}
56 
57 types::ID MachO::LookupTypeForExtension(const char *Ext) const {
59 
60  // Darwin always preprocesses assembly files (unless -x is used explicitly).
61  if (Ty == types::TY_PP_Asm)
62  return types::TY_Asm;
63 
64  return Ty;
65 }
66 
67 bool MachO::HasNativeLLVMSupport() const { return true; }
68 
70  // Default to use libc++ on OS X 10.9+ and iOS 7+.
71  if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
72  (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
74  return ToolChain::CST_Libcxx;
75 
77 }
78 
79 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
80 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
83  if (isTargetIOSBased())
85  if (isNonFragile)
88 }
89 
90 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
93  return true;
94  else if (isTargetIOSBased())
95  return !isIPhoneOSVersionLT(3, 2);
96  else {
97  assert(isTargetMacOS() && "unexpected darwin target");
98  return !isMacosxVersionLT(10, 6);
99  }
100 }
101 
102 // This is just a MachO name translation routine and there's no
103 // way to join this into ARMTargetParser without breaking all
104 // other assumptions. Maybe MachO should consider standardising
105 // their nomenclature.
106 static const char *ArmMachOArchName(StringRef Arch) {
107  return llvm::StringSwitch<const char *>(Arch)
108  .Case("armv6k", "armv6")
109  .Case("armv6m", "armv6m")
110  .Case("armv5tej", "armv5")
111  .Case("xscale", "xscale")
112  .Case("armv4t", "armv4t")
113  .Case("armv7", "armv7")
114  .Cases("armv7a", "armv7-a", "armv7")
115  .Cases("armv7r", "armv7-r", "armv7")
116  .Cases("armv7em", "armv7e-m", "armv7em")
117  .Cases("armv7k", "armv7-k", "armv7k")
118  .Cases("armv7m", "armv7-m", "armv7m")
119  .Cases("armv7s", "armv7-s", "armv7s")
120  .Default(nullptr);
121 }
122 
123 static const char *ArmMachOArchNameCPU(StringRef CPU) {
124  unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
125  if (ArchKind == llvm::ARM::AK_INVALID)
126  return nullptr;
127  StringRef Arch = llvm::ARM::getArchName(ArchKind);
128 
129  // FIXME: Make sure this MachO triple mangling is really necessary.
130  // ARMv5* normalises to ARMv5.
131  if (Arch.startswith("armv5"))
132  Arch = Arch.substr(0, 5);
133  // ARMv6*, except ARMv6M, normalises to ARMv6.
134  else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
135  Arch = Arch.substr(0, 5);
136  // ARMv7A normalises to ARMv7.
137  else if (Arch.endswith("v7a"))
138  Arch = Arch.substr(0, 5);
139  return Arch.data();
140 }
141 
142 static bool isSoftFloatABI(const ArgList &Args) {
143  Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
144  options::OPT_mfloat_abi_EQ);
145  if (!A)
146  return false;
147 
148  return A->getOption().matches(options::OPT_msoft_float) ||
149  (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
150  A->getValue() == StringRef("soft"));
151 }
152 
153 StringRef MachO::getMachOArchName(const ArgList &Args) const {
154  switch (getTriple().getArch()) {
155  default:
157 
158  case llvm::Triple::aarch64:
159  return "arm64";
160 
161  case llvm::Triple::thumb:
162  case llvm::Triple::arm:
163  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
164  if (const char *Arch = ArmMachOArchName(A->getValue()))
165  return Arch;
166 
167  if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
168  if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
169  return Arch;
170 
171  return "arm";
172  }
173 }
174 
176 
178 
179 std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args,
180  types::ID InputType) const {
181  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
182 
183  return Triple.getTriple();
184 }
185 
186 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
187  types::ID InputType) const {
188  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
189 
190  // If the target isn't initialized (e.g., an unknown Darwin platform, return
191  // the default triple).
192  if (!isTargetInitialized())
193  return Triple.getTriple();
194 
195  SmallString<16> Str;
196  if (isTargetWatchOSBased())
197  Str += "watchos";
198  else if (isTargetTvOSBased())
199  Str += "tvos";
200  else if (isTargetIOSBased())
201  Str += "ios";
202  else
203  Str += "macosx";
204  Str += getTargetVersion().getAsString();
205  Triple.setOSName(Str);
206 
207  return Triple.getTriple();
208 }
209 
210 void Generic_ELF::anchor() {}
211 
213  switch (AC) {
215  if (!Lipo)
216  Lipo.reset(new tools::darwin::Lipo(*this));
217  return Lipo.get();
219  if (!Dsymutil)
220  Dsymutil.reset(new tools::darwin::Dsymutil(*this));
221  return Dsymutil.get();
223  if (!VerifyDebug)
224  VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
225  return VerifyDebug.get();
226  default:
227  return ToolChain::getTool(AC);
228  }
229 }
230 
231 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
232 
234  return new tools::darwin::Assembler(*this);
235 }
236 
237 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
238  const ArgList &Args)
239  : Darwin(D, Triple, Args) {}
240 
241 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
242  // For modern targets, promote certain warnings to errors.
243  if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
244  // Always enable -Wdeprecated-objc-isa-usage and promote it
245  // to an error.
246  CC1Args.push_back("-Wdeprecated-objc-isa-usage");
247  CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
248 
249  // For iOS and watchOS, also error about implicit function declarations,
250  // as that can impact calling conventions.
251  if (!isTargetMacOS())
252  CC1Args.push_back("-Werror=implicit-function-declaration");
253  }
254 }
255 
256 /// \brief Determine whether Objective-C automated reference counting is
257 /// enabled.
258 static bool isObjCAutoRefCount(const ArgList &Args) {
259  return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
260 }
261 
262 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
263  ArgStringList &CmdArgs) const {
264  // Avoid linking compatibility stubs on i386 mac.
265  if (isTargetMacOS() && getArch() == llvm::Triple::x86)
266  return;
267 
268  ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
269 
270  if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
271  runtime.hasSubscripting())
272  return;
273 
274  CmdArgs.push_back("-force_load");
275  SmallString<128> P(getDriver().ClangExecutable);
276  llvm::sys::path::remove_filename(P); // 'clang'
277  llvm::sys::path::remove_filename(P); // 'bin'
278  llvm::sys::path::append(P, "lib", "arc", "libarclite_");
279  // Mash in the platform.
281  P += "watchsimulator";
282  else if (isTargetWatchOS())
283  P += "watchos";
284  else if (isTargetTvOSSimulator())
285  P += "appletvsimulator";
286  else if (isTargetTvOS())
287  P += "appletvos";
288  else if (isTargetIOSSimulator())
289  P += "iphonesimulator";
290  else if (isTargetIPhoneOS())
291  P += "iphoneos";
292  else
293  P += "macosx";
294  P += ".a";
295 
296  CmdArgs.push_back(Args.MakeArgString(P));
297 }
298 
299 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
300  StringRef DarwinLibName, bool AlwaysLink,
301  bool IsEmbedded, bool AddRPath) const {
302  SmallString<128> Dir(getDriver().ResourceDir);
303  llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
304 
305  SmallString<128> P(Dir);
306  llvm::sys::path::append(P, DarwinLibName);
307 
308  // For now, allow missing resource libraries to support developers who may
309  // not have compiler-rt checked out or integrated into their build (unless
310  // we explicitly force linking with this library).
311  if (AlwaysLink || getVFS().exists(P))
312  CmdArgs.push_back(Args.MakeArgString(P));
313 
314  // Adding the rpaths might negatively interact when other rpaths are involved,
315  // so we should make sure we add the rpaths last, after all user-specified
316  // rpaths. This is currently true from this place, but we need to be
317  // careful if this function is ever called before user's rpaths are emitted.
318  if (AddRPath) {
319  assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
320 
321  // Add @executable_path to rpath to support having the dylib copied with
322  // the executable.
323  CmdArgs.push_back("-rpath");
324  CmdArgs.push_back("@executable_path");
325 
326  // Add the path to the resource dir to rpath to support using the dylib
327  // from the default location without copying.
328  CmdArgs.push_back("-rpath");
329  CmdArgs.push_back(Args.MakeArgString(Dir));
330  }
331 }
332 
333 StringRef Darwin::getPlatformFamily() const {
334  switch (TargetPlatform) {
335  case DarwinPlatformKind::MacOS:
336  return "MacOSX";
337  case DarwinPlatformKind::IPhoneOS:
338  case DarwinPlatformKind::IPhoneOSSimulator:
339  return "iPhone";
340  case DarwinPlatformKind::TvOS:
341  case DarwinPlatformKind::TvOSSimulator:
342  return "AppleTV";
343  case DarwinPlatformKind::WatchOS:
344  case DarwinPlatformKind::WatchOSSimulator:
345  return "Watch";
346  }
347  llvm_unreachable("Unsupported platform");
348 }
349 
350 StringRef Darwin::getSDKName(StringRef isysroot) {
351  // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
352  llvm::sys::path::const_iterator SDKDir;
353  auto BeginSDK = llvm::sys::path::begin(isysroot);
354  auto EndSDK = llvm::sys::path::end(isysroot);
355  for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
356  StringRef SDK = *IT;
357  if (SDK.endswith(".sdk"))
358  return SDK.slice(0, SDK.size() - 4);
359  }
360  return "";
361 }
362 
364  switch(TargetPlatform) {
365  case DarwinPlatformKind::MacOS:
366  return "osx";
367  case DarwinPlatformKind::IPhoneOS:
368  return "ios";
369  case DarwinPlatformKind::IPhoneOSSimulator:
370  return "iossim";
371  case DarwinPlatformKind::TvOS:
372  return "tvos";
373  case DarwinPlatformKind::TvOSSimulator:
374  return "tvossim";
375  case DarwinPlatformKind::WatchOS:
376  return "watchos";
377  case DarwinPlatformKind::WatchOSSimulator:
378  return "watchossim";
379  }
380  llvm_unreachable("Unsupported platform");
381 }
382 
383 void Darwin::addProfileRTLibs(const ArgList &Args,
384  ArgStringList &CmdArgs) const {
385  if (!needsProfileRT(Args)) return;
386 
387  AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") +
388  getOSLibraryNameSuffix() + ".a").str(),
389  /*AlwaysLink*/ true);
390 }
391 
392 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
393  ArgStringList &CmdArgs,
394  StringRef Sanitizer) const {
396  Args, CmdArgs,
397  (Twine("libclang_rt.") + Sanitizer + "_" +
398  getOSLibraryNameSuffix() + "_dynamic.dylib").str(),
399  /*AlwaysLink*/ true, /*IsEmbedded*/ false,
400  /*AddRPath*/ true);
401 }
402 
403 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
404  ArgStringList &CmdArgs) const {
405  // Darwin only supports the compiler-rt based runtime libraries.
406  switch (GetRuntimeLibType(Args)) {
408  break;
409  default:
410  getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
411  << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
412  return;
413  }
414 
415  // Darwin doesn't support real static executables, don't link any runtime
416  // libraries with -static.
417  if (Args.hasArg(options::OPT_static) ||
418  Args.hasArg(options::OPT_fapple_kext) ||
419  Args.hasArg(options::OPT_mkernel))
420  return;
421 
422  // Reject -static-libgcc for now, we can deal with this when and if someone
423  // cares. This is useful in situations where someone wants to statically link
424  // something like libstdc++, and needs its runtime support routines.
425  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
426  getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
427  return;
428  }
429 
430  const SanitizerArgs &Sanitize = getSanitizerArgs();
431  if (Sanitize.needsAsanRt())
432  AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
433  if (Sanitize.needsUbsanRt())
434  AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
435  if (Sanitize.needsTsanRt())
436  AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
437  if (Sanitize.needsStatsRt()) {
438  StringRef OS = isTargetMacOS() ? "osx" : "iossim";
439  AddLinkRuntimeLib(Args, CmdArgs,
440  (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
441  /*AlwaysLink=*/true);
442  AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
443  }
444  if (Sanitize.needsEsanRt())
445  AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
446 
447  // Otherwise link libSystem, then the dynamic runtime library, and finally any
448  // target specific static runtime library.
449  CmdArgs.push_back("-lSystem");
450 
451  // Select the dynamic runtime library and the target specific static library.
452  if (isTargetWatchOSBased()) {
453  // We currently always need a static runtime library for watchOS.
454  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
455  } else if (isTargetTvOSBased()) {
456  // We currently always need a static runtime library for tvOS.
457  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
458  } else if (isTargetIOSBased()) {
459  // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
460  // it never went into the SDK.
461  // Linking against libgcc_s.1 isn't needed for iOS 5.0+
462  if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
463  getTriple().getArch() != llvm::Triple::aarch64)
464  CmdArgs.push_back("-lgcc_s.1");
465 
466  // We currently always need a static runtime library for iOS.
467  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
468  } else {
469  assert(isTargetMacOS() && "unexpected non MacOS platform");
470  // The dynamic runtime library was merged with libSystem for 10.6 and
471  // beyond; only 10.4 and 10.5 need an additional runtime library.
472  if (isMacosxVersionLT(10, 5))
473  CmdArgs.push_back("-lgcc_s.10.4");
474  else if (isMacosxVersionLT(10, 6))
475  CmdArgs.push_back("-lgcc_s.10.5");
476 
477  // Originally for OS X, we thought we would only need a static runtime
478  // library when targeting 10.4, to provide versions of the static functions
479  // which were omitted from 10.4.dylib. This led to the creation of the 10.4
480  // builtins library.
481  //
482  // Unfortunately, that turned out to not be true, because Darwin system
483  // headers can still use eprintf on i386, and it is not exported from
484  // libSystem. Therefore, we still must provide a runtime library just for
485  // the tiny tiny handful of projects that *might* use that symbol.
486  //
487  // Then over time, we figured out it was useful to add more things to the
488  // runtime so we created libclang_rt.osx.a to provide new functions when
489  // deploying to old OS builds, and for a long time we had both eprintf and
490  // osx builtin libraries. Which just seems excessive. So with PR 28855, we
491  // are removing the eprintf library and expecting eprintf to be provided by
492  // the OS X builtins library.
493  if (isMacosxVersionLT(10, 5))
494  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
495  else
496  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
497  }
498 }
499 
500 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
501  const OptTable &Opts = getDriver().getOpts();
502 
503  // Support allowing the SDKROOT environment variable used by xcrun and other
504  // Xcode tools to define the default sysroot, by making it the default for
505  // isysroot.
506  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
507  // Warn if the path does not exist.
508  if (!getVFS().exists(A->getValue()))
509  getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
510  } else {
511  if (char *env = ::getenv("SDKROOT")) {
512  // We only use this value as the default if it is an absolute path,
513  // exists, and it is not the root path.
514  if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
515  StringRef(env) != "/") {
516  Args.append(Args.MakeSeparateArg(
517  nullptr, Opts.getOption(options::OPT_isysroot), env));
518  }
519  }
520  }
521 
522  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
523  Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
524  Arg *TvOSVersion = Args.getLastArg(options::OPT_mtvos_version_min_EQ);
525  Arg *WatchOSVersion = Args.getLastArg(options::OPT_mwatchos_version_min_EQ);
526 
527  if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
528  getDriver().Diag(diag::err_drv_argument_not_allowed_with)
529  << OSXVersion->getAsString(Args)
530  << (iOSVersion ? iOSVersion :
531  TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
532  iOSVersion = TvOSVersion = WatchOSVersion = nullptr;
533  } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
534  getDriver().Diag(diag::err_drv_argument_not_allowed_with)
535  << iOSVersion->getAsString(Args)
536  << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
537  TvOSVersion = WatchOSVersion = nullptr;
538  } else if (TvOSVersion && WatchOSVersion) {
539  getDriver().Diag(diag::err_drv_argument_not_allowed_with)
540  << TvOSVersion->getAsString(Args)
541  << WatchOSVersion->getAsString(Args);
542  WatchOSVersion = nullptr;
543  } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
544  // If no deployment target was specified on the command line, check for
545  // environment defines.
546  std::string OSXTarget;
547  std::string iOSTarget;
548  std::string TvOSTarget;
549  std::string WatchOSTarget;
550 
551  if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
552  OSXTarget = env;
553  if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
554  iOSTarget = env;
555  if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET"))
556  TvOSTarget = env;
557  if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET"))
558  WatchOSTarget = env;
559 
560  // If there is no command-line argument to specify the Target version and
561  // no environment variable defined, see if we can set the default based
562  // on -isysroot.
563  if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
564  TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
565  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
566  StringRef isysroot = A->getValue();
567  StringRef SDK = getSDKName(isysroot);
568  if (SDK.size() > 0) {
569  // Slice the version number out.
570  // Version number is between the first and the last number.
571  size_t StartVer = SDK.find_first_of("0123456789");
572  size_t EndVer = SDK.find_last_of("0123456789");
573  if (StartVer != StringRef::npos && EndVer > StartVer) {
574  StringRef Version = SDK.slice(StartVer, EndVer + 1);
575  if (SDK.startswith("iPhoneOS") ||
576  SDK.startswith("iPhoneSimulator"))
577  iOSTarget = Version;
578  else if (SDK.startswith("MacOSX"))
579  OSXTarget = Version;
580  else if (SDK.startswith("WatchOS") ||
581  SDK.startswith("WatchSimulator"))
582  WatchOSTarget = Version;
583  else if (SDK.startswith("AppleTVOS") ||
584  SDK.startswith("AppleTVSimulator"))
585  TvOSTarget = Version;
586  }
587  }
588  }
589  }
590 
591  // If no OSX or iOS target has been specified, try to guess platform
592  // from arch name and compute the version from the triple.
593  if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
594  WatchOSTarget.empty()) {
595  StringRef MachOArchName = getMachOArchName(Args);
596  unsigned Major, Minor, Micro;
597  if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
598  MachOArchName == "arm64") {
599  getTriple().getiOSVersion(Major, Minor, Micro);
600  llvm::raw_string_ostream(iOSTarget) << Major << '.' << Minor << '.'
601  << Micro;
602  } else if (MachOArchName == "armv7k") {
603  getTriple().getWatchOSVersion(Major, Minor, Micro);
604  llvm::raw_string_ostream(WatchOSTarget) << Major << '.' << Minor << '.'
605  << Micro;
606  } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
607  MachOArchName != "armv7em") {
608  if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) {
609  getDriver().Diag(diag::err_drv_invalid_darwin_version)
610  << getTriple().getOSName();
611  }
612  llvm::raw_string_ostream(OSXTarget) << Major << '.' << Minor << '.'
613  << Micro;
614  }
615  }
616 
617  // Do not allow conflicts with the watchOS target.
618  if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
619  getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
620  << "WATCHOS_DEPLOYMENT_TARGET"
621  << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" :
622  "TVOS_DEPLOYMENT_TARGET");
623  }
624 
625  // Do not allow conflicts with the tvOS target.
626  if (!TvOSTarget.empty() && !iOSTarget.empty()) {
627  getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
628  << "TVOS_DEPLOYMENT_TARGET"
629  << "IPHONEOS_DEPLOYMENT_TARGET";
630  }
631 
632  // Allow conflicts among OSX and iOS for historical reasons, but choose the
633  // default platform.
634  if (!OSXTarget.empty() && (!iOSTarget.empty() ||
635  !WatchOSTarget.empty() ||
636  !TvOSTarget.empty())) {
637  if (getTriple().getArch() == llvm::Triple::arm ||
638  getTriple().getArch() == llvm::Triple::aarch64 ||
639  getTriple().getArch() == llvm::Triple::thumb)
640  OSXTarget = "";
641  else
642  iOSTarget = WatchOSTarget = TvOSTarget = "";
643  }
644 
645  if (!OSXTarget.empty()) {
646  const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
647  OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
648  Args.append(OSXVersion);
649  } else if (!iOSTarget.empty()) {
650  const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
651  iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
652  Args.append(iOSVersion);
653  } else if (!TvOSTarget.empty()) {
654  const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
655  TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget);
656  Args.append(TvOSVersion);
657  } else if (!WatchOSTarget.empty()) {
658  const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
659  WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget);
660  Args.append(WatchOSVersion);
661  }
662  }
663 
664  DarwinPlatformKind Platform;
665  if (OSXVersion)
666  Platform = MacOS;
667  else if (iOSVersion)
668  Platform = IPhoneOS;
669  else if (TvOSVersion)
670  Platform = TvOS;
671  else if (WatchOSVersion)
672  Platform = WatchOS;
673  else
674  llvm_unreachable("Unable to infer Darwin variant");
675 
676  // Set the tool chain target information.
677  unsigned Major, Minor, Micro;
678  bool HadExtra;
679  if (Platform == MacOS) {
680  assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
681  "Unknown target platform!");
682  if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
683  HadExtra) ||
684  HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
685  getDriver().Diag(diag::err_drv_invalid_version_number)
686  << OSXVersion->getAsString(Args);
687  } else if (Platform == IPhoneOS) {
688  assert(iOSVersion && "Unknown target platform!");
689  if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
690  HadExtra) ||
691  HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
692  getDriver().Diag(diag::err_drv_invalid_version_number)
693  << iOSVersion->getAsString(Args);
694  } else if (Platform == TvOS) {
695  if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
696  Micro, HadExtra) || HadExtra ||
697  Major >= 10 || Minor >= 100 || Micro >= 100)
698  getDriver().Diag(diag::err_drv_invalid_version_number)
699  << TvOSVersion->getAsString(Args);
700  } else if (Platform == WatchOS) {
701  if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
702  Micro, HadExtra) || HadExtra ||
703  Major >= 10 || Minor >= 100 || Micro >= 100)
704  getDriver().Diag(diag::err_drv_invalid_version_number)
705  << WatchOSVersion->getAsString(Args);
706  } else
707  llvm_unreachable("unknown kind of Darwin platform");
708 
709  // Recognize iOS targets with an x86 architecture as the iOS simulator.
710  if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
711  getTriple().getArch() == llvm::Triple::x86_64))
712  Platform = IPhoneOSSimulator;
713  if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
714  getTriple().getArch() == llvm::Triple::x86_64))
715  Platform = TvOSSimulator;
716  if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
717  getTriple().getArch() == llvm::Triple::x86_64))
718  Platform = WatchOSSimulator;
719 
720  setTarget(Platform, Major, Minor, Micro);
721 
722  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
723  StringRef SDK = getSDKName(A->getValue());
724  if (SDK.size() > 0) {
725  size_t StartVer = SDK.find_first_of("0123456789");
726  StringRef SDKName = SDK.slice(0, StartVer);
727  if (!SDKName.startswith(getPlatformFamily()))
728  getDriver().Diag(diag::warn_incompatible_sysroot)
729  << SDKName << getPlatformFamily();
730  }
731  }
732 }
733 
734 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
735  ArgStringList &CmdArgs) const {
737 
738  switch (Type) {
740  CmdArgs.push_back("-lc++");
741  break;
742 
744  // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
745  // it was previously found in the gcc lib dir. However, for all the Darwin
746  // platforms we care about it was -lstdc++.6, so we search for that
747  // explicitly if we can't see an obvious -lstdc++ candidate.
748 
749  // Check in the sysroot first.
750  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
751  SmallString<128> P(A->getValue());
752  llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
753 
754  if (!getVFS().exists(P)) {
755  llvm::sys::path::remove_filename(P);
756  llvm::sys::path::append(P, "libstdc++.6.dylib");
757  if (getVFS().exists(P)) {
758  CmdArgs.push_back(Args.MakeArgString(P));
759  return;
760  }
761  }
762  }
763 
764  // Otherwise, look in the root.
765  // FIXME: This should be removed someday when we don't have to care about
766  // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
767  if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
768  getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
769  CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
770  return;
771  }
772 
773  // Otherwise, let the linker search.
774  CmdArgs.push_back("-lstdc++");
775  break;
776  }
777 }
778 
779 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
780  ArgStringList &CmdArgs) const {
781  // For Darwin platforms, use the compiler-rt-based support library
782  // instead of the gcc-provided one (which is also incidentally
783  // only present in the gcc lib dir, which makes it hard to find).
784 
785  SmallString<128> P(getDriver().ResourceDir);
786  llvm::sys::path::append(P, "lib", "darwin");
787 
788  // Use the newer cc_kext for iOS ARM after 6.0.
789  if (isTargetWatchOS()) {
790  llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
791  } else if (isTargetTvOS()) {
792  llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
793  } else if (isTargetIPhoneOS()) {
794  llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
795  } else {
796  llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
797  }
798 
799  // For now, allow missing resource libraries to support developers who may
800  // not have compiler-rt checked out or integrated into their build.
801  if (getVFS().exists(P))
802  CmdArgs.push_back(Args.MakeArgString(P));
803 }
804 
805 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
806  const char *BoundArch) const {
807  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
808  const OptTable &Opts = getDriver().getOpts();
809 
810  // FIXME: We really want to get out of the tool chain level argument
811  // translation business, as it makes the driver functionality much
812  // more opaque. For now, we follow gcc closely solely for the
813  // purpose of easily achieving feature parity & testability. Once we
814  // have something that works, we should reevaluate each translation
815  // and try to push it down into tool specific logic.
816 
817  for (Arg *A : Args) {
818  if (A->getOption().matches(options::OPT_Xarch__)) {
819  // Skip this argument unless the architecture matches either the toolchain
820  // triple arch, or the arch being bound.
821  llvm::Triple::ArchType XarchArch =
823  if (!(XarchArch == getArch() ||
824  (BoundArch &&
825  XarchArch ==
827  continue;
828 
829  Arg *OriginalArg = A;
830  unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
831  unsigned Prev = Index;
832  std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
833 
834  // If the argument parsing failed or more than one argument was
835  // consumed, the -Xarch_ argument's parameter tried to consume
836  // extra arguments. Emit an error and ignore.
837  //
838  // We also want to disallow any options which would alter the
839  // driver behavior; that isn't going to work in our model. We
840  // use isDriverOption() as an approximation, although things
841  // like -O4 are going to slip through.
842  if (!XarchArg || Index > Prev + 1) {
843  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
844  << A->getAsString(Args);
845  continue;
846  } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
847  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
848  << A->getAsString(Args);
849  continue;
850  }
851 
852  XarchArg->setBaseArg(A);
853 
854  A = XarchArg.release();
855  DAL->AddSynthesizedArg(A);
856 
857  // Linker input arguments require custom handling. The problem is that we
858  // have already constructed the phase actions, so we can not treat them as
859  // "input arguments".
860  if (A->getOption().hasFlag(options::LinkerInput)) {
861  // Convert the argument into individual Zlinker_input_args.
862  for (const char *Value : A->getValues()) {
863  DAL->AddSeparateArg(
864  OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
865  }
866  continue;
867  }
868  }
869 
870  // Sob. These is strictly gcc compatible for the time being. Apple
871  // gcc translates options twice, which means that self-expanding
872  // options add duplicates.
873  switch ((options::ID)A->getOption().getID()) {
874  default:
875  DAL->append(A);
876  break;
877 
878  case options::OPT_mkernel:
879  case options::OPT_fapple_kext:
880  DAL->append(A);
881  DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
882  break;
883 
884  case options::OPT_dependency_file:
885  DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
886  break;
887 
888  case options::OPT_gfull:
889  DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
890  DAL->AddFlagArg(
891  A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
892  break;
893 
894  case options::OPT_gused:
895  DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
896  DAL->AddFlagArg(
897  A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
898  break;
899 
900  case options::OPT_shared:
901  DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
902  break;
903 
904  case options::OPT_fconstant_cfstrings:
905  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
906  break;
907 
908  case options::OPT_fno_constant_cfstrings:
909  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
910  break;
911 
912  case options::OPT_Wnonportable_cfstrings:
913  DAL->AddFlagArg(A,
914  Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
915  break;
916 
917  case options::OPT_Wno_nonportable_cfstrings:
918  DAL->AddFlagArg(
919  A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
920  break;
921 
922  case options::OPT_fpascal_strings:
923  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
924  break;
925 
926  case options::OPT_fno_pascal_strings:
927  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
928  break;
929  }
930  }
931 
932  if (getTriple().getArch() == llvm::Triple::x86 ||
933  getTriple().getArch() == llvm::Triple::x86_64)
934  if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
935  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
936  "core2");
937 
938  // Add the arch options based on the particular spelling of -arch, to match
939  // how the driver driver works.
940  if (BoundArch) {
941  StringRef Name = BoundArch;
942  const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
943  const Option MArch = Opts.getOption(options::OPT_march_EQ);
944 
945  // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
946  // which defines the list of which architectures we accept.
947  if (Name == "ppc")
948  ;
949  else if (Name == "ppc601")
950  DAL->AddJoinedArg(nullptr, MCpu, "601");
951  else if (Name == "ppc603")
952  DAL->AddJoinedArg(nullptr, MCpu, "603");
953  else if (Name == "ppc604")
954  DAL->AddJoinedArg(nullptr, MCpu, "604");
955  else if (Name == "ppc604e")
956  DAL->AddJoinedArg(nullptr, MCpu, "604e");
957  else if (Name == "ppc750")
958  DAL->AddJoinedArg(nullptr, MCpu, "750");
959  else if (Name == "ppc7400")
960  DAL->AddJoinedArg(nullptr, MCpu, "7400");
961  else if (Name == "ppc7450")
962  DAL->AddJoinedArg(nullptr, MCpu, "7450");
963  else if (Name == "ppc970")
964  DAL->AddJoinedArg(nullptr, MCpu, "970");
965 
966  else if (Name == "ppc64" || Name == "ppc64le")
967  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
968 
969  else if (Name == "i386")
970  ;
971  else if (Name == "i486")
972  DAL->AddJoinedArg(nullptr, MArch, "i486");
973  else if (Name == "i586")
974  DAL->AddJoinedArg(nullptr, MArch, "i586");
975  else if (Name == "i686")
976  DAL->AddJoinedArg(nullptr, MArch, "i686");
977  else if (Name == "pentium")
978  DAL->AddJoinedArg(nullptr, MArch, "pentium");
979  else if (Name == "pentium2")
980  DAL->AddJoinedArg(nullptr, MArch, "pentium2");
981  else if (Name == "pentpro")
982  DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
983  else if (Name == "pentIIm3")
984  DAL->AddJoinedArg(nullptr, MArch, "pentium2");
985 
986  else if (Name == "x86_64")
987  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
988  else if (Name == "x86_64h") {
989  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
990  DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
991  }
992 
993  else if (Name == "arm")
994  DAL->AddJoinedArg(nullptr, MArch, "armv4t");
995  else if (Name == "armv4t")
996  DAL->AddJoinedArg(nullptr, MArch, "armv4t");
997  else if (Name == "armv5")
998  DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
999  else if (Name == "xscale")
1000  DAL->AddJoinedArg(nullptr, MArch, "xscale");
1001  else if (Name == "armv6")
1002  DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1003  else if (Name == "armv6m")
1004  DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1005  else if (Name == "armv7")
1006  DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1007  else if (Name == "armv7em")
1008  DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1009  else if (Name == "armv7k")
1010  DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1011  else if (Name == "armv7m")
1012  DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1013  else if (Name == "armv7s")
1014  DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1015  }
1016 
1017  return DAL;
1018 }
1019 
1020 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1021  ArgStringList &CmdArgs) const {
1022  // Embedded targets are simple at the moment, not supporting sanitizers and
1023  // with different libraries for each member of the product { static, PIC } x
1024  // { hard-float, soft-float }
1025  llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1026  CompilerRT +=
1028  ? "hard"
1029  : "soft";
1030  CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1031 
1032  AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
1033 }
1034 
1035 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
1036  const char *BoundArch) const {
1037  // First get the generic Apple args, before moving onto Darwin-specific ones.
1038  DerivedArgList *DAL = MachO::TranslateArgs(Args, BoundArch);
1039  const OptTable &Opts = getDriver().getOpts();
1040 
1041  // If no architecture is bound, none of the translations here are relevant.
1042  if (!BoundArch)
1043  return DAL;
1044 
1045  // Add an explicit version min argument for the deployment target. We do this
1046  // after argument translation because -Xarch_ arguments may add a version min
1047  // argument.
1048  AddDeploymentTarget(*DAL);
1049 
1050  // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1051  // FIXME: It would be far better to avoid inserting those -static arguments,
1052  // but we can't check the deployment target in the translation code until
1053  // it is set here.
1054  if (isTargetWatchOSBased() ||
1055  (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1056  for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1057  Arg *A = *it;
1058  ++it;
1059  if (A->getOption().getID() != options::OPT_mkernel &&
1060  A->getOption().getID() != options::OPT_fapple_kext)
1061  continue;
1062  assert(it != ie && "unexpected argument translation");
1063  A = *it;
1064  assert(A->getOption().getID() == options::OPT_static &&
1065  "missing expected -static argument");
1066  it = DAL->getArgs().erase(it);
1067  }
1068  }
1069 
1070  if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1072  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1073  "libc++");
1074 
1075  // Validate the C++ standard library choice.
1077  if (Type == ToolChain::CST_Libcxx) {
1078  // Check whether the target provides libc++.
1079  StringRef where;
1080 
1081  // Complain about targeting iOS < 5.0 in any way.
1082  if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1083  where = "iOS 5.0";
1084 
1085  if (where != StringRef()) {
1086  getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1087  }
1088  }
1089 
1090  return DAL;
1091 }
1092 
1094  return getArch() == llvm::Triple::x86_64;
1095 }
1096 
1098  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1099  return S[0] != '\0';
1100  return false;
1101 }
1102 
1103 bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
1104  // Darwin uses SjLj exceptions on ARM.
1105  if (getTriple().getArch() != llvm::Triple::arm &&
1106  getTriple().getArch() != llvm::Triple::thumb)
1107  return false;
1108 
1109  // Only watchOS uses the new DWARF/Compact unwinding method.
1110  llvm::Triple Triple(ComputeLLVMTriple(Args));
1111  return !Triple.isWatchABI();
1112 }
1113 
1115  assert(TargetInitialized && "Target not initialized!");
1116  if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
1117  return false;
1118  return true;
1119 }
1120 
1121 bool MachO::isPICDefault() const { return true; }
1122 
1123 bool MachO::isPIEDefault() const { return false; }
1124 
1126  return (getArch() == llvm::Triple::x86_64 ||
1127  getArch() == llvm::Triple::aarch64);
1128 }
1129 
1131  // Profiling instrumentation is only supported on x86.
1132  return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
1133 }
1134 
1135 void Darwin::addMinVersionArgs(const ArgList &Args,
1136  ArgStringList &CmdArgs) const {
1138 
1139  if (isTargetWatchOS())
1140  CmdArgs.push_back("-watchos_version_min");
1141  else if (isTargetWatchOSSimulator())
1142  CmdArgs.push_back("-watchos_simulator_version_min");
1143  else if (isTargetTvOS())
1144  CmdArgs.push_back("-tvos_version_min");
1145  else if (isTargetTvOSSimulator())
1146  CmdArgs.push_back("-tvos_simulator_version_min");
1147  else if (isTargetIOSSimulator())
1148  CmdArgs.push_back("-ios_simulator_version_min");
1149  else if (isTargetIOSBased())
1150  CmdArgs.push_back("-iphoneos_version_min");
1151  else {
1152  assert(isTargetMacOS() && "unexpected target");
1153  CmdArgs.push_back("-macosx_version_min");
1154  }
1155 
1156  CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
1157 }
1158 
1159 void Darwin::addStartObjectFileArgs(const ArgList &Args,
1160  ArgStringList &CmdArgs) const {
1161  // Derived from startfile spec.
1162  if (Args.hasArg(options::OPT_dynamiclib)) {
1163  // Derived from darwin_dylib1 spec.
1164  if (isTargetWatchOSBased()) {
1165  ; // watchOS does not need dylib1.o.
1166  } else if (isTargetIOSSimulator()) {
1167  ; // iOS simulator does not need dylib1.o.
1168  } else if (isTargetIPhoneOS()) {
1169  if (isIPhoneOSVersionLT(3, 1))
1170  CmdArgs.push_back("-ldylib1.o");
1171  } else {
1172  if (isMacosxVersionLT(10, 5))
1173  CmdArgs.push_back("-ldylib1.o");
1174  else if (isMacosxVersionLT(10, 6))
1175  CmdArgs.push_back("-ldylib1.10.5.o");
1176  }
1177  } else {
1178  if (Args.hasArg(options::OPT_bundle)) {
1179  if (!Args.hasArg(options::OPT_static)) {
1180  // Derived from darwin_bundle1 spec.
1181  if (isTargetWatchOSBased()) {
1182  ; // watchOS does not need bundle1.o.
1183  } else if (isTargetIOSSimulator()) {
1184  ; // iOS simulator does not need bundle1.o.
1185  } else if (isTargetIPhoneOS()) {
1186  if (isIPhoneOSVersionLT(3, 1))
1187  CmdArgs.push_back("-lbundle1.o");
1188  } else {
1189  if (isMacosxVersionLT(10, 6))
1190  CmdArgs.push_back("-lbundle1.o");
1191  }
1192  }
1193  } else {
1194  if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
1195  if (Args.hasArg(options::OPT_static) ||
1196  Args.hasArg(options::OPT_object) ||
1197  Args.hasArg(options::OPT_preload)) {
1198  CmdArgs.push_back("-lgcrt0.o");
1199  } else {
1200  CmdArgs.push_back("-lgcrt1.o");
1201 
1202  // darwin_crt2 spec is empty.
1203  }
1204  // By default on OS X 10.8 and later, we don't link with a crt1.o
1205  // file and the linker knows to use _main as the entry point. But,
1206  // when compiling with -pg, we need to link with the gcrt1.o file,
1207  // so pass the -no_new_main option to tell the linker to use the
1208  // "start" symbol as the entry point.
1209  if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1210  CmdArgs.push_back("-no_new_main");
1211  } else {
1212  if (Args.hasArg(options::OPT_static) ||
1213  Args.hasArg(options::OPT_object) ||
1214  Args.hasArg(options::OPT_preload)) {
1215  CmdArgs.push_back("-lcrt0.o");
1216  } else {
1217  // Derived from darwin_crt1 spec.
1218  if (isTargetWatchOSBased()) {
1219  ; // watchOS does not need crt1.o.
1220  } else if (isTargetIOSSimulator()) {
1221  ; // iOS simulator does not need crt1.o.
1222  } else if (isTargetIPhoneOS()) {
1223  if (getArch() == llvm::Triple::aarch64)
1224  ; // iOS does not need any crt1 files for arm64
1225  else if (isIPhoneOSVersionLT(3, 1))
1226  CmdArgs.push_back("-lcrt1.o");
1227  else if (isIPhoneOSVersionLT(6, 0))
1228  CmdArgs.push_back("-lcrt1.3.1.o");
1229  } else {
1230  if (isMacosxVersionLT(10, 5))
1231  CmdArgs.push_back("-lcrt1.o");
1232  else if (isMacosxVersionLT(10, 6))
1233  CmdArgs.push_back("-lcrt1.10.5.o");
1234  else if (isMacosxVersionLT(10, 8))
1235  CmdArgs.push_back("-lcrt1.10.6.o");
1236 
1237  // darwin_crt2 spec is empty.
1238  }
1239  }
1240  }
1241  }
1242  }
1243 
1244  if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1245  !isTargetWatchOS() &&
1246  isMacosxVersionLT(10, 5)) {
1247  const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1248  CmdArgs.push_back(Str);
1249  }
1250 }
1251 
1252 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
1253 
1254 void Darwin::CheckObjCARC() const {
1256  (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
1257  return;
1258  getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
1259 }
1260 
1262  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
1264  Res |= SanitizerKind::Address;
1265  if (isTargetMacOS()) {
1266  if (!isMacosxVersionLT(10, 9))
1267  Res |= SanitizerKind::Vptr;
1268  Res |= SanitizerKind::SafeStack;
1269  if (IsX86_64)
1270  Res |= SanitizerKind::Thread;
1271  } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
1272  if (IsX86_64)
1273  Res |= SanitizerKind::Thread;
1274  }
1275  return Res;
1276 }
1277 
1278 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1279 /// all subcommands; this relies on gcc translating the majority of
1280 /// command line options.
1281 
1282 /// \brief Parse a GCCVersion object out of a string of text.
1283 ///
1284 /// This is the primary means of forming GCCVersion objects.
1285 /*static*/
1286 Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
1287  const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1288  std::pair<StringRef, StringRef> First = VersionText.split('.');
1289  std::pair<StringRef, StringRef> Second = First.second.split('.');
1290 
1291  GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1292  if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1293  return BadVersion;
1294  GoodVersion.MajorStr = First.first.str();
1295  if (First.second.empty())
1296  return GoodVersion;
1297  if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1298  return BadVersion;
1299  GoodVersion.MinorStr = Second.first.str();
1300 
1301  // First look for a number prefix and parse that if present. Otherwise just
1302  // stash the entire patch string in the suffix, and leave the number
1303  // unspecified. This covers versions strings such as:
1304  // 5 (handled above)
1305  // 4.4
1306  // 4.4.0
1307  // 4.4.x
1308  // 4.4.2-rc4
1309  // 4.4.x-patched
1310  // And retains any patch number it finds.
1311  StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1312  if (!PatchText.empty()) {
1313  if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1314  // Try to parse the number and any suffix.
1315  if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1316  GoodVersion.Patch < 0)
1317  return BadVersion;
1318  GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1319  }
1320  }
1321 
1322  return GoodVersion;
1323 }
1324 
1325 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
1326 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1327  int RHSPatch,
1328  StringRef RHSPatchSuffix) const {
1329  if (Major != RHSMajor)
1330  return Major < RHSMajor;
1331  if (Minor != RHSMinor)
1332  return Minor < RHSMinor;
1333  if (Patch != RHSPatch) {
1334  // Note that versions without a specified patch sort higher than those with
1335  // a patch.
1336  if (RHSPatch == -1)
1337  return true;
1338  if (Patch == -1)
1339  return false;
1340 
1341  // Otherwise just sort on the patch itself.
1342  return Patch < RHSPatch;
1343  }
1344  if (PatchSuffix != RHSPatchSuffix) {
1345  // Sort empty suffixes higher.
1346  if (RHSPatchSuffix.empty())
1347  return true;
1348  if (PatchSuffix.empty())
1349  return false;
1350 
1351  // Provide a lexicographic sort to make this a total ordering.
1352  return PatchSuffix < RHSPatchSuffix;
1353  }
1354 
1355  // The versions are equal.
1356  return false;
1357 }
1358 
1359 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
1360  const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1361  if (A)
1362  return A->getValue();
1363  return GCC_INSTALL_PREFIX;
1364 }
1365 
1366 /// \brief Initialize a GCCInstallationDetector from the driver.
1367 ///
1368 /// This performs all of the autodetection and sets up the various paths.
1369 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1370 ///
1371 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1372 /// should instead pull the target out of the driver. This is currently
1373 /// necessary because the driver doesn't store the final version of the target
1374 /// triple.
1376  const llvm::Triple &TargetTriple, const ArgList &Args,
1377  ArrayRef<std::string> ExtraTripleAliases) {
1378  llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1379  ? TargetTriple.get64BitArchVariant()
1380  : TargetTriple.get32BitArchVariant();
1381  // The library directories which may contain GCC installations.
1382  SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1383  // The compatible GCC triples for this particular architecture.
1384  SmallVector<StringRef, 16> CandidateTripleAliases;
1385  SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1386  CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1387  CandidateTripleAliases, CandidateBiarchLibDirs,
1388  CandidateBiarchTripleAliases);
1389 
1390  // Compute the set of prefixes for our search.
1391  SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1392  D.PrefixDirs.end());
1393 
1394  StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1395  if (GCCToolchainDir != "") {
1396  if (GCCToolchainDir.back() == '/')
1397  GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1398 
1399  Prefixes.push_back(GCCToolchainDir);
1400  } else {
1401  // If we have a SysRoot, try that first.
1402  if (!D.SysRoot.empty()) {
1403  Prefixes.push_back(D.SysRoot);
1404  Prefixes.push_back(D.SysRoot + "/usr");
1405  }
1406 
1407  // Then look for gcc installed alongside clang.
1408  Prefixes.push_back(D.InstalledDir + "/..");
1409 
1410  // Then look for distribution supplied gcc installations.
1411  if (D.SysRoot.empty()) {
1412  // Look for RHEL devtoolsets.
1413  Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
1414  Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
1415  Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
1416  Prefixes.push_back("/opt/rh/devtoolset-1.1/root/usr");
1417  Prefixes.push_back("/opt/rh/devtoolset-1.0/root/usr");
1418  // And finally in /usr.
1419  Prefixes.push_back("/usr");
1420  }
1421  }
1422 
1423  // Loop over the various components which exist and select the best GCC
1424  // installation available. GCC installs are ranked by version number.
1425  Version = GCCVersion::Parse("0.0.0");
1426  for (const std::string &Prefix : Prefixes) {
1427  if (!D.getVFS().exists(Prefix))
1428  continue;
1429  for (StringRef Suffix : CandidateLibDirs) {
1430  const std::string LibDir = Prefix + Suffix.str();
1431  if (!D.getVFS().exists(LibDir))
1432  continue;
1433  for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1434  ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1435  for (StringRef Candidate : CandidateTripleAliases)
1436  ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1437  }
1438  for (StringRef Suffix : CandidateBiarchLibDirs) {
1439  const std::string LibDir = Prefix + Suffix.str();
1440  if (!D.getVFS().exists(LibDir))
1441  continue;
1442  for (StringRef Candidate : CandidateBiarchTripleAliases)
1443  ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1444  /*NeedsBiarchSuffix=*/ true);
1445  }
1446  }
1447 }
1448 
1449 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1450  for (const auto &InstallPath : CandidateGCCInstallPaths)
1451  OS << "Found candidate GCC installation: " << InstallPath << "\n";
1452 
1453  if (!GCCInstallPath.empty())
1454  OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1455 
1456  for (const auto &Multilib : Multilibs)
1457  OS << "Candidate multilib: " << Multilib << "\n";
1458 
1459  if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1460  OS << "Selected multilib: " << SelectedMultilib << "\n";
1461 }
1462 
1464  if (BiarchSibling.hasValue()) {
1465  M = BiarchSibling.getValue();
1466  return true;
1467  }
1468  return false;
1469 }
1470 
1471 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1472  const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1473  SmallVectorImpl<StringRef> &LibDirs,
1474  SmallVectorImpl<StringRef> &TripleAliases,
1475  SmallVectorImpl<StringRef> &BiarchLibDirs,
1476  SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1477  // Declare a bunch of static data sets that we'll select between below. These
1478  // are specifically designed to always refer to string literals to avoid any
1479  // lifetime or initialization issues.
1480  static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1481  static const char *const AArch64Triples[] = {
1482  "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android",
1483  "aarch64-redhat-linux"};
1484  static const char *const AArch64beLibDirs[] = {"/lib"};
1485  static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1486  "aarch64_be-linux-gnu"};
1487 
1488  static const char *const ARMLibDirs[] = {"/lib"};
1489  static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1490  "arm-linux-androideabi"};
1491  static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1492  "armv7hl-redhat-linux-gnueabi"};
1493  static const char *const ARMebLibDirs[] = {"/lib"};
1494  static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1495  "armeb-linux-androideabi"};
1496  static const char *const ARMebHFTriples[] = {
1497  "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
1498 
1499  static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
1500  static const char *const X86_64Triples[] = {
1501  "x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
1502  "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
1503  "x86_64-redhat-linux", "x86_64-suse-linux",
1504  "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1505  "x86_64-slackware-linux", "x86_64-linux-android",
1506  "x86_64-unknown-linux"};
1507  static const char *const X32LibDirs[] = {"/libx32"};
1508  static const char *const X86LibDirs[] = {"/lib32", "/lib"};
1509  static const char *const X86Triples[] = {
1510  "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu",
1511  "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux",
1512  "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux",
1513  "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",
1514  "i586-linux-gnu"};
1515 
1516  static const char *const MIPSLibDirs[] = {"/lib"};
1517  static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux",
1518  "mips-mti-linux-gnu",
1519  "mips-img-linux-gnu"};
1520  static const char *const MIPSELLibDirs[] = {"/lib"};
1521  static const char *const MIPSELTriples[] = {
1522  "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"};
1523 
1524  static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1525  static const char *const MIPS64Triples[] = {
1526  "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1527  "mips64-linux-gnuabi64"};
1528  static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1529  static const char *const MIPS64ELTriples[] = {
1530  "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1531  "mips64el-linux-android", "mips64el-linux-gnuabi64"};
1532 
1533  static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
1534  static const char *const PPCTriples[] = {
1535  "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1536  "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
1537  static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
1538  static const char *const PPC64Triples[] = {
1539  "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
1540  "powerpc64-suse-linux", "ppc64-redhat-linux"};
1541  static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
1542  static const char *const PPC64LETriples[] = {
1543  "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
1544  "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
1545 
1546  static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
1547  static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
1548  "sparcv8-linux-gnu"};
1549  static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
1550  static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
1551  "sparcv9-linux-gnu"};
1552 
1553  static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
1554  static const char *const SystemZTriples[] = {
1555  "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1556  "s390x-suse-linux", "s390x-redhat-linux"};
1557 
1558  // Solaris.
1559  static const char *const SolarisSPARCLibDirs[] = {"/gcc"};
1560  static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",
1561  "i386-pc-solaris2.11"};
1562 
1563  using std::begin;
1564  using std::end;
1565 
1566  if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1567  LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));
1568  TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));
1569  return;
1570  }
1571 
1572  switch (TargetTriple.getArch()) {
1573  case llvm::Triple::aarch64:
1574  LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1575  TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1576  BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1577  BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1578  break;
1579  case llvm::Triple::aarch64_be:
1580  LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1581  TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1582  BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1583  BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1584  break;
1585  case llvm::Triple::arm:
1586  case llvm::Triple::thumb:
1587  LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1588  if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1589  TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1590  } else {
1591  TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1592  }
1593  break;
1594  case llvm::Triple::armeb:
1595  case llvm::Triple::thumbeb:
1596  LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1597  if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1598  TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1599  } else {
1600  TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1601  }
1602  break;
1603  case llvm::Triple::x86_64:
1604  LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1605  TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1606  // x32 is always available when x86_64 is available, so adding it as
1607  // secondary arch with x86_64 triples
1608  if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1609  BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1610  BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1611  } else {
1612  BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1613  BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
1614  }
1615  break;
1616  case llvm::Triple::x86:
1617  LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1618  // MCU toolchain is 32 bit only and its triple alias is TargetTriple
1619  // itself, which will be appended below.
1620  if (!TargetTriple.isOSIAMCU()) {
1621  TripleAliases.append(begin(X86Triples), end(X86Triples));
1622  BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1623  BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1624  }
1625  break;
1626  case llvm::Triple::mips:
1627  LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1628  TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1629  BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1630  BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1631  break;
1632  case llvm::Triple::mipsel:
1633  LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1634  TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1635  TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1636  BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1637  BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1638  break;
1639  case llvm::Triple::mips64:
1640  LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1641  TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1642  BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1643  BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1644  break;
1645  case llvm::Triple::mips64el:
1646  LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1647  TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1648  BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1649  BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1650  BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1651  break;
1652  case llvm::Triple::ppc:
1653  LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1654  TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1655  BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1656  BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1657  break;
1658  case llvm::Triple::ppc64:
1659  LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1660  TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1661  BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1662  BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
1663  break;
1664  case llvm::Triple::ppc64le:
1665  LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1666  TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
1667  break;
1668  case llvm::Triple::sparc:
1669  case llvm::Triple::sparcel:
1670  LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1671  TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1672  BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1673  BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1674  break;
1675  case llvm::Triple::sparcv9:
1676  LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1677  TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1678  BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1679  BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1680  break;
1681  case llvm::Triple::systemz:
1682  LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1683  TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
1684  break;
1685  default:
1686  // By default, just rely on the standard lib directories and the original
1687  // triple.
1688  break;
1689  }
1690 
1691  // Always append the drivers target triple to the end, in case it doesn't
1692  // match any of our aliases.
1693  TripleAliases.push_back(TargetTriple.str());
1694 
1695  // Also include the multiarch variant if it's different.
1696  if (TargetTriple.str() != BiarchTriple.str())
1697  BiarchTripleAliases.push_back(BiarchTriple.str());
1698 }
1699 
1700 // Parses the contents of version.txt in an CUDA installation. It should
1701 // contain one line of the from e.g. "CUDA Version 7.5.2".
1702 static CudaVersion ParseCudaVersionFile(llvm::StringRef V) {
1703  if (!V.startswith("CUDA Version "))
1704  return CudaVersion::UNKNOWN;
1705  V = V.substr(strlen("CUDA Version "));
1706  int Major = -1, Minor = -1;
1707  auto First = V.split('.');
1708  auto Second = First.second.split('.');
1709  if (!First.first.getAsInteger(10, Major) ||
1710  !Second.first.getAsInteger(10, Minor))
1711  return CudaVersion::UNKNOWN;
1712 
1713  if (Major == 7 && Minor == 0) {
1714  // This doesn't appear to ever happen -- version.txt doesn't exist in the
1715  // CUDA 7 installs I've seen. But no harm in checking.
1716  return CudaVersion::CUDA_70;
1717  }
1718  if (Major == 7 && Minor == 5)
1719  return CudaVersion::CUDA_75;
1720  if (Major == 8 && Minor == 0)
1721  return CudaVersion::CUDA_80;
1722  return CudaVersion::UNKNOWN;
1723 }
1724 
1725 // \brief -- try common CUDA installation paths looking for files we need for
1726 // CUDA compilation.
1728  const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args) {
1729  SmallVector<std::string, 4> CudaPathCandidates;
1730 
1731  if (Args.hasArg(options::OPT_cuda_path_EQ))
1732  CudaPathCandidates.push_back(
1733  Args.getLastArgValue(options::OPT_cuda_path_EQ));
1734  else {
1735  CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda");
1736  // FIXME: Uncomment this once we can compile the cuda 8 headers.
1737  // CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-8.0");
1738  CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.5");
1739  CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.0");
1740  }
1741 
1742  for (const auto &CudaPath : CudaPathCandidates) {
1743  if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
1744  continue;
1745 
1746  InstallPath = CudaPath;
1747  BinPath = CudaPath + "/bin";
1748  IncludePath = InstallPath + "/include";
1749  LibDevicePath = InstallPath + "/nvvm/libdevice";
1750  LibPath = InstallPath + (TargetTriple.isArch64Bit() ? "/lib64" : "/lib");
1751 
1752  auto &FS = D.getVFS();
1753  if (!(FS.exists(IncludePath) && FS.exists(BinPath) && FS.exists(LibPath) &&
1754  FS.exists(LibDevicePath)))
1755  continue;
1756 
1757  std::error_code EC;
1758  for (llvm::sys::fs::directory_iterator LI(LibDevicePath, EC), LE;
1759  !EC && LI != LE; LI = LI.increment(EC)) {
1760  StringRef FilePath = LI->path();
1761  StringRef FileName = llvm::sys::path::filename(FilePath);
1762  // Process all bitcode filenames that look like libdevice.compute_XX.YY.bc
1763  const StringRef LibDeviceName = "libdevice.";
1764  if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
1765  continue;
1766  StringRef GpuArch = FileName.slice(
1767  LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
1768  LibDeviceMap[GpuArch] = FilePath.str();
1769  // Insert map entries for specifc devices with this compute capability.
1770  if (GpuArch == "compute_20") {
1771  LibDeviceMap["sm_20"] = FilePath;
1772  LibDeviceMap["sm_21"] = FilePath;
1773  } else if (GpuArch == "compute_30") {
1774  LibDeviceMap["sm_30"] = FilePath;
1775  LibDeviceMap["sm_32"] = FilePath;
1776  } else if (GpuArch == "compute_35") {
1777  LibDeviceMap["sm_35"] = FilePath;
1778  LibDeviceMap["sm_37"] = FilePath;
1779  } else if (GpuArch == "compute_50") {
1780  LibDeviceMap["sm_50"] = FilePath;
1781  LibDeviceMap["sm_52"] = FilePath;
1782  LibDeviceMap["sm_53"] = FilePath;
1783  LibDeviceMap["sm_60"] = FilePath;
1784  LibDeviceMap["sm_61"] = FilePath;
1785  LibDeviceMap["sm_62"] = FilePath;
1786  }
1787  }
1788 
1789  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
1790  FS.getBufferForFile(InstallPath + "/version.txt");
1791  if (!VersionFile) {
1792  // CUDA 7.0 doesn't have a version.txt, so guess that's our version if
1793  // version.txt isn't present.
1794  Version = CudaVersion::CUDA_70;
1795  } else {
1796  Version = ParseCudaVersionFile((*VersionFile)->getBuffer());
1797  }
1798 
1799  IsValid = true;
1800  break;
1801  }
1802 }
1803 
1805  CudaArch Arch) const {
1806  if (Arch == CudaArch::UNKNOWN || Version == CudaVersion::UNKNOWN ||
1807  ArchsWithVersionTooLowErrors.count(Arch) > 0)
1808  return;
1809 
1810  auto RequiredVersion = MinVersionForCudaArch(Arch);
1811  if (Version < RequiredVersion) {
1812  ArchsWithVersionTooLowErrors.insert(Arch);
1813  D.Diag(diag::err_drv_cuda_version_too_low)
1814  << InstallPath << CudaArchToString(Arch) << CudaVersionToString(Version)
1815  << CudaVersionToString(RequiredVersion);
1816  }
1817 }
1818 
1820  if (isValid())
1821  OS << "Found CUDA installation: " << InstallPath << ", version "
1822  << CudaVersionToString(Version) << "\n";
1823 }
1824 
1825 namespace {
1826 // Filter to remove Multilibs that don't exist as a suffix to Path
1827 class FilterNonExistent {
1828  StringRef Base, File;
1829  vfs::FileSystem &VFS;
1830 
1831 public:
1832  FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS)
1833  : Base(Base), File(File), VFS(VFS) {}
1834  bool operator()(const Multilib &M) {
1835  return !VFS.exists(Base + M.gccSuffix() + File);
1836  }
1837 };
1838 } // end anonymous namespace
1839 
1840 static void addMultilibFlag(bool Enabled, const char *const Flag,
1841  std::vector<std::string> &Flags) {
1842  if (Enabled)
1843  Flags.push_back(std::string("+") + Flag);
1844  else
1845  Flags.push_back(std::string("-") + Flag);
1846 }
1847 
1848 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
1849  return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1850 }
1851 
1852 static bool isMipsArch(llvm::Triple::ArchType Arch) {
1853  return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1854  Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1855 }
1856 
1857 static bool isMips32(llvm::Triple::ArchType Arch) {
1858  return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1859 }
1860 
1861 static bool isMips64(llvm::Triple::ArchType Arch) {
1862  return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1863 }
1864 
1865 static bool isMipsEL(llvm::Triple::ArchType Arch) {
1866  return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1867 }
1868 
1869 static bool isMips16(const ArgList &Args) {
1870  Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1871  return A && A->getOption().matches(options::OPT_mips16);
1872 }
1873 
1874 static bool isMicroMips(const ArgList &Args) {
1875  Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1876  return A && A->getOption().matches(options::OPT_mmicromips);
1877 }
1878 
1879 namespace {
1880 struct DetectedMultilibs {
1881  /// The set of multilibs that the detected installation supports.
1883 
1884  /// The primary multilib appropriate for the given flags.
1885  Multilib SelectedMultilib;
1886 
1887  /// On Biarch systems, this corresponds to the default multilib when
1888  /// targeting the non-default multilib. Otherwise, it is empty.
1889  llvm::Optional<Multilib> BiarchSibling;
1890 };
1891 } // end anonymous namespace
1892 
1893 static Multilib makeMultilib(StringRef commonSuffix) {
1894  return Multilib(commonSuffix, commonSuffix, commonSuffix);
1895 }
1896 
1898  FilterNonExistent &NonExistent,
1899  DetectedMultilibs &Result) {
1900  // Check for Code Sourcery toolchain multilibs
1901  MultilibSet CSMipsMultilibs;
1902  {
1903  auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
1904 
1905  auto MArchMicroMips =
1906  makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
1907 
1908  auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
1909 
1910  auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1911 
1912  auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
1913 
1914  auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1915 
1916  auto DefaultFloat =
1917  makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
1918 
1919  auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1920 
1921  auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1922 
1923  // Note that this one's osSuffix is ""
1924  auto MAbi64 = makeMultilib("")
1925  .gccSuffix("/64")
1926  .includeSuffix("/64")
1927  .flag("+mabi=n64")
1928  .flag("-mabi=n32")
1929  .flag("-m32");
1930 
1931  CSMipsMultilibs =
1932  MultilibSet()
1933  .Either(MArchMips16, MArchMicroMips, MArchDefault)
1934  .Maybe(UCLibc)
1935  .Either(SoftFloat, Nan2008, DefaultFloat)
1936  .FilterOut("/micromips/nan2008")
1937  .FilterOut("/mips16/nan2008")
1938  .Either(BigEndian, LittleEndian)
1939  .Maybe(MAbi64)
1940  .FilterOut("/mips16.*/64")
1941  .FilterOut("/micromips.*/64")
1942  .FilterOut(NonExistent)
1943  .setIncludeDirsCallback([](const Multilib &M) {
1944  std::vector<std::string> Dirs({"/include"});
1945  if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1946  Dirs.push_back(
1947  "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1948  else
1949  Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1950  return Dirs;
1951  });
1952  }
1953 
1954  MultilibSet DebianMipsMultilibs;
1955  {
1956  Multilib MAbiN32 =
1957  Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1958 
1959  Multilib M64 = Multilib()
1960  .gccSuffix("/64")
1961  .includeSuffix("/64")
1962  .flag("+m64")
1963  .flag("-m32")
1964  .flag("-mabi=n32");
1965 
1966  Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1967 
1968  DebianMipsMultilibs =
1969  MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1970  }
1971 
1972  // Sort candidates. Toolchain that best meets the directories tree goes first.
1973  // Then select the first toolchains matches command line flags.
1974  MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1975  if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1976  std::iter_swap(Candidates, Candidates + 1);
1977  for (const MultilibSet *Candidate : Candidates) {
1978  if (Candidate->select(Flags, Result.SelectedMultilib)) {
1979  if (Candidate == &DebianMipsMultilibs)
1980  Result.BiarchSibling = Multilib();
1981  Result.Multilibs = *Candidate;
1982  return true;
1983  }
1984  }
1985  return false;
1986 }
1987 
1989  FilterNonExistent &NonExistent,
1990  DetectedMultilibs &Result) {
1991 
1992  MultilibSet AndroidMipsMultilibs =
1993  MultilibSet()
1994  .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1995  .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1996  .FilterOut(NonExistent);
1997 
1998  if (AndroidMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1999  Result.Multilibs = AndroidMipsMultilibs;
2000  return true;
2001  }
2002  return false;
2003 }
2004 
2006  FilterNonExistent &NonExistent,
2007  DetectedMultilibs &Result) {
2008  // Musl toolchain multilibs
2009  MultilibSet MuslMipsMultilibs;
2010  {
2011  auto MArchMipsR2 = makeMultilib("")
2012  .osSuffix("/mips-r2-hard-musl")
2013  .flag("+EB")
2014  .flag("-EL")
2015  .flag("+march=mips32r2");
2016 
2017  auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
2018  .flag("-EB")
2019  .flag("+EL")
2020  .flag("+march=mips32r2");
2021 
2022  MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
2023 
2024  // Specify the callback that computes the include directories.
2025  MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
2026  return std::vector<std::string>(
2027  {"/../sysroot" + M.osSuffix() + "/usr/include"});
2028  });
2029  }
2030  if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
2031  Result.Multilibs = MuslMipsMultilibs;
2032  return true;
2033  }
2034  return false;
2035 }
2036 
2038  FilterNonExistent &NonExistent,
2039  DetectedMultilibs &Result) {
2040  // CodeScape MTI toolchain v1.2 and early.
2041  MultilibSet MtiMipsMultilibsV1;
2042  {
2043  auto MArchMips32 = makeMultilib("/mips32")
2044  .flag("+m32")
2045  .flag("-m64")
2046  .flag("-mmicromips")
2047  .flag("+march=mips32");
2048 
2049  auto MArchMicroMips = makeMultilib("/micromips")
2050  .flag("+m32")
2051  .flag("-m64")
2052  .flag("+mmicromips");
2053 
2054  auto MArchMips64r2 = makeMultilib("/mips64r2")
2055  .flag("-m32")
2056  .flag("+m64")
2057  .flag("+march=mips64r2");
2058 
2059  auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
2060  "-march=mips64r2");
2061 
2062  auto MArchDefault = makeMultilib("")
2063  .flag("+m32")
2064  .flag("-m64")
2065  .flag("-mmicromips")
2066  .flag("+march=mips32r2");
2067 
2068  auto Mips16 = makeMultilib("/mips16").flag("+mips16");
2069 
2070  auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
2071 
2072  auto MAbi64 =
2073  makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2074 
2075  auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
2076 
2077  auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2078 
2079  auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
2080 
2081  auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
2082 
2083  MtiMipsMultilibsV1 =
2084  MultilibSet()
2085  .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
2086  MArchDefault)
2087  .Maybe(UCLibc)
2088  .Maybe(Mips16)
2089  .FilterOut("/mips64/mips16")
2090  .FilterOut("/mips64r2/mips16")
2091  .FilterOut("/micromips/mips16")
2092  .Maybe(MAbi64)
2093  .FilterOut("/micromips/64")
2094  .FilterOut("/mips32/64")
2095  .FilterOut("^/64")
2096  .FilterOut("/mips16/64")
2097  .Either(BigEndian, LittleEndian)
2098  .Maybe(SoftFloat)
2099  .Maybe(Nan2008)
2100  .FilterOut(".*sof/nan2008")
2101  .FilterOut(NonExistent)
2102  .setIncludeDirsCallback([](const Multilib &M) {
2103  std::vector<std::string> Dirs({"/include"});
2104  if (StringRef(M.includeSuffix()).startswith("/uclibc"))
2105  Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
2106  else
2107  Dirs.push_back("/../../../../sysroot/usr/include");
2108  return Dirs;
2109  });
2110  }
2111 
2112  // CodeScape IMG toolchain starting from v1.3.
2113  MultilibSet MtiMipsMultilibsV2;
2114  {
2115  auto BeHard = makeMultilib("/mips-r2-hard")
2116  .flag("+EB")
2117  .flag("-msoft-float")
2118  .flag("-mnan=2008")
2119  .flag("-muclibc");
2120  auto BeSoft = makeMultilib("/mips-r2-soft")
2121  .flag("+EB")
2122  .flag("+msoft-float")
2123  .flag("-mnan=2008");
2124  auto ElHard = makeMultilib("/mipsel-r2-hard")
2125  .flag("+EL")
2126  .flag("-msoft-float")
2127  .flag("-mnan=2008")
2128  .flag("-muclibc");
2129  auto ElSoft = makeMultilib("/mipsel-r2-soft")
2130  .flag("+EL")
2131  .flag("+msoft-float")
2132  .flag("-mnan=2008")
2133  .flag("-mmicromips");
2134  auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
2135  .flag("+EB")
2136  .flag("-msoft-float")
2137  .flag("+mnan=2008")
2138  .flag("-muclibc");
2139  auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
2140  .flag("+EL")
2141  .flag("-msoft-float")
2142  .flag("+mnan=2008")
2143  .flag("-muclibc")
2144  .flag("-mmicromips");
2145  auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
2146  .flag("+EB")
2147  .flag("-msoft-float")
2148  .flag("+mnan=2008")
2149  .flag("+muclibc");
2150  auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
2151  .flag("+EL")
2152  .flag("-msoft-float")
2153  .flag("+mnan=2008")
2154  .flag("+muclibc");
2155  auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
2156  .flag("+EB")
2157  .flag("-msoft-float")
2158  .flag("-mnan=2008")
2159  .flag("+muclibc");
2160  auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
2161  .flag("+EL")
2162  .flag("-msoft-float")
2163  .flag("-mnan=2008")
2164  .flag("+muclibc");
2165  auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
2166  .flag("+EL")
2167  .flag("-msoft-float")
2168  .flag("+mnan=2008")
2169  .flag("+mmicromips");
2170  auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
2171  .flag("+EL")
2172  .flag("+msoft-float")
2173  .flag("-mnan=2008")
2174  .flag("+mmicromips");
2175 
2176  auto O32 =
2177  makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2178  auto N32 =
2179  makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2180  auto N64 =
2181  makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2182 
2183  MtiMipsMultilibsV2 =
2184  MultilibSet()
2185  .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
2186  BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
2187  ElHardUclibc, ElMicroHardNan, ElMicroSoft})
2188  .Either(O32, N32, N64)
2189  .FilterOut(NonExistent)
2190  .setIncludeDirsCallback([](const Multilib &M) {
2191  return std::vector<std::string>({"/../../../../sysroot" +
2192  M.includeSuffix() +
2193  "/../usr/include"});
2194  })
2195  .setFilePathsCallback([](const Multilib &M) {
2196  return std::vector<std::string>(
2197  {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
2198  });
2199  }
2200  for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
2201  if (Candidate->select(Flags, Result.SelectedMultilib)) {
2202  Result.Multilibs = *Candidate;
2203  return true;
2204  }
2205  }
2206  return false;
2207 }
2208 
2210  FilterNonExistent &NonExistent,
2211  DetectedMultilibs &Result) {
2212  // CodeScape IMG toolchain v1.2 and early.
2213  MultilibSet ImgMultilibsV1;
2214  {
2215  auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
2216 
2217  auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2218 
2219  auto MAbi64 =
2220  makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2221 
2222  ImgMultilibsV1 =
2223  MultilibSet()
2224  .Maybe(Mips64r6)
2225  .Maybe(MAbi64)
2226  .Maybe(LittleEndian)
2227  .FilterOut(NonExistent)
2228  .setIncludeDirsCallback([](const Multilib &M) {
2229  return std::vector<std::string>(
2230  {"/include", "/../../../../sysroot/usr/include"});
2231  });
2232  }
2233 
2234  // CodeScape IMG toolchain starting from v1.3.
2235  MultilibSet ImgMultilibsV2;
2236  {
2237  auto BeHard = makeMultilib("/mips-r6-hard")
2238  .flag("+EB")
2239  .flag("-msoft-float")
2240  .flag("-mmicromips");
2241  auto BeSoft = makeMultilib("/mips-r6-soft")
2242  .flag("+EB")
2243  .flag("+msoft-float")
2244  .flag("-mmicromips");
2245  auto ElHard = makeMultilib("/mipsel-r6-hard")
2246  .flag("+EL")
2247  .flag("-msoft-float")
2248  .flag("-mmicromips");
2249  auto ElSoft = makeMultilib("/mipsel-r6-soft")
2250  .flag("+EL")
2251  .flag("+msoft-float")
2252  .flag("-mmicromips");
2253  auto BeMicroHard = makeMultilib("/micromips-r6-hard")
2254  .flag("+EB")
2255  .flag("-msoft-float")
2256  .flag("+mmicromips");
2257  auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
2258  .flag("+EB")
2259  .flag("+msoft-float")
2260  .flag("+mmicromips");
2261  auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
2262  .flag("+EL")
2263  .flag("-msoft-float")
2264  .flag("+mmicromips");
2265  auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
2266  .flag("+EL")
2267  .flag("+msoft-float")
2268  .flag("+mmicromips");
2269 
2270  auto O32 =
2271  makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2272  auto N32 =
2273  makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2274  auto N64 =
2275  makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2276 
2277  ImgMultilibsV2 =
2278  MultilibSet()
2279  .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
2280  ElMicroHard, ElMicroSoft})
2281  .Either(O32, N32, N64)
2282  .FilterOut(NonExistent)
2283  .setIncludeDirsCallback([](const Multilib &M) {
2284  return std::vector<std::string>({"/../../../../sysroot" +
2285  M.includeSuffix() +
2286  "/../usr/include"});
2287  })
2288  .setFilePathsCallback([](const Multilib &M) {
2289  return std::vector<std::string>(
2290  {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
2291  });
2292  }
2293  for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
2294  if (Candidate->select(Flags, Result.SelectedMultilib)) {
2295  Result.Multilibs = *Candidate;
2296  return true;
2297  }
2298  }
2299  return false;
2300 }
2301 
2302 static bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
2303  StringRef Path, const ArgList &Args,
2304  DetectedMultilibs &Result) {
2305  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2306 
2307  StringRef CPUName;
2308  StringRef ABIName;
2309  tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
2310 
2311  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2312 
2313  Multilib::flags_list Flags;
2314  addMultilibFlag(isMips32(TargetArch), "m32", Flags);
2315  addMultilibFlag(isMips64(TargetArch), "m64", Flags);
2316  addMultilibFlag(isMips16(Args), "mips16", Flags);
2317  addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
2318  addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
2319  CPUName == "mips32r5" || CPUName == "p5600",
2320  "march=mips32r2", Flags);
2321  addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
2322  addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
2323  addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
2324  CPUName == "mips64r5" || CPUName == "octeon",
2325  "march=mips64r2", Flags);
2326  addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
2327  addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
2328  addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
2329  Flags);
2330  addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
2331  addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
2332  addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
2333  addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
2334  addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
2335  addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
2336 
2337  if (TargetTriple.isAndroid())
2338  return findMipsAndroidMultilibs(Flags, NonExistent, Result);
2339 
2340  if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2341  TargetTriple.getOS() == llvm::Triple::Linux &&
2342  TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2343  return findMipsMuslMultilibs(Flags, NonExistent, Result);
2344 
2345  if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2346  TargetTriple.getOS() == llvm::Triple::Linux &&
2347  TargetTriple.getEnvironment() == llvm::Triple::GNU)
2348  return findMipsMtiMultilibs(Flags, NonExistent, Result);
2349 
2350  if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
2351  TargetTriple.getOS() == llvm::Triple::Linux &&
2352  TargetTriple.getEnvironment() == llvm::Triple::GNU)
2353  return findMipsImgMultilibs(Flags, NonExistent, Result);
2354 
2355  if (findMipsCsMultilibs(Flags, NonExistent, Result))
2356  return true;
2357 
2358  // Fallback to the regular toolchain-tree structure.
2359  Multilib Default;
2360  Result.Multilibs.push_back(Default);
2361  Result.Multilibs.FilterOut(NonExistent);
2362 
2363  if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
2364  Result.BiarchSibling = Multilib();
2365  return true;
2366  }
2367 
2368  return false;
2369 }
2370 
2371 static void findAndroidArmMultilibs(const Driver &D,
2372  const llvm::Triple &TargetTriple,
2373  StringRef Path, const ArgList &Args,
2374  DetectedMultilibs &Result) {
2375  // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
2376  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2377  Multilib ArmV7Multilib = makeMultilib("/armv7-a")
2378  .flag("+armv7")
2379  .flag("-thumb");
2380  Multilib ThumbMultilib = makeMultilib("/thumb")
2381  .flag("-armv7")
2382  .flag("+thumb");
2383  Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
2384  .flag("+armv7")
2385  .flag("+thumb");
2386  Multilib DefaultMultilib = makeMultilib("")
2387  .flag("-armv7")
2388  .flag("-thumb");
2389  MultilibSet AndroidArmMultilibs =
2390  MultilibSet()
2391  .Either(ThumbMultilib, ArmV7Multilib,
2392  ArmV7ThumbMultilib, DefaultMultilib)
2393  .FilterOut(NonExistent);
2394 
2395  Multilib::flags_list Flags;
2396  llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
2397  bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
2398  bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
2399  bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
2400  bool IsThumbMode = IsThumbArch ||
2401  Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
2402  (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB);
2403  bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
2404  (llvm::ARM::parseArchVersion(Arch) == 7 ||
2405  (IsArmArch && Arch == "" && IsV7SubArch));
2406  addMultilibFlag(IsArmV7Mode, "armv7", Flags);
2407  addMultilibFlag(IsThumbMode, "thumb", Flags);
2408 
2409  if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
2410  Result.Multilibs = AndroidArmMultilibs;
2411 }
2412 
2413 static bool findBiarchMultilibs(const Driver &D,
2414  const llvm::Triple &TargetTriple,
2415  StringRef Path, const ArgList &Args,
2416  bool NeedsBiarchSuffix,
2417  DetectedMultilibs &Result) {
2418  // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
2419  // in what would normally be GCCInstallPath and put the 64-bit
2420  // libs in a subdirectory named 64. The simple logic we follow is that
2421  // *if* there is a subdirectory of the right name with crtbegin.o in it,
2422  // we use that. If not, and if not a biarch triple alias, we look for
2423  // crtbegin.o without the subdirectory.
2424 
2425  Multilib Default;
2426  Multilib Alt64 = Multilib()
2427  .gccSuffix("/64")
2428  .includeSuffix("/64")
2429  .flag("-m32")
2430  .flag("+m64")
2431  .flag("-mx32");
2432  Multilib Alt32 = Multilib()
2433  .gccSuffix("/32")
2434  .includeSuffix("/32")
2435  .flag("+m32")
2436  .flag("-m64")
2437  .flag("-mx32");
2438  Multilib Altx32 = Multilib()
2439  .gccSuffix("/x32")
2440  .includeSuffix("/x32")
2441  .flag("-m32")
2442  .flag("-m64")
2443  .flag("+mx32");
2444 
2445  // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
2446  FilterNonExistent NonExistent(
2447  Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
2448 
2449  // Determine default multilib from: 32, 64, x32
2450  // Also handle cases such as 64 on 32, 32 on 64, etc.
2451  enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
2452  const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
2453  if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
2454  Want = WANT64;
2455  else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
2456  Want = WANT64;
2457  else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
2458  Want = WANT32;
2459  else {
2460  if (TargetTriple.isArch32Bit())
2461  Want = NeedsBiarchSuffix ? WANT64 : WANT32;
2462  else if (IsX32)
2463  Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
2464  else
2465  Want = NeedsBiarchSuffix ? WANT32 : WANT64;
2466  }
2467 
2468  if (Want == WANT32)
2469  Default.flag("+m32").flag("-m64").flag("-mx32");
2470  else if (Want == WANT64)
2471  Default.flag("-m32").flag("+m64").flag("-mx32");
2472  else if (Want == WANTX32)
2473  Default.flag("-m32").flag("-m64").flag("+mx32");
2474  else
2475  return false;
2476 
2477  Result.Multilibs.push_back(Default);
2478  Result.Multilibs.push_back(Alt64);
2479  Result.Multilibs.push_back(Alt32);
2480  Result.Multilibs.push_back(Altx32);
2481 
2482  Result.Multilibs.FilterOut(NonExistent);
2483 
2484  Multilib::flags_list Flags;
2485  addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
2486  addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
2487  addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
2488 
2489  if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
2490  return false;
2491 
2492  if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
2493  Result.SelectedMultilib == Altx32)
2494  Result.BiarchSibling = Default;
2495 
2496  return true;
2497 }
2498 
2499 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
2500  const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args,
2501  const std::string &LibDir, StringRef CandidateTriple,
2502  bool NeedsBiarchSuffix) {
2503  // Solaris is a special case. The GCC installation is under
2504  // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we
2505  // need to iterate twice.
2506  std::error_code EC;
2507  for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE;
2508  !EC && LI != LE; LI = LI.increment(EC)) {
2509  StringRef VersionText = llvm::sys::path::filename(LI->getName());
2510  GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2511 
2512  if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2513  if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2514  continue; // Saw this path before; no need to look at it again.
2515  if (CandidateVersion.isOlderThan(4, 1, 1))
2516  continue;
2517  if (CandidateVersion <= Version)
2518  continue;
2519 
2520  GCCInstallPath =
2521  LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str();
2522  if (!D.getVFS().exists(GCCInstallPath))
2523  continue;
2524 
2525  // If we make it here there has to be at least one GCC version, let's just
2526  // use the latest one.
2527  std::error_code EEC;
2529  LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
2530  LLE;
2531  !EEC && LLI != LLE; LLI = LLI.increment(EEC)) {
2532 
2533  StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
2534  GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);
2535 
2536  if (CandidateSubVersion > Version)
2537  Version = CandidateSubVersion;
2538  }
2539 
2540  GCCTriple.setTriple(CandidateTriple);
2541 
2542  GCCInstallPath += "/" + Version.Text;
2543  GCCParentLibPath = GCCInstallPath + "/../../../../";
2544 
2545  IsValid = true;
2546  }
2547 }
2548 
2549 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2550  const llvm::Triple &TargetTriple, const ArgList &Args,
2551  const std::string &LibDir, StringRef CandidateTriple,
2552  bool NeedsBiarchSuffix) {
2553  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2554  // There are various different suffixes involving the triple we
2555  // check for. We also record what is necessary to walk from each back
2556  // up to the lib directory. Specifically, the number of "up" steps
2557  // in the second half of each row is 1 + the number of path separators
2558  // in the first half.
2559  const std::string LibAndInstallSuffixes[][2] = {
2560  {"/gcc/" + CandidateTriple.str(), "/../../.."},
2561 
2562  // Debian puts cross-compilers in gcc-cross
2563  {"/gcc-cross/" + CandidateTriple.str(), "/../../.."},
2564 
2565  {"/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
2566  "/../../../.."},
2567 
2568  // The Freescale PPC SDK has the gcc libraries in
2569  // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
2570  {"/" + CandidateTriple.str(), "/../.."},
2571 
2572  // Ubuntu has a strange mis-matched pair of triples that this happens to
2573  // match.
2574  // FIXME: It may be worthwhile to generalize this and look for a second
2575  // triple.
2576  {"/i386-linux-gnu/gcc/" + CandidateTriple.str(), "/../../../.."}};
2577 
2578  if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2579  scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2580  NeedsBiarchSuffix);
2581  return;
2582  }
2583 
2584  // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
2585  const unsigned NumLibSuffixes = (llvm::array_lengthof(LibAndInstallSuffixes) -
2586  (TargetArch != llvm::Triple::x86));
2587  for (unsigned i = 0; i < NumLibSuffixes; ++i) {
2588  StringRef LibSuffix = LibAndInstallSuffixes[i][0];
2589  std::error_code EC;
2591  LI = D.getVFS().dir_begin(LibDir + LibSuffix, EC),
2592  LE;
2593  !EC && LI != LE; LI = LI.increment(EC)) {
2594  StringRef VersionText = llvm::sys::path::filename(LI->getName());
2595  GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2596  if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2597  if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2598  continue; // Saw this path before; no need to look at it again.
2599  if (CandidateVersion.isOlderThan(4, 1, 1))
2600  continue;
2601  if (CandidateVersion <= Version)
2602  continue;
2603 
2604  DetectedMultilibs Detected;
2605 
2606  // Android standalone toolchain could have multilibs for ARM and Thumb.
2607  // Debian mips multilibs behave more like the rest of the biarch ones,
2608  // so handle them there
2609  if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2610  // It should also work without multilibs in a simplified toolchain.
2611  findAndroidArmMultilibs(D, TargetTriple, LI->getName(), Args, Detected);
2612  } else if (isMipsArch(TargetArch)) {
2613  if (!findMIPSMultilibs(D, TargetTriple, LI->getName(), Args, Detected))
2614  continue;
2615  } else if (!findBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
2616  NeedsBiarchSuffix, Detected)) {
2617  continue;
2618  }
2619 
2620  Multilibs = Detected.Multilibs;
2621  SelectedMultilib = Detected.SelectedMultilib;
2622  BiarchSibling = Detected.BiarchSibling;
2623  Version = CandidateVersion;
2624  GCCTriple.setTriple(CandidateTriple);
2625  // FIXME: We hack together the directory name here instead of
2626  // using LI to ensure stable path separators across Windows and
2627  // Linux.
2628  GCCInstallPath =
2629  LibDir + LibAndInstallSuffixes[i][0] + "/" + VersionText.str();
2630  GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
2631  IsValid = true;
2632  }
2633  }
2634 }
2635 
2636 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2637  const ArgList &Args)
2638  : ToolChain(D, Triple, Args), GCCInstallation(D), CudaInstallation(D) {
2639  getProgramPaths().push_back(getDriver().getInstalledDir());
2640  if (getDriver().getInstalledDir() != getDriver().Dir)
2641  getProgramPaths().push_back(getDriver().Dir);
2642 }
2643 
2645 
2647  switch (AC) {
2649  if (!Preprocess)
2650  Preprocess.reset(new tools::gcc::Preprocessor(*this));
2651  return Preprocess.get();
2653  if (!Compile)
2654  Compile.reset(new tools::gcc::Compiler(*this));
2655  return Compile.get();
2656  default:
2657  return ToolChain::getTool(AC);
2658  }
2659 }
2660 
2662  return new tools::gnutools::Assembler(*this);
2663 }
2664 
2665 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2666 
2667 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2668  // Print the information about how we detected the GCC installation.
2669  GCCInstallation.print(OS);
2670  CudaInstallation.print(OS);
2671 }
2672 
2674  return getArch() == llvm::Triple::x86_64;
2675 }
2676 
2678  return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2679 }
2680 
2681 bool Generic_GCC::isPIEDefault() const { return false; }
2682 
2684  return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2685 }
2686 
2688  switch (getTriple().getArch()) {
2689  case llvm::Triple::x86:
2690  case llvm::Triple::x86_64:
2691  case llvm::Triple::aarch64:
2692  case llvm::Triple::aarch64_be:
2693  case llvm::Triple::arm:
2694  case llvm::Triple::armeb:
2695  case llvm::Triple::bpfel:
2696  case llvm::Triple::bpfeb:
2697  case llvm::Triple::thumb:
2698  case llvm::Triple::thumbeb:
2699  case llvm::Triple::ppc:
2700  case llvm::Triple::ppc64:
2701  case llvm::Triple::ppc64le:
2702  case llvm::Triple::systemz:
2703  case llvm::Triple::mips:
2704  case llvm::Triple::mipsel:
2705  return true;
2706  default:
2707  return false;
2708  }
2709 }
2710 
2711 /// \brief Helper to add the variant paths of a libstdc++ installation.
2713  Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2714  StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2715  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2716  if (!getVFS().exists(Base + Suffix))
2717  return false;
2718 
2719  addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2720 
2721  // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2722  // that path exists or we have neither a GCC nor target multiarch triple, use
2723  // this vanilla search path.
2724  if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2725  getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2726  addSystemInclude(DriverArgs, CC1Args,
2727  Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2728  } else {
2729  // Otherwise try to use multiarch naming schemes which have normalized the
2730  // triples and put the triple before the suffix.
2731  //
2732  // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2733  // the target triple, so we support that here.
2734  addSystemInclude(DriverArgs, CC1Args,
2735  Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2736  addSystemInclude(DriverArgs, CC1Args,
2737  Base + "/" + TargetMultiarchTriple + Suffix);
2738  }
2739 
2740  addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2741  return true;
2742 }
2743 
2744 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2745  ArgStringList &CC1Args) const {
2747  bool UseInitArrayDefault =
2748  getTriple().getArch() == llvm::Triple::aarch64 ||
2749  getTriple().getArch() == llvm::Triple::aarch64_be ||
2750  (getTriple().getOS() == llvm::Triple::Linux &&
2751  (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) ||
2752  getTriple().getOS() == llvm::Triple::NaCl ||
2753  (getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2754  !getTriple().hasEnvironment());
2755 
2756  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2757  options::OPT_fno_use_init_array, UseInitArrayDefault))
2758  CC1Args.push_back("-fuse-init-array");
2759 }
2760 
2761 /// Mips Toolchain
2763  const llvm::Triple &Triple,
2764  const ArgList &Args)
2765  : Linux(D, Triple, Args) {
2766  // Select the correct multilib according to the given arguments.
2767  DetectedMultilibs Result;
2768  findMIPSMultilibs(D, Triple, "", Args, Result);
2769  Multilibs = Result.Multilibs;
2770  SelectedMultilib = Result.SelectedMultilib;
2771 
2772  // Find out the library suffix based on the ABI.
2773  LibSuffix = tools::mips::getMipsABILibSuffix(Args, Triple);
2774  getFilePaths().clear();
2775  getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix);
2776 
2777  // Use LLD by default.
2778  DefaultLinker = "lld";
2779 }
2780 
2782  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2783  if (DriverArgs.hasArg(options::OPT_nostdinc))
2784  return;
2785 
2786  const Driver &D = getDriver();
2787 
2788  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2790  llvm::sys::path::append(P, "include");
2791  addSystemInclude(DriverArgs, CC1Args, P);
2792  }
2793 
2794  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2795  return;
2796 
2797  const auto &Callback = Multilibs.includeDirsCallback();
2798  if (Callback) {
2799  for (const auto &Path : Callback(SelectedMultilib))
2800  addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
2801  D.getInstalledDir() + Path);
2802  }
2803 }
2804 
2806  return new tools::gnutools::Linker(*this);
2807 }
2808 
2810  if (!getDriver().SysRoot.empty())
2811  return getDriver().SysRoot + SelectedMultilib.osSuffix();
2812 
2813  const std::string InstalledDir(getDriver().getInstalledDir());
2814  std::string SysRootPath =
2815  InstalledDir + "/../sysroot" + SelectedMultilib.osSuffix();
2816  if (llvm::sys::fs::exists(SysRootPath))
2817  return SysRootPath;
2818 
2819  return std::string();
2820 }
2821 
2823 MipsLLVMToolChain::GetCXXStdlibType(const ArgList &Args) const {
2824  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2825  if (A) {
2826  StringRef Value = A->getValue();
2827  if (Value != "libc++")
2828  getDriver().Diag(diag::err_drv_invalid_stdlib_name)
2829  << A->getAsString(Args);
2830  }
2831 
2832  return ToolChain::CST_Libcxx;
2833 }
2834 
2836  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2837  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2838  DriverArgs.hasArg(options::OPT_nostdincxx))
2839  return;
2840 
2841  assert((GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) &&
2842  "Only -lc++ (aka libcxx) is suported in this toolchain.");
2843 
2844  const auto &Callback = Multilibs.includeDirsCallback();
2845  if (Callback) {
2846  for (std::string Path : Callback(SelectedMultilib)) {
2847  Path = getDriver().getInstalledDir() + Path + "/c++/v1";
2848  if (llvm::sys::fs::exists(Path)) {
2849  addSystemInclude(DriverArgs, CC1Args, Path);
2850  break;
2851  }
2852  }
2853  }
2854 }
2855 
2857  ArgStringList &CmdArgs) const {
2858  assert((GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) &&
2859  "Only -lc++ (aka libxx) is suported in this toolchain.");
2860 
2861  CmdArgs.push_back("-lc++");
2862  CmdArgs.push_back("-lc++abi");
2863  CmdArgs.push_back("-lunwind");
2864 }
2865 
2866 std::string MipsLLVMToolChain::getCompilerRT(const ArgList &Args,
2867  StringRef Component,
2868  bool Shared) const {
2869  SmallString<128> Path(getDriver().ResourceDir);
2870  llvm::sys::path::append(Path, SelectedMultilib.osSuffix(), "lib" + LibSuffix,
2871  getOS());
2872  llvm::sys::path::append(Path, Twine("libclang_rt." + Component + "-" +
2873  "mips" + (Shared ? ".so" : ".a")));
2874  return Path.str();
2875 }
2876 
2877 /// Hexagon Toolchain
2878 
2880  const std::string &InstalledDir,
2881  const SmallVectorImpl<std::string> &PrefixDirs) const {
2882  std::string InstallRelDir;
2883  const Driver &D = getDriver();
2884 
2885  // Locate the rest of the toolchain ...
2886  for (auto &I : PrefixDirs)
2887  if (D.getVFS().exists(I))
2888  return I;
2889 
2890  if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
2891  return InstallRelDir;
2892 
2893  return InstallRelDir;
2894 }
2895 
2897  const ArgList &Args) {
2898  StringRef Gn = "";
2899  if (Arg *A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
2900  options::OPT_msmall_data_threshold_EQ)) {
2901  Gn = A->getValue();
2902  } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2903  options::OPT_fPIC)) {
2904  Gn = "0";
2905  }
2906 
2907  unsigned G;
2908  if (!Gn.getAsInteger(10, G))
2909  return G;
2910 
2911  return None;
2912 }
2913 
2915  ToolChain::path_list &LibPaths) const {
2916  const Driver &D = getDriver();
2917 
2918  //----------------------------------------------------------------------------
2919  // -L Args
2920  //----------------------------------------------------------------------------
2921  for (Arg *A : Args.filtered(options::OPT_L))
2922  for (const char *Value : A->getValues())
2923  LibPaths.push_back(Value);
2924 
2925  //----------------------------------------------------------------------------
2926  // Other standard paths
2927  //----------------------------------------------------------------------------
2928  std::vector<std::string> RootDirs;
2929  std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
2930  std::back_inserter(RootDirs));
2931 
2932  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2933  D.PrefixDirs);
2934  if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
2935  RootDirs.push_back(TargetDir);
2936 
2937  bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
2938  // Assume G0 with -shared.
2939  bool HasG0 = Args.hasArg(options::OPT_shared);
2940  if (auto G = getSmallDataThreshold(Args))
2941  HasG0 = G.getValue() == 0;
2942 
2943  const std::string CpuVer = GetTargetCPUVersion(Args).str();
2944  for (auto &Dir : RootDirs) {
2945  std::string LibDir = Dir + "/hexagon/lib";
2946  std::string LibDirCpu = LibDir + '/' + CpuVer;
2947  if (HasG0) {
2948  if (HasPIC)
2949  LibPaths.push_back(LibDirCpu + "/G0/pic");
2950  LibPaths.push_back(LibDirCpu + "/G0");
2951  }
2952  LibPaths.push_back(LibDirCpu);
2953  LibPaths.push_back(LibDir);
2954  }
2955 }
2956 
2957 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
2958  const llvm::opt::ArgList &Args)
2959  : Linux(D, Triple, Args) {
2960  const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2961  D.PrefixDirs);
2962 
2963  // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
2964  // program paths
2965  const std::string BinDir(TargetDir + "/bin");
2966  if (D.getVFS().exists(BinDir))
2967  getProgramPaths().push_back(BinDir);
2968 
2969  ToolChain::path_list &LibPaths = getFilePaths();
2970 
2971  // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
2972  // 'elf' OS type, so the Linux paths are not appropriate. When we actually
2973  // support 'linux' we'll need to fix this up
2974  LibPaths.clear();
2975  getHexagonLibraryPaths(Args, LibPaths);
2976 }
2977 
2979 
2981  return new tools::hexagon::Assembler(*this);
2982 }
2983 
2985  return new tools::hexagon::Linker(*this);
2986 }
2987 
2988 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2989  ArgStringList &CC1Args) const {
2990  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2991  DriverArgs.hasArg(options::OPT_nostdlibinc))
2992  return;
2993 
2994  const Driver &D = getDriver();
2995  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2996  D.PrefixDirs);
2997  addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
2998 }
2999 
3001  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
3002  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3003  DriverArgs.hasArg(options::OPT_nostdincxx))
3004  return;
3005 
3006  const Driver &D = getDriver();
3007  std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
3008  addSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include/c++");
3009 }
3010 
3012 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
3013  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
3014  if (!A)
3015  return ToolChain::CST_Libstdcxx;
3016 
3017  StringRef Value = A->getValue();
3018  if (Value != "libstdc++")
3019  getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3020 
3021  return ToolChain::CST_Libstdcxx;
3022 }
3023 
3024 //
3025 // Returns the default CPU for Hexagon. This is the default compilation target
3026 // if no Hexagon processor is selected at the command-line.
3027 //
3029  return "hexagonv60";
3030 }
3031 
3032 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
3033  Arg *CpuArg = nullptr;
3034  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
3035  CpuArg = A;
3036 
3037  StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
3038  if (CPU.startswith("hexagon"))
3039  return CPU.substr(sizeof("hexagon") - 1);
3040  return CPU;
3041 }
3042 // End Hexagon
3043 
3044 /// AMDGPU Toolchain
3045 AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
3046  const ArgList &Args)
3047  : Generic_ELF(D, Triple, Args) { }
3048 
3050  return new tools::amdgpu::Linker(*this);
3051 }
3052 // End AMDGPU
3053 
3054 /// NaCl Toolchain
3055 NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
3056  const ArgList &Args)
3057  : Generic_ELF(D, Triple, Args) {
3058 
3059  // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
3060  // default paths, and must instead only use the paths provided
3061  // with this toolchain based on architecture.
3062  path_list &file_paths = getFilePaths();
3063  path_list &prog_paths = getProgramPaths();
3064 
3065  file_paths.clear();
3066  prog_paths.clear();
3067 
3068  // Path for library files (libc.a, ...)
3069  std::string FilePath(getDriver().Dir + "/../");
3070 
3071  // Path for tools (clang, ld, etc..)
3072  std::string ProgPath(getDriver().Dir + "/../");
3073 
3074  // Path for toolchain libraries (libgcc.a, ...)
3075  std::string ToolPath(getDriver().ResourceDir + "/lib/");
3076 
3077  switch (Triple.getArch()) {
3078  case llvm::Triple::x86:
3079  file_paths.push_back(FilePath + "x86_64-nacl/lib32");
3080  file_paths.push_back(FilePath + "i686-nacl/usr/lib");
3081  prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3082  file_paths.push_back(ToolPath + "i686-nacl");
3083  break;
3084  case llvm::Triple::x86_64:
3085  file_paths.push_back(FilePath + "x86_64-nacl/lib");
3086  file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
3087  prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3088  file_paths.push_back(ToolPath + "x86_64-nacl");
3089  break;
3090  case llvm::Triple::arm:
3091  file_paths.push_back(FilePath + "arm-nacl/lib");
3092  file_paths.push_back(FilePath + "arm-nacl/usr/lib");
3093  prog_paths.push_back(ProgPath + "arm-nacl/bin");
3094  file_paths.push_back(ToolPath + "arm-nacl");
3095  break;
3096  case llvm::Triple::mipsel:
3097  file_paths.push_back(FilePath + "mipsel-nacl/lib");
3098  file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
3099  prog_paths.push_back(ProgPath + "bin");
3100  file_paths.push_back(ToolPath + "mipsel-nacl");
3101  break;
3102  default:
3103  break;
3104  }
3105 
3106  NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
3107 }
3108 
3109 void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
3110  ArgStringList &CC1Args) const {
3111  const Driver &D = getDriver();
3112  if (DriverArgs.hasArg(options::OPT_nostdinc))
3113  return;
3114 
3115  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3117  llvm::sys::path::append(P, "include");
3118  addSystemInclude(DriverArgs, CC1Args, P.str());
3119  }
3120 
3121  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3122  return;
3123 
3124  SmallString<128> P(D.Dir + "/../");
3125  switch (getTriple().getArch()) {
3126  case llvm::Triple::x86:
3127  // x86 is special because multilib style uses x86_64-nacl/include for libc
3128  // headers but the SDK wants i686-nacl/usr/include. The other architectures
3129  // have the same substring.
3130  llvm::sys::path::append(P, "i686-nacl/usr/include");
3131  addSystemInclude(DriverArgs, CC1Args, P.str());
3132  llvm::sys::path::remove_filename(P);
3133  llvm::sys::path::remove_filename(P);
3134  llvm::sys::path::remove_filename(P);
3135  llvm::sys::path::append(P, "x86_64-nacl/include");
3136  addSystemInclude(DriverArgs, CC1Args, P.str());
3137  return;
3138  case llvm::Triple::arm:
3139  llvm::sys::path::append(P, "arm-nacl/usr/include");
3140  break;
3141  case llvm::Triple::x86_64:
3142  llvm::sys::path::append(P, "x86_64-nacl/usr/include");
3143  break;
3144  case llvm::Triple::mipsel:
3145  llvm::sys::path::append(P, "mipsel-nacl/usr/include");
3146  break;
3147  default:
3148  return;
3149  }
3150 
3151  addSystemInclude(DriverArgs, CC1Args, P.str());
3152  llvm::sys::path::remove_filename(P);
3153  llvm::sys::path::remove_filename(P);
3154  llvm::sys::path::append(P, "include");
3155  addSystemInclude(DriverArgs, CC1Args, P.str());
3156 }
3157 
3158 void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
3159  ArgStringList &CmdArgs) const {
3160  // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3161  // if the value is libc++, and emits an error for other values.
3162  GetCXXStdlibType(Args);
3163  CmdArgs.push_back("-lc++");
3164 }
3165 
3166 void NaClToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3167  ArgStringList &CC1Args) const {
3168  const Driver &D = getDriver();
3169  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3170  DriverArgs.hasArg(options::OPT_nostdincxx))
3171  return;
3172 
3173  // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3174  // if the value is libc++, and emits an error for other values.
3175  GetCXXStdlibType(DriverArgs);
3176 
3177  SmallString<128> P(D.Dir + "/../");
3178  switch (getTriple().getArch()) {
3179  case llvm::Triple::arm:
3180  llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
3181  addSystemInclude(DriverArgs, CC1Args, P.str());
3182  break;
3183  case llvm::Triple::x86:
3184  llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3185  addSystemInclude(DriverArgs, CC1Args, P.str());
3186  break;
3187  case llvm::Triple::x86_64:
3188  llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3189  addSystemInclude(DriverArgs, CC1Args, P.str());
3190  break;
3191  case llvm::Triple::mipsel:
3192  llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
3193  addSystemInclude(DriverArgs, CC1Args, P.str());
3194  break;
3195  default:
3196  break;
3197  }
3198 }
3199 
3201 NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
3202  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3203  StringRef Value = A->getValue();
3204  if (Value == "libc++")
3205  return ToolChain::CST_Libcxx;
3206  getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3207  }
3208 
3209  return ToolChain::CST_Libcxx;
3210 }
3211 
3212 std::string
3214  types::ID InputType) const {
3215  llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
3216  if (TheTriple.getArch() == llvm::Triple::arm &&
3217  TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
3218  TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
3219  return TheTriple.getTriple();
3220 }
3221 
3223  return new tools::nacltools::Linker(*this);
3224 }
3225 
3227  if (getTriple().getArch() == llvm::Triple::arm)
3228  return new tools::nacltools::AssemblerARM(*this);
3229  return new tools::gnutools::Assembler(*this);
3230 }
3231 // End NaCl
3232 
3233 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
3234 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
3235 /// Currently does not support anything else but compilation.
3236 
3237 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple,
3238  const ArgList &Args)
3239  : ToolChain(D, Triple, Args) {
3240  // Path mangling to find libexec
3241  std::string Path(getDriver().Dir);
3242 
3243  Path += "/../libexec";
3244  getProgramPaths().push_back(Path);
3245 }
3246 
3248 
3249 bool TCEToolChain::IsMathErrnoDefault() const { return true; }
3250 
3251 bool TCEToolChain::isPICDefault() const { return false; }
3252 
3253 bool TCEToolChain::isPIEDefault() const { return false; }
3254 
3255 bool TCEToolChain::isPICDefaultForced() const { return false; }
3256 
3257 // CloudABI - CloudABI tool chain which can call ld(1) directly.
3258 
3259 CloudABI::CloudABI(const Driver &D, const llvm::Triple &Triple,
3260  const ArgList &Args)
3261  : Generic_ELF(D, Triple, Args) {
3262  SmallString<128> P(getDriver().Dir);
3263  llvm::sys::path::append(P, "..", getTriple().str(), "lib");
3264  getFilePaths().push_back(P.str());
3265 }
3266 
3267 void CloudABI::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3268  ArgStringList &CC1Args) const {
3269  if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
3270  DriverArgs.hasArg(options::OPT_nostdincxx))
3271  return;
3272 
3273  SmallString<128> P(getDriver().Dir);
3274  llvm::sys::path::append(P, "..", getTriple().str(), "include/c++/v1");
3275  addSystemInclude(DriverArgs, CC1Args, P.str());
3276 }
3277 
3278 void CloudABI::AddCXXStdlibLibArgs(const ArgList &Args,
3279  ArgStringList &CmdArgs) const {
3280  CmdArgs.push_back("-lc++");
3281  CmdArgs.push_back("-lc++abi");
3282  CmdArgs.push_back("-lunwind");
3283 }
3284 
3286  return new tools::cloudabi::Linker(*this);
3287 }
3288 
3290  // Only enable PIE on architectures that support PC-relative
3291  // addressing. PC-relative addressing is required, as the process
3292  // startup code must be able to relocate itself.
3293  switch (getTriple().getArch()) {
3294  case llvm::Triple::aarch64:
3295  case llvm::Triple::x86_64:
3296  return true;
3297  default:
3298  return false;
3299  }
3300 }
3301 
3304  Res |= SanitizerKind::SafeStack;
3305  return Res;
3306 }
3307 
3309  return SanitizerKind::SafeStack;
3310 }
3311 
3312 /// Haiku - Haiku tool chain which can call as(1) and ld(1) directly.
3313 
3314 Haiku::Haiku(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
3315  : Generic_ELF(D, Triple, Args) {
3316 
3317 }
3318 
3319 void Haiku::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3320  ArgStringList &CC1Args) const {
3321  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3322  DriverArgs.hasArg(options::OPT_nostdincxx))
3323  return;
3324 
3325  switch (GetCXXStdlibType(DriverArgs)) {
3326  case ToolChain::CST_Libcxx:
3327  addSystemInclude(DriverArgs, CC1Args,
3328  getDriver().SysRoot + "/system/develop/headers/c++/v1");
3329  break;
3331  addSystemInclude(DriverArgs, CC1Args,
3332  getDriver().SysRoot + "/system/develop/headers/c++");
3333  addSystemInclude(DriverArgs, CC1Args,
3334  getDriver().SysRoot + "/system/develop/headers/c++/backward");
3335 
3336  StringRef Triple = getTriple().str();
3337  addSystemInclude(DriverArgs, CC1Args,
3338  getDriver().SysRoot + "/system/develop/headers/c++/" +
3339  Triple);
3340  break;
3341  }
3342 }
3343 
3344 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
3345 
3346 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple,
3347  const ArgList &Args)
3348  : Generic_ELF(D, Triple, Args) {
3349  getFilePaths().push_back(getDriver().Dir + "/../lib");
3350  getFilePaths().push_back("/usr/lib");
3351 }
3352 
3354  return new tools::openbsd::Assembler(*this);
3355 }
3356 
3357 Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); }
3358 
3359 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
3360 
3361 Bitrig::Bitrig(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3362  : Generic_ELF(D, Triple, Args) {
3363  getFilePaths().push_back(getDriver().Dir + "/../lib");
3364  getFilePaths().push_back("/usr/lib");
3365 }
3366 
3368  return new tools::bitrig::Assembler(*this);
3369 }
3370 
3371 Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); }
3372 
3374  return ToolChain::CST_Libcxx;
3375 }
3376 
3377 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3378  ArgStringList &CC1Args) const {
3379  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3380  DriverArgs.hasArg(options::OPT_nostdincxx))
3381  return;
3382 
3383  switch (GetCXXStdlibType(DriverArgs)) {
3384  case ToolChain::CST_Libcxx:
3385  addSystemInclude(DriverArgs, CC1Args,
3386  getDriver().SysRoot + "/usr/include/c++/v1");
3387  break;
3389  addSystemInclude(DriverArgs, CC1Args,
3390  getDriver().SysRoot + "/usr/include/c++/stdc++");
3391  addSystemInclude(DriverArgs, CC1Args,
3392  getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
3393 
3394  StringRef Triple = getTriple().str();
3395  if (Triple.startswith("amd64"))
3396  addSystemInclude(DriverArgs, CC1Args,
3397  getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
3398  Triple.substr(5));
3399  else
3400  addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot +
3401  "/usr/include/c++/stdc++/" +
3402  Triple);
3403  break;
3404  }
3405 }
3406 
3407 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
3408  ArgStringList &CmdArgs) const {
3409  switch (GetCXXStdlibType(Args)) {
3410  case ToolChain::CST_Libcxx:
3411  CmdArgs.push_back("-lc++");
3412  CmdArgs.push_back("-lc++abi");
3413  CmdArgs.push_back("-lpthread");
3414  break;
3416  CmdArgs.push_back("-lstdc++");
3417  break;
3418  }
3419 }
3420 
3421 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
3422 
3423 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
3424  const ArgList &Args)
3425  : Generic_ELF(D, Triple, Args) {
3426 
3427  // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
3428  // back to '/usr/lib' if it doesn't exist.
3429  if ((Triple.getArch() == llvm::Triple::x86 ||
3430  Triple.getArch() == llvm::Triple::ppc) &&
3431  D.getVFS().exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
3432  getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
3433  else
3434  getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
3435 }
3436 
3438  if (getTriple().getOSMajorVersion() >= 10)
3439  return ToolChain::CST_Libcxx;
3440  return ToolChain::CST_Libstdcxx;
3441 }
3442 
3443 void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3444  ArgStringList &CC1Args) const {
3445  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3446  DriverArgs.hasArg(options::OPT_nostdincxx))
3447  return;
3448 
3449  switch (GetCXXStdlibType(DriverArgs)) {
3450  case ToolChain::CST_Libcxx:
3451  addSystemInclude(DriverArgs, CC1Args,
3452  getDriver().SysRoot + "/usr/include/c++/v1");
3453  break;
3455  addSystemInclude(DriverArgs, CC1Args,
3456  getDriver().SysRoot + "/usr/include/c++/4.2");
3457  addSystemInclude(DriverArgs, CC1Args,
3458  getDriver().SysRoot + "/usr/include/c++/4.2/backward");
3459  break;
3460  }
3461 }
3462 
3463 void FreeBSD::AddCXXStdlibLibArgs(const ArgList &Args,
3464  ArgStringList &CmdArgs) const {
3466  bool Profiling = Args.hasArg(options::OPT_pg);
3467 
3468  switch (Type) {
3469  case ToolChain::CST_Libcxx:
3470  CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");
3471  break;
3472 
3474  CmdArgs.push_back(Profiling ? "-lstdc++_p" : "-lstdc++");
3475  break;
3476  }
3477 }
3478 
3480  return new tools::freebsd::Assembler(*this);
3481 }
3482 
3483 Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
3484 
3485 bool FreeBSD::UseSjLjExceptions(const ArgList &Args) const {
3486  // FreeBSD uses SjLj exceptions on ARM oabi.
3487  switch (getTriple().getEnvironment()) {
3488  case llvm::Triple::GNUEABIHF:
3489  case llvm::Triple::GNUEABI:
3490  case llvm::Triple::EABI:
3491  return false;
3492 
3493  default:
3494  return (getTriple().getArch() == llvm::Triple::arm ||
3495  getTriple().getArch() == llvm::Triple::thumb);
3496  }
3497 }
3498 
3499 bool FreeBSD::HasNativeLLVMSupport() const { return true; }
3500 
3502 
3504  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
3505  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3506  const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
3507  getTriple().getArch() == llvm::Triple::mips64el;
3509  Res |= SanitizerKind::Address;
3510  Res |= SanitizerKind::Vptr;
3511  if (IsX86_64 || IsMIPS64) {
3512  Res |= SanitizerKind::Leak;
3513  Res |= SanitizerKind::Thread;
3514  }
3515  if (IsX86 || IsX86_64) {
3516  Res |= SanitizerKind::SafeStack;
3517  }
3518  return Res;
3519 }
3520 
3521 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
3522 
3523 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3524  : Generic_ELF(D, Triple, Args) {
3525  if (getDriver().UseStdLib) {
3526  // When targeting a 32-bit platform, try the special directory used on
3527  // 64-bit hosts, and only fall back to the main library directory if that
3528  // doesn't work.
3529  // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
3530  // what all logic is needed to emulate the '=' prefix here.
3531  switch (Triple.getArch()) {
3532  case llvm::Triple::x86:
3533  getFilePaths().push_back("=/usr/lib/i386");
3534  break;
3535  case llvm::Triple::arm:
3536  case llvm::Triple::armeb:
3537  case llvm::Triple::thumb:
3538  case llvm::Triple::thumbeb:
3539  switch (Triple.getEnvironment()) {
3540  case llvm::Triple::EABI:
3541  case llvm::Triple::GNUEABI:
3542  getFilePaths().push_back("=/usr/lib/eabi");
3543  break;
3544  case llvm::Triple::EABIHF:
3545  case llvm::Triple::GNUEABIHF:
3546  getFilePaths().push_back("=/usr/lib/eabihf");
3547  break;
3548  default:
3549  getFilePaths().push_back("=/usr/lib/oabi");
3550  break;
3551  }
3552  break;
3553  case llvm::Triple::mips64:
3554  case llvm::Triple::mips64el:
3555  if (tools::mips::hasMipsAbiArg(Args, "o32"))
3556  getFilePaths().push_back("=/usr/lib/o32");
3557  else if (tools::mips::hasMipsAbiArg(Args, "64"))
3558  getFilePaths().push_back("=/usr/lib/64");
3559  break;
3560  case llvm::Triple::ppc:
3561  getFilePaths().push_back("=/usr/lib/powerpc");
3562  break;
3563  case llvm::Triple::sparc:
3564  getFilePaths().push_back("=/usr/lib/sparc");
3565  break;
3566  default:
3567  break;
3568  }
3569 
3570  getFilePaths().push_back("=/usr/lib");
3571  }
3572 }
3573 
3575  return new tools::netbsd::Assembler(*this);
3576 }
3577 
3578 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
3579 
3581  unsigned Major, Minor, Micro;
3582  getTriple().getOSVersion(Major, Minor, Micro);
3583  if (Major >= 7 || Major == 0) {
3584  switch (getArch()) {
3585  case llvm::Triple::aarch64:
3586  case llvm::Triple::arm:
3587  case llvm::Triple::armeb:
3588  case llvm::Triple::thumb:
3589  case llvm::Triple::thumbeb:
3590  case llvm::Triple::ppc:
3591  case llvm::Triple::ppc64:
3592  case llvm::Triple::ppc64le:
3593  case llvm::Triple::sparc:
3594  case llvm::Triple::sparcv9:
3595  case llvm::Triple::x86:
3596  case llvm::Triple::x86_64:
3597  return ToolChain::CST_Libcxx;
3598  default:
3599  break;
3600  }
3601  }
3602  return ToolChain::CST_Libstdcxx;
3603 }
3604 
3605 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3606  ArgStringList &CC1Args) const {
3607  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3608  DriverArgs.hasArg(options::OPT_nostdincxx))
3609  return;
3610 
3611  switch (GetCXXStdlibType(DriverArgs)) {
3612  case ToolChain::CST_Libcxx:
3613  addSystemInclude(DriverArgs, CC1Args,
3614  getDriver().SysRoot + "/usr/include/c++/");
3615  break;
3617  addSystemInclude(DriverArgs, CC1Args,
3618  getDriver().SysRoot + "/usr/include/g++");
3619  addSystemInclude(DriverArgs, CC1Args,
3620  getDriver().SysRoot + "/usr/include/g++/backward");
3621  break;
3622  }
3623 }
3624 
3625 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
3626 
3627 Minix::Minix(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3628  : Generic_ELF(D, Triple, Args) {
3629  getFilePaths().push_back(getDriver().Dir + "/../lib");
3630  getFilePaths().push_back("/usr/lib");
3631 }
3632 
3634  return new tools::minix::Assembler(*this);
3635 }
3636 
3637 Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); }
3638 
3639 static void addPathIfExists(const Driver &D, const Twine &Path,
3640  ToolChain::path_list &Paths) {
3641  if (D.getVFS().exists(Path))
3642  Paths.push_back(Path.str());
3643 }
3644 
3645 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
3646 
3647 Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
3648  const ArgList &Args)
3649  : Generic_GCC(D, Triple, Args) {
3650 
3651  GCCInstallation.init(Triple, Args);
3652 
3653  path_list &Paths = getFilePaths();
3654  if (GCCInstallation.isValid())
3656 
3657  addPathIfExists(D, getDriver().getInstalledDir(), Paths);
3658  if (getDriver().getInstalledDir() != getDriver().Dir)
3659  addPathIfExists(D, getDriver().Dir, Paths);
3660 
3661  addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);
3662 
3663  std::string LibPath = "/usr/lib/";
3664  switch (Triple.getArch()) {
3665  case llvm::Triple::x86:
3666  case llvm::Triple::sparc:
3667  break;
3668  case llvm::Triple::x86_64:
3669  LibPath += "amd64/";
3670  break;
3671  case llvm::Triple::sparcv9:
3672  LibPath += "sparcv9/";
3673  break;
3674  default:
3675  llvm_unreachable("Unsupported architecture");
3676  }
3677 
3678  addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);
3679 }
3680 
3682  return new tools::solaris::Assembler(*this);
3683 }
3684 
3685 Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
3686 
3687 void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3688  ArgStringList &CC1Args) const {
3689  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3690  DriverArgs.hasArg(options::OPT_nostdincxx))
3691  return;
3692 
3693  // Include the support directory for things like xlocale and fudged system
3694  // headers.
3695  addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");
3696 
3697  if (GCCInstallation.isValid()) {
3699  addSystemInclude(DriverArgs, CC1Args,
3700  getDriver().SysRoot + "/usr/gcc/" +
3701  Version.MajorStr + "." +
3702  Version.MinorStr +
3703  "/include/c++/" + Version.Text);
3704  addSystemInclude(DriverArgs, CC1Args,
3705  getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
3706  "." + Version.MinorStr + "/include/c++/" +
3707  Version.Text + "/" +
3708  GCCInstallation.getTriple().str());
3709  }
3710 }
3711 
3712 /// Distribution (very bare-bones at the moment).
3713 
3714 enum Distro {
3715  // NB: Releases of a particular Linux distro should be kept together
3716  // in this enum, because some tests are done by integer comparison against
3717  // the first and last known member in the family, e.g. IsRedHat().
3748 };
3749 
3750 static bool IsRedhat(enum Distro Distro) {
3751  return Distro == Fedora || (Distro >= RHEL5 && Distro <= RHEL7);
3752 }
3753 
3754 static bool IsOpenSUSE(enum Distro Distro) { return Distro == OpenSUSE; }
3755 
3756 static bool IsDebian(enum Distro Distro) {
3757  return Distro >= DebianLenny && Distro <= DebianStretch;
3758 }
3759 
3760 static bool IsUbuntu(enum Distro Distro) {
3761  return Distro >= UbuntuHardy && Distro <= UbuntuXenial;
3762 }
3763 
3764 static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch) {
3765  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3766  llvm::MemoryBuffer::getFile("/etc/lsb-release");
3767  if (File) {
3768  StringRef Data = File.get()->getBuffer();
3770  Data.split(Lines, "\n");
3771  Distro Version = UnknownDistro;
3772  for (StringRef Line : Lines)
3773  if (Version == UnknownDistro && Line.startswith("DISTRIB_CODENAME="))
3774  Version = llvm::StringSwitch<Distro>(Line.substr(17))
3775  .Case("hardy", UbuntuHardy)
3776  .Case("intrepid", UbuntuIntrepid)
3777  .Case("jaunty", UbuntuJaunty)
3778  .Case("karmic", UbuntuKarmic)
3779  .Case("lucid", UbuntuLucid)
3780  .Case("maverick", UbuntuMaverick)
3781  .Case("natty", UbuntuNatty)
3782  .Case("oneiric", UbuntuOneiric)
3783  .Case("precise", UbuntuPrecise)
3784  .Case("quantal", UbuntuQuantal)
3785  .Case("raring", UbuntuRaring)
3786  .Case("saucy", UbuntuSaucy)
3787  .Case("trusty", UbuntuTrusty)
3788  .Case("utopic", UbuntuUtopic)
3789  .Case("vivid", UbuntuVivid)
3790  .Case("wily", UbuntuWily)
3791  .Case("xenial", UbuntuXenial)
3792  .Default(UnknownDistro);
3793  if (Version != UnknownDistro)
3794  return Version;
3795  }
3796 
3797  File = llvm::MemoryBuffer::getFile("/etc/redhat-release");
3798  if (File) {
3799  StringRef Data = File.get()->getBuffer();
3800  if (Data.startswith("Fedora release"))
3801  return Fedora;
3802  if (Data.startswith("Red Hat Enterprise Linux") ||
3803  Data.startswith("CentOS") ||
3804  Data.startswith("Scientific Linux")) {
3805  if (Data.find("release 7") != StringRef::npos)
3806  return RHEL7;
3807  else if (Data.find("release 6") != StringRef::npos)
3808  return RHEL6;
3809  else if (Data.find("release 5") != StringRef::npos)
3810  return RHEL5;
3811  }
3812  return UnknownDistro;
3813  }
3814 
3815  File = llvm::MemoryBuffer::getFile("/etc/debian_version");
3816  if (File) {
3817  StringRef Data = File.get()->getBuffer();
3818  if (Data[0] == '5')
3819  return DebianLenny;
3820  else if (Data.startswith("squeeze/sid") || Data[0] == '6')
3821  return DebianSqueeze;
3822  else if (Data.startswith("wheezy/sid") || Data[0] == '7')
3823  return DebianWheezy;
3824  else if (Data.startswith("jessie/sid") || Data[0] == '8')
3825  return DebianJessie;
3826  else if (Data.startswith("stretch/sid") || Data[0] == '9')
3827  return DebianStretch;
3828  return UnknownDistro;
3829  }
3830 
3831  if (D.getVFS().exists("/etc/SuSE-release"))
3832  return OpenSUSE;
3833 
3834  if (D.getVFS().exists("/etc/exherbo-release"))
3835  return Exherbo;
3836 
3837  if (D.getVFS().exists("/etc/arch-release"))
3838  return ArchLinux;
3839 
3840  return UnknownDistro;
3841 }
3842 
3843 /// \brief Get our best guess at the multiarch triple for a target.
3844 ///
3845 /// Debian-based systems are starting to use a multiarch setup where they use
3846 /// a target-triple directory in the library and header search paths.
3847 /// Unfortunately, this triple does not align with the vanilla target triple,
3848 /// so we provide a rough mapping here.
3849 static std::string getMultiarchTriple(const Driver &D,
3850  const llvm::Triple &TargetTriple,
3851  StringRef SysRoot) {
3852  llvm::Triple::EnvironmentType TargetEnvironment =
3853  TargetTriple.getEnvironment();
3854 
3855  // For most architectures, just use whatever we have rather than trying to be
3856  // clever.
3857  switch (TargetTriple.getArch()) {
3858  default:
3859  break;
3860 
3861  // We use the existence of '/lib/<triple>' as a directory to detect some
3862  // common linux triples that don't quite match the Clang triple for both
3863  // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
3864  // regardless of what the actual target triple is.
3865  case llvm::Triple::arm:
3866  case llvm::Triple::thumb:
3867  if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3868  if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))
3869  return "arm-linux-gnueabihf";
3870  } else {
3871  if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))
3872  return "arm-linux-gnueabi";
3873  }
3874  break;
3875  case llvm::Triple::armeb:
3876  case llvm::Triple::thumbeb:
3877  if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3878  if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))
3879  return "armeb-linux-gnueabihf";
3880  } else {
3881  if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))
3882  return "armeb-linux-gnueabi";
3883  }
3884  break;
3885  case llvm::Triple::x86:
3886  if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))
3887  return "i386-linux-gnu";
3888  break;
3889  case llvm::Triple::x86_64:
3890  // We don't want this for x32, otherwise it will match x86_64 libs
3891  if (TargetEnvironment != llvm::Triple::GNUX32 &&
3892  D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu"))
3893  return "x86_64-linux-gnu";
3894  break;
3895  case llvm::Triple::aarch64:
3896  if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))
3897  return "aarch64-linux-gnu";
3898  break;
3899  case llvm::Triple::aarch64_be:
3900  if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))
3901  return "aarch64_be-linux-gnu";
3902  break;
3903  case llvm::Triple::mips:
3904  if (D.getVFS().exists(SysRoot + "/lib/mips-linux-gnu"))
3905  return "mips-linux-gnu";
3906  break;
3907  case llvm::Triple::mipsel:
3908  if (D.getVFS().exists(SysRoot + "/lib/mipsel-linux-gnu"))
3909  return "mipsel-linux-gnu";
3910  break;
3911  case llvm::Triple::mips64:
3912  if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
3913  return "mips64-linux-gnu";
3914  if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnuabi64"))
3915  return "mips64-linux-gnuabi64";
3916  break;
3917  case llvm::Triple::mips64el:
3918  if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
3919  return "mips64el-linux-gnu";
3920  if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnuabi64"))
3921  return "mips64el-linux-gnuabi64";
3922  break;
3923  case llvm::Triple::ppc:
3924  if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
3925  return "powerpc-linux-gnuspe";
3926  if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))
3927  return "powerpc-linux-gnu";
3928  break;
3929  case llvm::Triple::ppc64:
3930  if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))
3931  return "powerpc64-linux-gnu";
3932  break;
3933  case llvm::Triple::ppc64le:
3934  if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
3935  return "powerpc64le-linux-gnu";
3936  break;
3937  case llvm::Triple::sparc:
3938  if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))
3939  return "sparc-linux-gnu";
3940  break;
3941  case llvm::Triple::sparcv9:
3942  if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))
3943  return "sparc64-linux-gnu";
3944  break;
3945  case llvm::Triple::systemz:
3946  if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))
3947  return "s390x-linux-gnu";
3948  break;
3949  }
3950  return TargetTriple.str();
3951 }
3952 
3953 static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
3954  if (isMipsArch(Triple.getArch())) {
3955  // lib32 directory has a special meaning on MIPS targets.
3956  // It contains N32 ABI binaries. Use this folder if produce
3957  // code for N32 ABI only.
3958  if (tools::mips::hasMipsAbiArg(Args, "n32"))
3959  return "lib32";
3960  return Triple.isArch32Bit() ? "lib" : "lib64";
3961  }
3962 
3963  // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
3964  // using that variant while targeting other architectures causes problems
3965  // because the libraries are laid out in shared system roots that can't cope
3966  // with a 'lib32' library search path being considered. So we only enable
3967  // them when we know we may need it.
3968  //
3969  // FIXME: This is a bit of a hack. We should really unify this code for
3970  // reasoning about oslibdir spellings with the lib dir spellings in the
3971  // GCCInstallationDetector, but that is a more significant refactoring.
3972  if (Triple.getArch() == llvm::Triple::x86 ||
3973  Triple.getArch() == llvm::Triple::ppc)
3974  return "lib32";
3975 
3976  if (Triple.getArch() == llvm::Triple::x86_64 &&
3977  Triple.getEnvironment() == llvm::Triple::GNUX32)
3978  return "libx32";
3979 
3980  return Triple.isArch32Bit() ? "lib" : "lib64";
3981 }
3982 
3983 static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
3984  const Multilib &Multilib,
3985  StringRef InstallPath,
3986  ToolChain::path_list &Paths) {
3987  if (const auto &PathsCallback = Multilibs.filePathsCallback())
3988  for (const auto &Path : PathsCallback(Multilib))
3989  addPathIfExists(D, InstallPath + Path, Paths);
3990 }
3991 
3992 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3993  : Generic_ELF(D, Triple, Args) {
3994  GCCInstallation.init(Triple, Args);
3995  CudaInstallation.init(Triple, Args);
3997  llvm::Triple::ArchType Arch = Triple.getArch();
3998  std::string SysRoot = computeSysRoot();
3999 
4000  // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
4001  // least) put various tools in a triple-prefixed directory off of the parent
4002  // of the GCC installation. We use the GCC triple here to ensure that we end
4003  // up with tools that support the same amount of cross compiling as the
4004  // detected GCC installation. For example, if we find a GCC installation
4005  // targeting x86_64, but it is a bi-arch GCC installation, it can also be
4006  // used to target i386.
4007  // FIXME: This seems unlikely to be Linux-specific.
4009  PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
4010  GCCInstallation.getTriple().str() + "/bin")
4011  .str());
4012 
4013  Distro Distro = DetectDistro(D, Arch);
4014 
4015  if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
4016  ExtraOpts.push_back("-z");
4017  ExtraOpts.push_back("relro");
4018  }
4019 
4020  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
4021  ExtraOpts.push_back("-X");
4022 
4023  const bool IsAndroid = Triple.isAndroid();
4024  const bool IsMips = isMipsArch(Arch);
4025 
4026  if (IsMips && !SysRoot.empty())
4027  ExtraOpts.push_back("--sysroot=" + SysRoot);
4028 
4029  // Do not use 'gnu' hash style for Mips targets because .gnu.hash
4030  // and the MIPS ABI require .dynsym to be sorted in different ways.
4031  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
4032  // ABI requires a mapping between the GOT and the symbol table.
4033  // Android loader does not support .gnu.hash.
4034  if (!IsMips && !IsAndroid) {
4035  if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
4036  (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
4037  ExtraOpts.push_back("--hash-style=gnu");
4038 
4039  if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
4040  Distro == UbuntuJaunty || Distro == UbuntuKarmic)
4041  ExtraOpts.push_back("--hash-style=both");
4042  }
4043 
4044  if (IsRedhat(Distro) && Distro != RHEL5 && Distro != RHEL6)
4045  ExtraOpts.push_back("--no-add-needed");
4046 
4047 #ifdef ENABLE_LINKER_BUILD_ID
4048  ExtraOpts.push_back("--build-id");
4049 #endif
4050 
4051  if (IsOpenSUSE(Distro))
4052  ExtraOpts.push_back("--enable-new-dtags");
4053 
4054  // The selection of paths to try here is designed to match the patterns which
4055  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
4056  // This was determined by running GCC in a fake filesystem, creating all
4057  // possible permutations of these directories, and seeing which ones it added
4058  // to the link paths.
4059  path_list &Paths = getFilePaths();
4060 
4061  const std::string OSLibDir = getOSLibDir(Triple, Args);
4062  const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
4063 
4064  // Add the multilib suffixed paths where they are available.
4065  if (GCCInstallation.isValid()) {
4066  const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4067  const std::string &LibPath = GCCInstallation.getParentLibPath();
4070 
4071  // Add toolchain / multilib specific file paths.
4072  addMultilibsFilePaths(D, Multilibs, Multilib,
4073  GCCInstallation.getInstallPath(), Paths);
4074 
4075  // Sourcery CodeBench MIPS toolchain holds some libraries under
4076  // a biarch-like suffix of the GCC installation.
4078  Paths);
4079 
4080  // GCC cross compiling toolchains will install target libraries which ship
4081  // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
4082  // any part of the GCC installation in
4083  // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
4084  // debatable, but is the reality today. We need to search this tree even
4085  // when we have a sysroot somewhere else. It is the responsibility of
4086  // whomever is doing the cross build targeting a sysroot using a GCC
4087  // installation that is *not* within the system root to ensure two things:
4088  //
4089  // 1) Any DSOs that are linked in from this tree or from the install path
4090  // above must be present on the system root and found via an
4091  // appropriate rpath.
4092  // 2) There must not be libraries installed into
4093  // <prefix>/<triple>/<libdir> unless they should be preferred over
4094  // those within the system root.
4095  //
4096  // Note that this matches the GCC behavior. See the below comment for where
4097  // Clang diverges from GCC's behavior.
4098  addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
4099  OSLibDir + Multilib.osSuffix(),
4100  Paths);
4101 
4102  // If the GCC installation we found is inside of the sysroot, we want to
4103  // prefer libraries installed in the parent prefix of the GCC installation.
4104  // It is important to *not* use these paths when the GCC installation is
4105  // outside of the system root as that can pick up unintended libraries.
4106  // This usually happens when there is an external cross compiler on the
4107  // host system, and a more minimal sysroot available that is the target of
4108  // the cross. Note that GCC does include some of these directories in some
4109  // configurations but this seems somewhere between questionable and simply
4110  // a bug.
4111  if (StringRef(LibPath).startswith(SysRoot)) {
4112  addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
4113  addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
4114  }
4115  }
4116 
4117  // Similar to the logic for GCC above, if we currently running Clang inside
4118  // of the requested system root, add its parent library paths to
4119  // those searched.
4120  // FIXME: It's not clear whether we should use the driver's installed
4121  // directory ('Dir' below) or the ResourceDir.
4122  if (StringRef(D.Dir).startswith(SysRoot)) {
4123  addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
4124  addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
4125  }
4126 
4127  addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
4128  addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
4129  addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
4130  addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
4131 
4132  // Try walking via the GCC triple path in case of biarch or multiarch GCC
4133  // installations with strange symlinks.
4134  if (GCCInstallation.isValid()) {
4135  addPathIfExists(D,
4136  SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
4137  "/../../" + OSLibDir,
4138  Paths);
4139 
4140  // Add the 'other' biarch variant path
4141  Multilib BiarchSibling;
4142  if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
4144  BiarchSibling.gccSuffix(),
4145  Paths);
4146  }
4147 
4148  // See comments above on the multilib variant for details of why this is
4149  // included even from outside the sysroot.
4150  const std::string &LibPath = GCCInstallation.getParentLibPath();
4151  const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4153  addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
4154  Multilib.osSuffix(),
4155  Paths);
4156 
4157  // See comments above on the multilib variant for details of why this is
4158  // only included from within the sysroot.
4159  if (StringRef(LibPath).startswith(SysRoot))
4160  addPathIfExists(D, LibPath, Paths);
4161  }
4162 
4163  // Similar to the logic for GCC above, if we are currently running Clang
4164  // inside of the requested system root, add its parent library path to those
4165  // searched.
4166  // FIXME: It's not clear whether we should use the driver's installed
4167  // directory ('Dir' below) or the ResourceDir.
4168  if (StringRef(D.Dir).startswith(SysRoot))
4169  addPathIfExists(D, D.Dir + "/../lib", Paths);
4170 
4171  addPathIfExists(D, SysRoot + "/lib", Paths);
4172  addPathIfExists(D, SysRoot + "/usr/lib", Paths);
4173 }
4174 
4175 bool Linux::HasNativeLLVMSupport() const { return true; }
4176 
4177 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
4178 
4180  return new tools::gnutools::Assembler(*this);
4181 }
4182 
4183 std::string Linux::computeSysRoot() const {
4184  if (!getDriver().SysRoot.empty())
4185  return getDriver().SysRoot;
4186 
4188  return std::string();
4189 
4190  // Standalone MIPS toolchains use different names for sysroot folder
4191  // and put it into different places. Here we try to check some known
4192  // variants.
4193 
4194  const StringRef InstallDir = GCCInstallation.getInstallPath();
4195  const StringRef TripleStr = GCCInstallation.getTriple().str();
4197 
4198  std::string Path =
4199  (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
4200  .str();
4201 
4202  if (getVFS().exists(Path))
4203  return Path;
4204 
4205  Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
4206 
4207  if (getVFS().exists(Path))
4208  return Path;
4209 
4210  return std::string();
4211 }
4212 
4213 std::string Linux::getDynamicLinker(const ArgList &Args) const {
4214  const llvm::Triple::ArchType Arch = getArch();
4215  const llvm::Triple &Triple = getTriple();
4216 
4217  const enum Distro Distro = DetectDistro(getDriver(), Arch);
4218 
4219  if (Triple.isAndroid())
4220  return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
4221  else if (Triple.isMusl()) {
4222  std::string ArchName;
4223  switch (Arch) {
4224  case llvm::Triple::thumb:
4225  ArchName = "arm";
4226  break;
4227  case llvm::Triple::thumbeb:
4228  ArchName = "armeb";
4229  break;
4230  default:
4231  ArchName = Triple.getArchName().str();
4232  }
4233  if (Triple.getEnvironment() == llvm::Triple::MuslEABIHF)
4234  ArchName += "hf";
4235 
4236  return "/lib/ld-musl-" + ArchName + ".so.1";
4237  }
4238 
4239  std::string LibDir;
4240  std::string Loader;
4241 
4242  switch (Arch) {
4243  default:
4244  llvm_unreachable("unsupported architecture");
4245 
4246  case llvm::Triple::aarch64:
4247  LibDir = "lib";
4248  Loader = "ld-linux-aarch64.so.1";
4249  break;
4250  case llvm::Triple::aarch64_be:
4251  LibDir = "lib";
4252  Loader = "ld-linux-aarch64_be.so.1";
4253  break;
4254  case llvm::Triple::arm:
4255  case llvm::Triple::thumb:
4256  case llvm::Triple::armeb:
4257  case llvm::Triple::thumbeb: {
4258  const bool HF =
4259  Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
4261 
4262  LibDir = "lib";
4263  Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
4264  break;
4265  }
4266  case llvm::Triple::mips:
4267  case llvm::Triple::mipsel:
4268  case llvm::Triple::mips64:
4269  case llvm::Triple::mips64el: {
4270  bool LE = (Triple.getArch() == llvm::Triple::mipsel) ||
4271  (Triple.getArch() == llvm::Triple::mips64el);
4272  bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
4273 
4274  LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
4275 
4276  if (tools::mips::isUCLibc(Args))
4277  Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
4278  else if (!Triple.hasEnvironment() &&
4279  Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
4280  Loader = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
4281  else
4282  Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
4283 
4284  break;
4285  }
4286  case llvm::Triple::ppc:
4287  LibDir = "lib";
4288  Loader = "ld.so.1";
4289  break;
4290  case llvm::Triple::ppc64:
4291  LibDir = "lib64";
4292  Loader =
4293  (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
4294  break;
4295  case llvm::Triple::ppc64le:
4296  LibDir = "lib64";
4297  Loader =
4298  (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
4299  break;
4300  case llvm::Triple::sparc:
4301  case llvm::Triple::sparcel:
4302  LibDir = "lib";
4303  Loader = "ld-linux.so.2";
4304  break;
4305  case llvm::Triple::sparcv9:
4306  LibDir = "lib64";
4307  Loader = "ld-linux.so.2";
4308  break;
4309  case llvm::Triple::systemz:
4310  LibDir = "lib";
4311  Loader = "ld64.so.1";
4312  break;
4313  case llvm::Triple::x86:
4314  LibDir = "lib";
4315  Loader = "ld-linux.so.2";
4316  break;
4317  case llvm::Triple::x86_64: {
4318  bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;
4319 
4320  LibDir = X32 ? "libx32" : "lib64";
4321  Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
4322  break;
4323  }
4324  }
4325 
4326  if (Distro == Exherbo && (Triple.getVendor() == llvm::Triple::UnknownVendor ||
4327  Triple.getVendor() == llvm::Triple::PC))
4328  return "/usr/" + Triple.str() + "/lib/" + Loader;
4329  return "/" + LibDir + "/" + Loader;
4330 }
4331 
4332 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4333  ArgStringList &CC1Args) const {
4334  const Driver &D = getDriver();
4335  std::string SysRoot = computeSysRoot();
4336 
4337  if (DriverArgs.hasArg(options::OPT_nostdinc))
4338  return;
4339 
4340  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
4341  addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
4342 
4343  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
4345  llvm::sys::path::append(P, "include");
4346  addSystemInclude(DriverArgs, CC1Args, P);
4347  }
4348 
4349  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
4350  return;
4351 
4352  // Check for configure-time C include directories.
4353  StringRef CIncludeDirs(C_INCLUDE_DIRS);
4354  if (CIncludeDirs != "") {
4356  CIncludeDirs.split(dirs, ":");
4357  for (StringRef dir : dirs) {
4358  StringRef Prefix =
4359  llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
4360  addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
4361  }
4362  return;
4363  }
4364 
4365  // Lacking those, try to detect the correct set of system includes for the
4366  // target triple.
4367 
4368  // Add include directories specific to the selected multilib set and multilib.
4369  if (GCCInstallation.isValid()) {
4370  const auto &Callback = Multilibs.includeDirsCallback();
4371  if (Callback) {
4372  for (const auto &Path : Callback(GCCInstallation.getMultilib()))
4374  DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
4375  }
4376  }
4377 
4378  // Implement generic Debian multiarch support.
4379  const StringRef X86_64MultiarchIncludeDirs[] = {
4380  "/usr/include/x86_64-linux-gnu",
4381 
4382  // FIXME: These are older forms of multiarch. It's not clear that they're
4383  // in use in any released version of Debian, so we should consider
4384  // removing them.
4385  "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};
4386  const StringRef X86MultiarchIncludeDirs[] = {
4387  "/usr/include/i386-linux-gnu",
4388 
4389  // FIXME: These are older forms of multiarch. It's not clear that they're
4390  // in use in any released version of Debian, so we should consider
4391  // removing them.
4392  "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
4393  "/usr/include/i486-linux-gnu"};
4394  const StringRef AArch64MultiarchIncludeDirs[] = {
4395  "/usr/include/aarch64-linux-gnu"};
4396  const StringRef ARMMultiarchIncludeDirs[] = {
4397  "/usr/include/arm-linux-gnueabi"};
4398  const StringRef ARMHFMultiarchIncludeDirs[] = {
4399  "/usr/include/arm-linux-gnueabihf"};
4400  const StringRef ARMEBMultiarchIncludeDirs[] = {
4401  "/usr/include/armeb-linux-gnueabi"};
4402  const StringRef ARMEBHFMultiarchIncludeDirs[] = {
4403  "/usr/include/armeb-linux-gnueabihf"};
4404  const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};
4405  const StringRef MIPSELMultiarchIncludeDirs[] = {
4406  "/usr/include/mipsel-linux-gnu"};
4407  const StringRef MIPS64MultiarchIncludeDirs[] = {
4408  "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"};
4409  const StringRef MIPS64ELMultiarchIncludeDirs[] = {
4410  "/usr/include/mips64el-linux-gnu",
4411  "/usr/include/mips64el-linux-gnuabi64"};
4412  const StringRef PPCMultiarchIncludeDirs[] = {
4413  "/usr/include/powerpc-linux-gnu"};
4414  const StringRef PPC64MultiarchIncludeDirs[] = {
4415  "/usr/include/powerpc64-linux-gnu"};
4416  const StringRef PPC64LEMultiarchIncludeDirs[] = {
4417  "/usr/include/powerpc64le-linux-gnu"};
4418  const StringRef SparcMultiarchIncludeDirs[] = {
4419  "/usr/include/sparc-linux-gnu"};
4420  const StringRef Sparc64MultiarchIncludeDirs[] = {
4421  "/usr/include/sparc64-linux-gnu"};
4422  const StringRef SYSTEMZMultiarchIncludeDirs[] = {
4423  "/usr/include/s390x-linux-gnu"};
4424  ArrayRef<StringRef> MultiarchIncludeDirs;
4425  switch (getTriple().getArch()) {
4426  case llvm::Triple::x86_64:
4427  MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
4428  break;
4429  case llvm::Triple::x86:
4430  MultiarchIncludeDirs = X86MultiarchIncludeDirs;
4431  break;
4432  case llvm::Triple::aarch64:
4433  case llvm::Triple::aarch64_be:
4434  MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
4435  break;
4436  case llvm::Triple::arm:
4437  case llvm::Triple::thumb:
4438  if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4439  MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
4440  else
4441  MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
4442  break;
4443  case llvm::Triple::armeb:
4444  case llvm::Triple::thumbeb:
4445  if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4446  MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;
4447  else
4448  MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;
4449  break;
4450  case llvm::Triple::mips:
4451  MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
4452  break;
4453  case llvm::Triple::mipsel:
4454  MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
4455  break;
4456  case llvm::Triple::mips64:
4457  MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
4458  break;
4459  case llvm::Triple::mips64el:
4460  MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
4461  break;
4462  case llvm::Triple::ppc:
4463  MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
4464  break;
4465  case llvm::Triple::ppc64:
4466  MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
4467  break;
4468  case llvm::Triple::ppc64le:
4469  MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
4470  break;
4471  case llvm::Triple::sparc:
4472  MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
4473  break;
4474  case llvm::Triple::sparcv9:
4475  MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
4476  break;
4477  case llvm::Triple::systemz:
4478  MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
4479  break;
4480  default:
4481  break;
4482  }
4483  for (StringRef Dir : MultiarchIncludeDirs) {
4484  if (D.getVFS().exists(SysRoot + Dir)) {
4485  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
4486  break;
4487  }
4488  }
4489 
4490  if (getTriple().getOS() == llvm::Triple::RTEMS)
4491  return;
4492 
4493  // Add an include of '/include' directly. This isn't provided by default by
4494  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
4495  // add even when Clang is acting as-if it were a system compiler.
4496  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
4497 
4498  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
4499 }
4500 
4501 static std::string DetectLibcxxIncludePath(StringRef base) {
4502  std::error_code EC;
4503  int MaxVersion = 0;
4504  std::string MaxVersionString = "";
4505  for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE;
4506  LI = LI.increment(EC)) {
4507  StringRef VersionText = llvm::sys::path::filename(LI->path());
4508  int Version;
4509  if (VersionText[0] == 'v' &&
4510  !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
4511  if (Version > MaxVersion) {
4512  MaxVersion = Version;
4513  MaxVersionString = VersionText;
4514  }
4515  }
4516  }
4517  return MaxVersion ? (base + "/" + MaxVersionString).str() : "";
4518 }
4519 
4520 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
4521  ArgStringList &CC1Args) const {
4522  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4523  DriverArgs.hasArg(options::OPT_nostdincxx))
4524  return;
4525 
4526  // Check if libc++ has been enabled and provide its include paths if so.
4527  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
4528  const std::string LibCXXIncludePathCandidates[] = {
4529  DetectLibcxxIncludePath(getDriver().Dir + "/../include/c++"),
4530  // If this is a development, non-installed, clang, libcxx will
4531  // not be found at ../include/c++ but it likely to be found at
4532  // one of the following two locations:
4533  DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/local/include/c++"),
4534  DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/include/c++") };
4535  for (const auto &IncludePath : LibCXXIncludePathCandidates) {
4536  if (IncludePath.empty() || !getVFS().exists(IncludePath))
4537  continue;
4538  // Add the first candidate that exists.
4539  addSystemInclude(DriverArgs, CC1Args, IncludePath);
4540  break;
4541  }
4542  return;
4543  }
4544 
4545  // We need a detected GCC installation on Linux to provide libstdc++'s
4546  // headers. We handled the libc++ case above.
4547  if (!GCCInstallation.isValid())
4548  return;
4549 
4550  // By default, look for the C++ headers in an include directory adjacent to
4551  // the lib directory of the GCC installation. Note that this is expect to be
4552  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
4553  StringRef LibDir = GCCInstallation.getParentLibPath();
4554  StringRef InstallDir = GCCInstallation.getInstallPath();
4555  StringRef TripleStr = GCCInstallation.getTriple().str();
4557  const std::string GCCMultiarchTriple = getMultiarchTriple(
4559  const std::string TargetMultiarchTriple =
4561  const GCCVersion &Version = GCCInstallation.getVersion();
4562 
4563  // The primary search for libstdc++ supports multiarch variants.
4564  if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
4565  "/c++/" + Version.Text, TripleStr,
4566  GCCMultiarchTriple, TargetMultiarchTriple,
4567  Multilib.includeSuffix(), DriverArgs, CC1Args))
4568  return;
4569 
4570  // Otherwise, fall back on a bunch of options which don't use multiarch
4571  // layouts for simplicity.
4572  const std::string LibStdCXXIncludePathCandidates[] = {
4573  // Gentoo is weird and places its headers inside the GCC install,
4574  // so if the first attempt to find the headers fails, try these patterns.
4575  InstallDir.str() + "/include/g++-v" + Version.Text,
4576  InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
4577  Version.MinorStr,
4578  InstallDir.str() + "/include/g++-v" + Version.MajorStr,
4579  // Android standalone toolchain has C++ headers in yet another place.
4580  LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4581  // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
4582  // without a subdirectory corresponding to the gcc version.
4583  LibDir.str() + "/../include/c++",
4584  };
4585 
4586  for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
4587  if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
4588  /*GCCMultiarchTriple*/ "",
4589  /*TargetMultiarchTriple*/ "",
4590  Multilib.includeSuffix(), DriverArgs, CC1Args))
4591  break;
4592  }
4593 }
4594 
4595 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
4596  ArgStringList &CC1Args) const {
4597  if (DriverArgs.hasArg(options::OPT_nocudainc))
4598  return;
4599 
4600  if (!CudaInstallation.isValid()) {
4601  getDriver().Diag(diag::err_drv_no_cuda_installation);
4602  return;
4603  }
4604 
4605  addSystemInclude(DriverArgs, CC1Args, CudaInstallation.getIncludePath());
4606  CC1Args.push_back("-include");
4607  CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
4608 }
4609 
4610 void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
4611  ArgStringList &CC1Args) const {
4612  if (GCCInstallation.isValid()) {
4613  CC1Args.push_back("-isystem");
4614  CC1Args.push_back(DriverArgs.MakeArgString(
4615  GCCInstallation.getParentLibPath() + "/../" +
4616  GCCInstallation.getTriple().str() + "/include"));
4617  }
4618 }
4619 
4621 
4623  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
4624  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
4625  const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
4626  getTriple().getArch() == llvm::Triple::mips64el;
4627  const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
4628  getTriple().getArch() == llvm::Triple::ppc64le;
4629  const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
4630  getTriple().getArch() == llvm::Triple::aarch64_be;
4632  Res |= SanitizerKind::Address;
4633  Res |= SanitizerKind::KernelAddress;
4634  Res |= SanitizerKind::Vptr;
4635  Res |= SanitizerKind::SafeStack;
4636  if (IsX86_64 || IsMIPS64 || IsAArch64)
4637  Res |= SanitizerKind::DataFlow;
4638  if (IsX86_64 || IsMIPS64 || IsAArch64)
4639  Res |= SanitizerKind::Leak;
4640  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
4641  Res |= SanitizerKind::Thread;
4642  if (IsX86_64 || IsMIPS64 || IsPowerPC64 || IsAArch64)
4643  Res |= SanitizerKind::Memory;
4644  if (IsX86_64)
4645  Res |= SanitizerKind::Efficiency;
4646  if (IsX86 || IsX86_64) {
4647  Res |= SanitizerKind::Function;
4648  }
4649  return Res;
4650 }
4651 
4652 void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
4653  llvm::opt::ArgStringList &CmdArgs) const {
4654  if (!needsProfileRT(Args)) return;
4655 
4656  // Add linker option -u__llvm_runtime_variable to cause runtime
4657  // initialization module to be linked in.
4658  if (!Args.hasArg(options::OPT_coverage))
4659  CmdArgs.push_back(Args.MakeArgString(
4660  Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
4661  ToolChain::addProfileRTLibs(Args, CmdArgs);
4662 }
4663 
4664 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
4665 
4666 DragonFly::DragonFly(const Driver &D, const llvm::Triple &Triple,
4667  const ArgList &Args)
4668  : Generic_ELF(D, Triple, Args) {
4669 
4670  // Path mangling to find libexec
4671  getProgramPaths().push_back(getDriver().getInstalledDir());
4672  if (getDriver().getInstalledDir() != getDriver().Dir)
4673  getProgramPaths().push_back(getDriver().Dir);
4674 
4675  getFilePaths().push_back(getDriver().Dir + "/../lib");
4676  getFilePaths().push_back("/usr/lib");
4677  getFilePaths().push_back("/usr/lib/gcc50");
4678 }
4679 
4681  return new tools::dragonfly::Assembler(*this);
4682 }
4683 
4685  return new tools::dragonfly::Linker(*this);
4686 }
4687 
4688 /// CUDA toolchain. Our assembler is ptxas, and our "linker" is fatbinary,
4689 /// which isn't properly a linker but nonetheless performs the step of stitching
4690 /// together object files from the assembler into a single blob.
4691 
4692 CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
4693  const ArgList &Args)
4694  : Linux(D, Triple, Args) {
4695  if (CudaInstallation.isValid())
4697 }
4698 
4699 void
4700 CudaToolChain::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
4701  llvm::opt::ArgStringList &CC1Args) const {
4702  Linux::addClangTargetOptions(DriverArgs, CC1Args);
4703  CC1Args.push_back("-fcuda-is-device");
4704 
4705  if (DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
4706  options::OPT_fno_cuda_flush_denormals_to_zero, false))
4707  CC1Args.push_back("-fcuda-flush-denormals-to-zero");
4708 
4709  if (DriverArgs.hasFlag(options::OPT_fcuda_approx_transcendentals,
4710  options::OPT_fno_cuda_approx_transcendentals, false))
4711  CC1Args.push_back("-fcuda-approx-transcendentals");
4712 
4713  if (DriverArgs.hasArg(options::OPT_nocudalib))
4714  return;
4715 
4716  std::string LibDeviceFile = CudaInstallation.getLibDeviceFile(
4717  DriverArgs.getLastArgValue(options::OPT_march_EQ));
4718  if (!LibDeviceFile.empty()) {
4719  CC1Args.push_back("-mlink-cuda-bitcode");
4720  CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
4721 
4722  // Libdevice in CUDA-7.0 requires PTX version that's more recent
4723  // than LLVM defaults to. Use PTX4.2 which is the PTX version that
4724  // came with CUDA-7.0.
4725  CC1Args.push_back("-target-feature");
4726  CC1Args.push_back("+ptx42");
4727  }
4728 }
4729 
4730 void CudaToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
4731  ArgStringList &CC1Args) const {
4732  // Check our CUDA version if we're going to include the CUDA headers.
4733  if (!DriverArgs.hasArg(options::OPT_nocudainc) &&
4734  !DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {
4735  StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
4736  assert(!Arch.empty() && "Must have an explicit GPU arch.");
4738  }
4739  Linux::AddCudaIncludeArgs(DriverArgs, CC1Args);
4740 }
4741 
4742 llvm::opt::DerivedArgList *
4743 CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
4744  const char *BoundArch) const {
4745  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
4746  const OptTable &Opts = getDriver().getOpts();
4747 
4748  for (Arg *A : Args) {
4749  if (A->getOption().matches(options::OPT_Xarch__)) {
4750  // Skip this argument unless the architecture matches BoundArch
4751  if (!BoundArch || A->getValue(0) != StringRef(BoundArch))
4752  continue;
4753 
4754  unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
4755  unsigned Prev = Index;
4756  std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
4757 
4758  // If the argument parsing failed or more than one argument was
4759  // consumed, the -Xarch_ argument's parameter tried to consume
4760  // extra arguments. Emit an error and ignore.
4761  //
4762  // We also want to disallow any options which would alter the
4763  // driver behavior; that isn't going to work in our model. We
4764  // use isDriverOption() as an approximation, although things
4765  // like -O4 are going to slip through.
4766  if (!XarchArg || Index > Prev + 1) {
4767  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
4768  << A->getAsString(Args);
4769  continue;
4770  } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
4771  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
4772  << A->getAsString(Args);
4773  continue;
4774  }
4775  XarchArg->setBaseArg(A);
4776  A = XarchArg.release();
4777  DAL->AddSynthesizedArg(A);
4778  }
4779  DAL->append(A);
4780  }
4781 
4782  if (BoundArch) {
4783  DAL->eraseArg(options::OPT_march_EQ);
4784  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
4785  }
4786  return DAL;
4787 }
4788 
4790  return new tools::NVPTX::Assembler(*this);
4791 }
4792 
4794  return new tools::NVPTX::Linker(*this);
4795 }
4796 
4797 /// XCore tool chain
4798 XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
4799  const ArgList &Args)
4800  : ToolChain(D, Triple, Args) {
4801  // ProgramPaths are found via 'PATH' environment variable.
4802 }
4803 
4805  return new tools::XCore::Assembler(*this);
4806 }
4807 
4809  return new tools::XCore::Linker(*this);
4810 }
4811 
4812 bool XCoreToolChain::isPICDefault() const { return false; }
4813 
4814 bool XCoreToolChain::isPIEDefault() const { return false; }
4815 
4816 bool XCoreToolChain::isPICDefaultForced() const { return false; }
4817 
4818 bool XCoreToolChain::SupportsProfiling() const { return false; }
4819 
4820 bool XCoreToolChain::hasBlocksRuntime() const { return false; }
4821 
4822 void XCoreToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4823  ArgStringList &CC1Args) const {
4824  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4825  DriverArgs.hasArg(options::OPT_nostdlibinc))
4826  return;
4827  if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
4829  const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4830  StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4831  ArrayRef<StringRef> DirVec(Dirs);
4832  addSystemIncludes(DriverArgs, CC1Args, DirVec);
4833  }
4834 }
4835 
4836 void XCoreToolChain::addClangTargetOptions(const ArgList &DriverArgs,
4837  ArgStringList &CC1Args) const {
4838  CC1Args.push_back("-nostdsysteminc");
4839 }
4840 
4842  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4843  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4844  DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4845  DriverArgs.hasArg(options::OPT_nostdincxx))
4846  return;
4847  if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
4849  const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4850  StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4851  ArrayRef<StringRef> DirVec(Dirs);
4852  addSystemIncludes(DriverArgs, CC1Args, DirVec);
4853  }
4854 }
4855 
4856 void XCoreToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
4857  ArgStringList &CmdArgs) const {
4858  // We don't output any lib args. This is handled by xcc.
4859 }
4860 
4861 MyriadToolChain::MyriadToolChain(const Driver &D, const llvm::Triple &Triple,
4862  const ArgList &Args)
4863  : Generic_ELF(D, Triple, Args) {
4864  // If a target of 'sparc-myriad-elf' is specified to clang, it wants to use
4865  // 'sparc-myriad--elf' (note the unknown OS) as the canonical triple.
4866  // This won't work to find gcc. Instead we give the installation detector an
4867  // extra triple, which is preferable to further hacks of the logic that at
4868  // present is based solely on getArch(). In particular, it would be wrong to
4869  // choose the myriad installation when targeting a non-myriad sparc install.
4870  switch (Triple.getArch()) {
4871  default:
4872  D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4873  << "myriad";
4874  case llvm::Triple::sparc:
4875  case llvm::Triple::sparcel:
4876  case llvm::Triple::shave:
4877  GCCInstallation.init(Triple, Args, {"sparc-myriad-elf"});
4878  }
4879 
4880  if (GCCInstallation.isValid()) {
4881  // The contents of LibDir are independent of the version of gcc.
4882  // This contains libc, libg (a superset of libc), libm, libstdc++, libssp.
4884  if (Triple.getArch() == llvm::Triple::sparcel)
4885  llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib/le");
4886  else
4887  llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib");
4888  addPathIfExists(D, LibDir, getFilePaths());
4889 
4890  // This directory contains crt{i,n,begin,end}.o as well as libgcc.
4891  // These files are tied to a particular version of gcc.
4892  SmallString<128> CompilerSupportDir(GCCInstallation.getInstallPath());
4893  // There are actually 4 choices: {le,be} x {fpu,nofpu}
4894  // but as this toolchain is for LEON sparc, it can assume FPU.
4895  if (Triple.getArch() == llvm::Triple::sparcel)
4896  llvm::sys::path::append(CompilerSupportDir, "le");
4897  addPathIfExists(D, CompilerSupportDir, getFilePaths());
4898  }
4899 }
4900 
4902 
4903 void MyriadToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4904  ArgStringList &CC1Args) const {
4905  if (!DriverArgs.hasArg(options::OPT_nostdinc))
4906  addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
4907 }
4908 
4910  const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4911  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4912  DriverArgs.hasArg(options::OPT_nostdincxx))
4913  return;
4914 
4915  // Only libstdc++, for now.
4916  StringRef LibDir = GCCInstallation.getParentLibPath();
4917  const GCCVersion &Version = GCCInstallation.getVersion();
4918  StringRef TripleStr = GCCInstallation.getTriple().str();
4920 
4922  LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4923  "", TripleStr, "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
4924 }
4925 
4926 // MyriadToolChain handles several triples:
4927 // {shave,sparc{,el}}-myriad-{rtems,unknown}-elf
4929  // The inherited method works fine if not targeting the SHAVE.
4930  if (!isShaveCompilation(getTriple()))
4931  return ToolChain::SelectTool(JA);
4932  switch (JA.getKind()) {
4935  if (!Compiler)
4936  Compiler.reset(new tools::SHAVE::Compiler(*this));
4937  return Compiler.get();
4939  if (!Assembler)
4940  Assembler.reset(new tools::SHAVE::Assembler(*this));
4941  return Assembler.get();
4942  default:
4943  return ToolChain::getTool(JA.getKind());
4944  }
4945 }
4946 
4948  return new tools::Myriad::Linker(*this);
4949 }
4950 
4951 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple,
4952  const llvm::opt::ArgList &Args)
4953  : ToolChain(D, Triple, Args) {
4954 
4955  assert(Triple.isArch32Bit() != Triple.isArch64Bit());
4956  getFilePaths().push_back(
4957  getDriver().SysRoot + "/lib" + (Triple.isArch32Bit() ? "32" : "64"));
4958 
4959  // Use LLD by default.
4960  DefaultLinker = "lld";
4961 }
4962 
4963 bool WebAssembly::IsMathErrnoDefault() const { return false; }
4964 
4965 bool WebAssembly::IsObjCNonFragileABIDefault() const { return true; }
4966 
4967 bool WebAssembly::UseObjCMixedDispatch() const { return true; }
4968 
4969 bool WebAssembly::isPICDefault() const { return false; }
4970 
4971 bool WebAssembly::isPIEDefault() const { return false; }
4972 
4973 bool WebAssembly::isPICDefaultForced() const { return false; }
4974 
4975 bool WebAssembly::IsIntegratedAssemblerDefault() const { return true; }
4976 
4977 // TODO: Support Objective C stuff.
4978 bool WebAssembly::SupportsObjCGC() const { return false; }
4979 
4980 bool WebAssembly::hasBlocksRuntime() const { return false; }
4981 
4982 // TODO: Support profiling.
4983 bool WebAssembly::SupportsProfiling() const { return false; }
4984 
4985 bool WebAssembly::HasNativeLLVMSupport() const { return true; }
4986 
4987 void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs,
4988  ArgStringList &CC1Args) const {
4989  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
4990  options::OPT_fno_use_init_array, true))
4991  CC1Args.push_back("-fuse-init-array");
4992 }
4993 
4994 ToolChain::RuntimeLibType WebAssembly::GetDefaultRuntimeLibType() const {
4996 }
4997 
4998 ToolChain::CXXStdlibType WebAssembly::GetCXXStdlibType(const ArgList &Args) const {
4999  return ToolChain::CST_Libcxx;
5000 }
5001 
5002 void WebAssembly::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
5003  ArgStringList &CC1Args) const {
5004  if (!DriverArgs.hasArg(options::OPT_nostdinc))
5005  addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
5006 }
5007 
5008 void WebAssembly::AddClangCXXStdlibIncludeArgs(
5009  const llvm::opt::ArgList &DriverArgs,
5010  llvm::opt::ArgStringList &CC1Args) const {
5011  if (!DriverArgs.hasArg(options::OPT_nostdlibinc) &&
5012  !DriverArgs.hasArg(options::OPT_nostdincxx))
5013  addSystemInclude(DriverArgs, CC1Args,
5014  getDriver().SysRoot + "/include/c++/v1");
5015 }
5016 
5017 Tool *WebAssembly::buildLinker() const {
5018  return new tools::wasm::Linker(*this);
5019 }
5020 
5021 PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
5022  : Generic_ELF(D, Triple, Args) {
5023  if (Args.hasArg(options::OPT_static))
5024  D.Diag(diag::err_drv_unsupported_opt_for_target) << "-static" << "PS4";
5025 
5026  // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
5027  // if it exists; otherwise use the driver's installation path, which
5028  // should be <SDK_DIR>/host_tools/bin.
5029 
5030  SmallString<512> PS4SDKDir;
5031  if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
5032  if (!llvm::sys::fs::exists(EnvValue))
5033  getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
5034  PS4SDKDir = EnvValue;
5035  } else {
5036  PS4SDKDir = getDriver().Dir;
5037  llvm::sys::path::append(PS4SDKDir, "/../../");
5038  }
5039 
5040  // By default, the driver won't report a warning if it can't find
5041  // PS4's include or lib directories. This behavior could be changed if
5042  // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
5043  // If -isysroot was passed, use that as the SDK base path.
5044  std::string PrefixDir;
5045  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5046  PrefixDir = A->getValue();
5047  if (!llvm::sys::fs::exists(PrefixDir))
5048  getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
5049  } else
5050  PrefixDir = PS4SDKDir.str();
5051 
5052  SmallString<512> PS4SDKIncludeDir(PrefixDir);
5053  llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
5054  if (!Args.hasArg(options::OPT_nostdinc) &&
5055  !Args.hasArg(options::OPT_nostdlibinc) &&
5056  !Args.hasArg(options::OPT_isysroot) &&
5057  !Args.hasArg(options::OPT__sysroot_EQ) &&
5058  !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
5059  getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5060  << "PS4 system headers" << PS4SDKIncludeDir;
5061  }
5062 
5063  SmallString<512> PS4SDKLibDir(PS4SDKDir);
5064  llvm::sys::path::append(PS4SDKLibDir, "target/lib");
5065  if (!Args.hasArg(options::OPT_nostdlib) &&
5066  !Args.hasArg(options::OPT_nodefaultlibs) &&
5067  !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
5068  !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
5069  !Args.hasArg(options::OPT_emit_ast) &&
5070  !llvm::sys::fs::exists(PS4SDKLibDir)) {
5071  getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5072  << "PS4 system libraries" << PS4SDKLibDir;
5073  return;
5074  }
5075  getFilePaths().push_back(PS4SDKLibDir.str());
5076 }
5077 
5079  return new tools::PS4cpu::Assemble(*this);
5080 }
5081 
5082 Tool *PS4CPU::buildLinker() const { return new tools::PS4cpu::Link(*this); }
5083 
5084 bool PS4CPU::isPICDefault() const { return true; }
5085 
5086 bool PS4CPU::HasNativeLLVMSupport() const { return true; }
5087 
5090  Res |= SanitizerKind::Address;
5091  Res |= SanitizerKind::Vptr;
5092  return Res;
5093 }
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
MultilibSet & Either(const Multilib &M1, const Multilib &M2)
Add a set of mutually incompatible Multilib segments.
Definition: Multilib.cpp:153
Tool * buildAssembler() const override
MultilibSet & Maybe(const Multilib &M)
Add an optional Multilib segment.
Definition: Multilib.cpp:143
const llvm::Triple & getTriple() const
Definition: ToolChain.h:130
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory with extern "C" semantics to CC1 arguments...
Definition: ToolChain.cpp:595
const std::string & includeSuffix() const
Get the include directory suffix.
Definition: Multilib.h:62
virtual void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass a suitable profile runtime ...
Definition: ToolChain.cpp:520
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
virtual Tool * getTool(Action::ActionClass AC) const
Definition: ToolChain.cpp:241
virtual Tool * SelectTool(const JobAction &JA) const
Choose a tool to use to handle the action JA.
Definition: ToolChain.cpp:326
static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
bool SupportsObjCGC() const override
Does this tool chain support Objective-C garbage collection.
bool SupportsEmbeddedBitcode() const override
SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
Tool * buildAssembler() const override
Definition: ToolChains.cpp:233
CudaArch
Definition: Cuda.h:30
ID lookupTypeForExtension(const char *Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
Definition: Types.cpp:156
static void addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Definition: ToolChain.cpp:602
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
const char * CudaArchToString(CudaArch A)
Definition: Cuda.cpp:23
Tool * buildAssembler() const override
static CudaVersion ParseCudaVersionFile(llvm::StringRef V)
Tool * buildLinker() const override
PS4CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Generic_GCC - A tool chain using the 'gcc' command to perform all subcommands; this relies on gcc tra...
Definition: ToolChains.h:33
Minix(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Minix - Minix tool chain which can call as(1) and ld(1) directly.
prefix_list PrefixDirs
Definition: Driver.h:124
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:554
Tool * buildLinker() const override
Tool * getTool(Action::ActionClass AC) const override
static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
CXXStdlibType GetDefaultCXXStdlibType() const override
static bool isMips64(llvm::Triple::ArchType Arch)
static void findAndroidArmMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
SanitizerMask getDefaultSanitizers() const override
Return sanitizers which are enabled by default.
Tool * buildLinker() const override
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
bool UseDwarfDebugFlags() const override
UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf compile unit information...
StringRef P
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Definition: Multilib.h:52
Tool * buildAssembler() const override
NaClToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
NaCl Toolchain.
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Defines types useful for describing an Objective-C runtime.
CXXStdlibType GetDefaultCXXStdlibType() const override
Definition: ToolChains.cpp:69
The base class of the type hierarchy.
Definition: Type.h:1281
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Tool * buildLinker() const override
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
Definition: ToolChains.cpp:67
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:240
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
TCEToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands.
Bitrig(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:97
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Struct to store and manipulate GCC versions.
Definition: ToolChains.h:50
static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:132
CudaArch StringToCudaArch(llvm::StringRef S)
Definition: Cuda.cpp:55
static bool GetReleaseVersion(const char *Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
Definition: Driver.cpp:2736
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: ToolChains.h:116
void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add any profiling runtime libraries that are needed.
Definition: ToolChains.cpp:383
FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args)
bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Definition: ToolChains.h:503
static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:684
static bool IsDebian(enum Distro Distro)
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific CUDA includes.
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Tool * buildAssembler() const override
iterator begin() const
Definition: Type.h:4235
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
StringRef getPlatformFamily() const
Definition: ToolChains.cpp:333
bool TargetInitialized
Whether the information on the target has been initialized.
Definition: ToolChains.h:379
Distro
Distribution (very bare-bones at the moment).
bool hasBlocksRuntime() const override
Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
Definition: ToolChains.cpp:91
The virtual file system interface.
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
const StringRef FilePath
Multilib & flag(StringRef F)
Add a flag to the flags list.
Definition: Multilib.h:75
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:37
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
const llvm::Triple & getTriple() const
Get the GCC triple for the detected install.
Definition: ToolChains.h:113
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
Tool * buildAssembler() const override
static bool findMipsAndroidMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
GCCInstallationDetector GCCInstallation
Definition: ToolChains.h:160
path_list & getProgramPaths()
Definition: ToolChain.h:148
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:108
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Definition: Multilib.h:42
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Darwin - The base Darwin tool chain.
Definition: ToolChains.h:372
Tool * buildAssembler() const override
void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add the linker arguments to link the compiler runtime library.
Definition: ToolChains.cpp:403
ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override
Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
Definition: ToolChains.cpp:80
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
ActionClass getKind() const
Definition: Action.h:122
static Multilib makeMultilib(StringRef commonSuffix)
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
OpenBSD(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
static bool needsProfileRT(const llvm::opt::ArgList &Args)
needsProfileRT - returns true if instrumentation profile is on.
Definition: ToolChain.cpp:312
bool isValid() const
Check whether we detected a valid Cuda install.
Definition: ToolChains.h:190
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
std::string getAsString() const
Retrieve a string representation of the version number.
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: ToolChains.h:122
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Tool * getTool(Action::ActionClass AC) const override
Definition: ToolChains.cpp:212
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:259
bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch, StringRef RHSPatchSuffix=StringRef()) const
Less-than for GCCVersion, implementing a Strict Weak Ordering.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
Definition: ObjCRuntime.h:160
XCoreToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
XCore tool chain.
CXXStdlibType GetDefaultCXXStdlibType() const override
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
Definition: Multilib.h:156
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
Tool * buildAssembler() const override
static std::string DetectLibcxxIncludePath(StringRef base)
path_list & getFilePaths()
Definition: ToolChain.h:145
static bool isMipsEL(llvm::Triple::ArchType Arch)
CloudABI(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:66
const Driver & getDriver() const
Definition: ToolChain.h:128
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, const char *BoundArch) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value)
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
iterator end() const
std::string getLibDeviceFile(StringRef Gpu) const
Get libdevice file for given architecture.
Definition: ToolChains.h:207
Tool * buildLinker() const override
static bool isMicroMips(const ArgList &Args)
detail::InMemoryDirectory::const_iterator I
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
static bool IsRedhat(enum Distro Distro)
CXXStdlibType GetDefaultCXXStdlibType() const override
WebAssembly(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
FreeBSD(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
const MultilibSet & getMultilibs() const
Get the whole MultilibSet.
Definition: ToolChains.h:125
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Tool * buildLinker() const override
static llvm::StringRef getGCCToolchainDir(const ArgList &Args)
Darwin(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Darwin - Darwin tool chain for i386 and x86_64.
Definition: ToolChains.cpp:54
'watchos' is a variant of iOS for Apple's watchOS.
Definition: ObjCRuntime.h:46
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
static std::string getMultiarchTriple(const Driver &D, const llvm::Triple &TargetTriple, StringRef SysRoot)
Get our best guess at the multiarch triple for a target.
virtual std::string computeSysRoot() const
const char * CudaVersionToString(CudaVersion V)
Definition: Cuda.cpp:9
StringRef getOS() const
Definition: ToolChain.h:135
MachO(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: ToolChains.cpp:45
CudaInstallationDetector CudaInstallation
Definition: ToolChains.h:212
void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass a suitable profile runtime ...
std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, bool Shared=false) const override
virtual RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:527
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add options that need to be passed to cc1 for this target.
bool getBiarchSibling(Multilib &M) const
Get the biarch sibling multilib (if it exists).
static const char * ArmMachOArchNameCPU(StringRef CPU)
Definition: ToolChains.cpp:123
static bool isMipsArch(llvm::Triple::ArchType Arch)
static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, ArrayRef< StringRef > Paths)
Utility function to add a list of system include directories to CC1.
Definition: ToolChain.cpp:610
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:32
MatchFinder::MatchCallback * Callback
static void addMultilibFlag(bool Enabled, const char *const Flag, std::vector< std::string > &Flags)
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
bool isValid() const
Check whether we detected a valid GCC install.
Definition: ToolChains.h:110
Defines version macros and version-related utility functions for Clang.
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
DragonFly(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
bool IsUnwindTablesDefault() const override
IsUnwindTablesDefault - Does this tool chain use -funwind-tables by default.
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, const char *BoundArch) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
StringRef getMachOArchName(const llvm::opt::ArgList &Args) const
Get the "MachO" arch name for a particular compiler invocation.
Definition: ToolChains.cpp:153
VersionTuple getTargetVersion() const
Definition: ToolChains.h:498
VersionTuple TargetVersion
The OS version we are targeting.
Definition: ToolChains.h:394
static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch)
bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override
UseSjLjExceptions - Does this tool chain use SjLj exceptions.
Tool * buildAssembler() const override
static bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
Definition: Multilib.h:26
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args)
Tool * buildAssembler() const override
static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs, const Multilib &Multilib, StringRef InstallPath, ToolChain::path_list &Paths)
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
NetBSD(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
static bool IsUbuntu(enum Distro Distro)
std::string computeSysRoot() const override
virtual std::string ComputeLLVMTriple(const llvm::opt::ArgList &Args, types::ID InputType=types::TY_INVALID) const
ComputeLLVMTriple - Return the LLVM target triple to use, after taking command line arguments into ac...
Definition: ToolChain.cpp:416
CudaToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
CUDA toolchain.
vfs::FileSystem & getVFS() const
Definition: Driver.h:244
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
The result type of a method or function.
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Tools.cpp:7363
Tool * buildAssembler() const override
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add options that need to be passed to cc1 for this target.
void setTarget(DarwinPlatformKind Platform, unsigned Major, unsigned Minor, unsigned Micro) const
Definition: ToolChains.h:431
#define false
Definition: stdbool.h:33
StringRef FileName
Definition: Format.cpp:1313
void printVerboseInfo(raw_ostream &OS) const override
Dispatch to the specific toolchain for verbose printing.
bool SupportsProfiling() const override
SupportsProfiling - Does this tool chain support -pg.
const TemplateArgument * iterator
Definition: Type.h:4233
void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use MCU GCC toolchain includes.
Tool * buildLinker() const override
AnnotatedLine & Line
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override
UseSjLjExceptions - Does this tool chain use SjLj exceptions.
Tool * buildLinker() const override
bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value)
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args)
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, const char *BoundArch) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: ToolChains.cpp:805
CudaVersion
Definition: Cuda.h:19
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:114
bool isUCLibc(const llvm::opt::ArgList &Args)
Tool * buildAssembler() const override
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
Definition: ToolChains.cpp:186
static void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths)
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
StringRef getDefaultUniversalArchName() const
Provide the default architecture name (as expected by -arch) for this toolchain.
Definition: ToolChain.cpp:188
bool IsMathErrnoDefault() const override
IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
static const char * ArmMachOArchName(StringRef Arch)
Definition: ToolChains.cpp:106
virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Add the linker arguments to link the compiler runtime library.
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:580
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
DarwinClang(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: ToolChains.cpp:237
Solaris(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
Definition: ObjCRuntime.h:207
void addStartObjectFileArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
static bool isObjCAutoRefCount(const ArgList &Args)
Determine whether Objective-C automated reference counting is enabled.
Definition: ToolChains.cpp:258
MyriadToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
types::ID LookupTypeForExtension(const char *Ext) const override
LookupTypeForExtension - Return the default language type to use for the given extension.
Definition: ToolChains.cpp:57
StringRef getBinPath() const
Get the detected path to Cuda's bin directory.
Definition: ToolChains.h:199
void AddLinkARCArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add the linker arguments to link the ARC runtime library.
Definition: ToolChains.cpp:262
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
Definition: ToolChains.cpp:179
CudaVersion MinVersionForCudaArch(CudaArch A)
Get the earliest CudaVersion that supports the given CudaArch.
Definition: Cuda.cpp:149
DarwinPlatformKind TargetPlatform
Definition: ToolChains.h:391
static bool isMips32(llvm::Triple::ArchType Arch)
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
uint64_t SanitizerMask
Definition: Sanitizers.h:24
Generic_GCC(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
static StringRef getSDKName(StringRef isysroot)
Definition: ToolChains.cpp:350
void CheckObjCARC() const override
Complain if this tool chain doesn't support Objective-C ARC.
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific CUDA includes.
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
bool hasBlocksRuntime() const override
hasBlocksRuntime - Given that the user is compiling with -fblocks, does this tool chain guarantee the...
StringRef getOSLibraryNameSuffix() const
Definition: ToolChains.cpp:363
std::string SysRoot
sysroot, if present
Definition: Driver.h:127
MultilibSet Multilibs
Definition: ToolChain.h:96
static bool isSoftFloatABI(const ArgList &Args)
Definition: ToolChains.cpp:142
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
Defines the virtual file system interface vfs::FileSystem.
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
Tool * buildLinker() const override
void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: ToolChains.cpp:734
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Tool * SelectTool(const JobAction &JA) const override
Choose a tool to use to handle the action JA.
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition: ObjCRuntime.h:42
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, StringRef TargetMultiarchTriple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Helper to add the variant paths of a libstdc++ installation.
bool SupportsProfiling() const override
SupportsProfiling - Does this tool chain support -pg.
StringRef getIncludePath() const
Get the detected Cuda Include path.
Definition: ToolChains.h:201
std::string MajorStr
The text of the parsed major, and major+minor versions.
Definition: ToolChains.h:58
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
std::string Text
The unparsed text of the version.
Definition: ToolChains.h:52
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
static GCCVersion Parse(StringRef VersionText)
MipsLLVMToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Mips Toolchain.
Tool * buildLinker() const override
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
static bool isArmOrThumbArch(llvm::Triple::ArchType Arch)
Tool * buildLinker() const override
Definition: ToolChains.cpp:231
void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, StringRef DarwinLibName, bool AlwaysLink=false, bool IsEmbedded=false, bool AddRPath=false) const
Definition: ToolChains.cpp:299
void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override
Add warning options that need to be passed to cc1 for this target.
Definition: ToolChains.cpp:241
bool isDefault() const
Check whether the default is selected.
Definition: Multilib.h:88
const GCCVersion & getVersion() const
Get the detected GCC version string.
Definition: ToolChains.h:132
bool isShaveCompilation(const llvm::Triple &T) const
Definition: ToolChains.h:1155
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
Definition: Multilib.cpp:213
bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Definition: ToolChains.h:509
static bool findBiarchMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, bool NeedsBiarchSuffix, DetectedMultilibs &Result)
AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
AMDGPU Toolchain.
static bool isMips16(const ArgList &Args)
Tool * buildAssembler() const override
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:81
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args, ArrayRef< std::string > ExtraTripleAliases=None)
Initialize a GCCInstallationDetector from the driver.
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
std::vector< std::string > flags_list
Definition: Multilib.h:28
void print(raw_ostream &OS) const
Print information about the detected GCC installation.
bool select(const Multilib::flags_list &Flags, Multilib &M) const
Pick the best multilib in the set,.
Definition: Multilib.cpp:245
bool isTargetWatchOSSimulator() const
Definition: ToolChains.h:481
const IncludeDirsFunc & filePathsCallback() const
Definition: Multilib.h:166
const char * DefaultLinker
Definition: ToolChain.h:97
std::vector< std::string > ExtraOpts
Definition: ToolChains.h:847
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add options that need to be passed to cc1 for this target.
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
const IncludeDirsFunc & includeDirsCallback() const
Definition: Multilib.h:160
bool IsUnwindTablesDefault() const override
IsUnwindTablesDefault - Does this tool chain use -funwind-tables by default.
Tool * buildLinker() const override
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: ToolChains.h:119
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
const SanitizerArgs & getSanitizerArgs() const
Definition: ToolChain.cpp:89
unsigned size() const
Definition: Multilib.h:152
Haiku(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Haiku - Haiku tool chain which can call as(1) and ld(1) directly.
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:334
void CheckCudaVersionSupportsArch(CudaArch Arch) const
Emit an error if Version does not support the given Arch.
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Linux(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
HexagonToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
void AddCCKextLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCCKextLibArgs - Add the system specific linker arguments to use for kernel extensions (Darwin-spec...
Definition: ToolChains.cpp:779
static bool IsOpenSUSE(enum Distro Distro)
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:48
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:117