contrib/llvm/tools/clang/lib/Driver/ToolChains.h

   1 //===--- ToolChains.h - 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 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H
  11 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H
  12
  13 #include "Tools.h"
  14 #include "clang/Basic/Cuda.h"
  15 #include "clang/Basic/VersionTuple.h"
  16 #include "clang/Driver/Action.h"
  17 #include "clang/Driver/Multilib.h"
  18 #include "clang/Driver/ToolChain.h"
  19 #include "llvm/ADT/Optional.h"
  20 #include "llvm/ADT/SmallSet.h"
  21 #include "llvm/Support/Compiler.h"
  22 #include <set>
  23 #include <vector>
  24
  25 namespace clang {
  26 namespace driver {
  27
  28 /// A class to find a viable CUDA installation
  29 class CudaInstallationDetector {
  30 private:
  31   const Driver &D;
  32   bool IsValid = false;
  33   CudaVersion Version = CudaVersion::UNKNOWN;
  34   std::string InstallPath;
  35   std::string BinPath;
  36   std::string LibPath;
  37   std::string LibDevicePath;
  38   std::string IncludePath;
  39   llvm::StringMap<std::string> LibDeviceMap;
  40
  41   // CUDA architectures for which we have raised an error in
  42   // CheckCudaVersionSupportsArch.
  43   mutable llvm::SmallSet<CudaArch, 4> ArchsWithVersionTooLowErrors;
  44
  45 public:
  46   CudaInstallationDetector(const Driver &D, const llvm::Triple &HostTriple,
  47                            const llvm::opt::ArgList &Args);
  48
  49   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
  50                           llvm::opt::ArgStringList &CC1Args) const;
  51
  52   /// \brief Emit an error if Version does not support the given Arch.
  53   ///
  54   /// If either Version or Arch is unknown, does not emit an error.  Emits at
  55   /// most one error per Arch.
  56   void CheckCudaVersionSupportsArch(CudaArch Arch) const;
  57
  58   /// \brief Check whether we detected a valid Cuda install.
  59   bool isValid() const { return IsValid; }
  60   /// \brief Print information about the detected CUDA installation.
  61   void print(raw_ostream &OS) const;
  62
  63   /// \brief Get the detected Cuda install's version.
  64   CudaVersion version() const { return Version; }
  65   /// \brief Get the detected Cuda installation path.
  66   StringRef getInstallPath() const { return InstallPath; }
  67   /// \brief Get the detected path to Cuda's bin directory.
  68   StringRef getBinPath() const { return BinPath; }
  69   /// \brief Get the detected Cuda Include path.
  70   StringRef getIncludePath() const { return IncludePath; }
  71   /// \brief Get the detected Cuda library path.
  72   StringRef getLibPath() const { return LibPath; }
  73   /// \brief Get the detected Cuda device library path.
  74   StringRef getLibDevicePath() const { return LibDevicePath; }
  75   /// \brief Get libdevice file for given architecture
  76   std::string getLibDeviceFile(StringRef Gpu) const {
  77     return LibDeviceMap.lookup(Gpu);
  78   }
  79 };
  80
  81 namespace toolchains {
  82
  83 /// Generic_GCC - A tool chain using the 'gcc' command to perform
  84 /// all subcommands; this relies on gcc translating the majority of
  85 /// command line options.
  86 class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
  87 public:
  88   /// \brief Struct to store and manipulate GCC versions.
  89   ///
  90   /// We rely on assumptions about the form and structure of GCC version
  91   /// numbers: they consist of at most three '.'-separated components, and each
  92   /// component is a non-negative integer except for the last component. For
  93   /// the last component we are very flexible in order to tolerate release
  94   /// candidates or 'x' wildcards.
  95   ///
  96   /// Note that the ordering established among GCCVersions is based on the
  97   /// preferred version string to use. For example we prefer versions without
  98   /// a hard-coded patch number to those with a hard coded patch number.
  99   ///
 100   /// Currently this doesn't provide any logic for textual suffixes to patches
 101   /// in the way that (for example) Debian's version format does. If that ever
 102   /// becomes necessary, it can be added.
 103   struct GCCVersion {
 104     /// \brief The unparsed text of the version.
 105     std::string Text;
 106
 107     /// \brief The parsed major, minor, and patch numbers.
 108     int Major, Minor, Patch;
 109
 110     /// \brief The text of the parsed major, and major+minor versions.
 111     std::string MajorStr, MinorStr;
 112
 113     /// \brief Any textual suffix on the patch number.
 114     std::string PatchSuffix;
 115
 116     static GCCVersion Parse(StringRef VersionText);
 117     bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch,
 118                      StringRef RHSPatchSuffix = StringRef()) const;
 119     bool operator<(const GCCVersion &RHS) const {
 120       return isOlderThan(RHS.Major, RHS.Minor, RHS.Patch, RHS.PatchSuffix);
 121     }
 122     bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
 123     bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
 124     bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
 125   };
 126
 127   /// \brief This is a class to find a viable GCC installation for Clang to
 128   /// use.
 129   ///
 130   /// This class tries to find a GCC installation on the system, and report
 131   /// information about it. It starts from the host information provided to the
 132   /// Driver, and has logic for fuzzing that where appropriate.
 133   class GCCInstallationDetector {
 134     bool IsValid;
 135     llvm::Triple GCCTriple;
 136     const Driver &D;
 137
 138     // FIXME: These might be better as path objects.
 139     std::string GCCInstallPath;
 140     std::string GCCParentLibPath;
 141
 142     /// The primary multilib appropriate for the given flags.
 143     Multilib SelectedMultilib;
 144     /// On Biarch systems, this corresponds to the default multilib when
 145     /// targeting the non-default multilib. Otherwise, it is empty.
 146     llvm::Optional<Multilib> BiarchSibling;
 147
 148     GCCVersion Version;
 149
 150     // We retain the list of install paths that were considered and rejected in
 151     // order to print out detailed information in verbose mode.
 152     std::set<std::string> CandidateGCCInstallPaths;
 153
 154     /// The set of multilibs that the detected installation supports.
 155     MultilibSet Multilibs;
 156
 157   public:
 158     explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
 159     void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
 160               ArrayRef<std::string> ExtraTripleAliases = None);
 161
 162     /// \brief Check whether we detected a valid GCC install.
 163     bool isValid() const { return IsValid; }
 164
 165     /// \brief Get the GCC triple for the detected install.
 166     const llvm::Triple &getTriple() const { return GCCTriple; }
 167
 168     /// \brief Get the detected GCC installation path.
 169     StringRef getInstallPath() const { return GCCInstallPath; }
 170
 171     /// \brief Get the detected GCC parent lib path.
 172     StringRef getParentLibPath() const { return GCCParentLibPath; }
 173
 174     /// \brief Get the detected Multilib
 175     const Multilib &getMultilib() const { return SelectedMultilib; }
 176
 177     /// \brief Get the whole MultilibSet
 178     const MultilibSet &getMultilibs() const { return Multilibs; }
 179
 180     /// Get the biarch sibling multilib (if it exists).
 181     /// \return true iff such a sibling exists
 182     bool getBiarchSibling(Multilib &M) const;
 183
 184     /// \brief Get the detected GCC version string.
 185     const GCCVersion &getVersion() const { return Version; }
 186
 187     /// \brief Print information about the detected GCC installation.
 188     void print(raw_ostream &OS) const;
 189
 190   private:
 191     static void
 192     CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
 193                              const llvm::Triple &BiarchTriple,
 194                              SmallVectorImpl<StringRef> &LibDirs,
 195                              SmallVectorImpl<StringRef> &TripleAliases,
 196                              SmallVectorImpl<StringRef> &BiarchLibDirs,
 197                              SmallVectorImpl<StringRef> &BiarchTripleAliases);
 198
 199     bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,
 200                              const llvm::opt::ArgList &Args,
 201                              StringRef Path,
 202                              bool NeedsBiarchSuffix = false);
 203
 204     void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
 205                                 const llvm::opt::ArgList &Args,
 206                                 const std::string &LibDir,
 207                                 StringRef CandidateTriple,
 208                                 bool NeedsBiarchSuffix = false);
 209
 210     void scanLibDirForGCCTripleSolaris(const llvm::Triple &TargetArch,
 211                                        const llvm::opt::ArgList &Args,
 212                                        const std::string &LibDir,
 213                                        StringRef CandidateTriple,
 214                                        bool NeedsBiarchSuffix = false);
 215
 216     bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,
 217                              const llvm::opt::ArgList &Args,
 218                              StringRef CandidateTriple,
 219                              bool NeedsBiarchSuffix = false);
 220   };
 221
 222 protected:
 223   GCCInstallationDetector GCCInstallation;
 224   CudaInstallationDetector CudaInstallation;
 225
 226 public:
 227   Generic_GCC(const Driver &D, const llvm::Triple &Triple,
 228               const llvm::opt::ArgList &Args);
 229   ~Generic_GCC() override;
 230
 231   void printVerboseInfo(raw_ostream &OS) const override;
 232
 233   bool IsUnwindTablesDefault() const override;
 234   bool isPICDefault() const override;
 235   bool isPIEDefault() const override;
 236   bool isPICDefaultForced() const override;
 237   bool IsIntegratedAssemblerDefault() const override;
 238   llvm::opt::DerivedArgList *
 239   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 240                 Action::OffloadKind DeviceOffloadKind) const override;
 241
 242 protected:
 243   Tool *getTool(Action::ActionClass AC) const override;
 244   Tool *buildAssembler() const override;
 245   Tool *buildLinker() const override;
 246
 247   /// \name ToolChain Implementation Helper Functions
 248   /// @{
 249
 250   /// \brief Check whether the target triple's architecture is 64-bits.
 251   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 252
 253   /// \brief Check whether the target triple's architecture is 32-bits.
 254   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
 255
 256   // FIXME: This should be final, but the Solaris tool chain does weird
 257   // things we can't easily represent.
 258   void AddClangCXXStdlibIncludeArgs(
 259       const llvm::opt::ArgList &DriverArgs,
 260       llvm::opt::ArgStringList &CC1Args) const override;
 261
 262   virtual std::string findLibCxxIncludePath() const;
 263   virtual void
 264   addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
 265                            llvm::opt::ArgStringList &CC1Args) const;
 266
 267   bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple,
 268                                 StringRef GCCMultiarchTriple,
 269                                 StringRef TargetMultiarchTriple,
 270                                 Twine IncludeSuffix,
 271                                 const llvm::opt::ArgList &DriverArgs,
 272                                 llvm::opt::ArgStringList &CC1Args) const;
 273
 274   /// @}
 275
 276 private:
 277   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
 278   mutable std::unique_ptr<tools::gcc::Compiler> Compile;
 279 };
 280
 281 class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
 282 protected:
 283   Tool *buildAssembler() const override;
 284   Tool *buildLinker() const override;
 285   Tool *getTool(Action::ActionClass AC) const override;
 286
 287 private:
 288   mutable std::unique_ptr<tools::darwin::Lipo> Lipo;
 289   mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil;
 290   mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug;
 291
 292 public:
 293   MachO(const Driver &D, const llvm::Triple &Triple,
 294         const llvm::opt::ArgList &Args);
 295   ~MachO() override;
 296
 297   /// @name MachO specific toolchain API
 298   /// {
 299
 300   /// Get the "MachO" arch name for a particular compiler invocation. For
 301   /// example, Apple treats different ARM variations as distinct architectures.
 302   StringRef getMachOArchName(const llvm::opt::ArgList &Args) const;
 303
 304   /// Add the linker arguments to link the ARC runtime library.
 305   virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 306                               llvm::opt::ArgStringList &CmdArgs) const {}
 307
 308   /// Add the linker arguments to link the compiler runtime library.
 309   virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 310                                      llvm::opt::ArgStringList &CmdArgs) const;
 311
 312   virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 313                                       llvm::opt::ArgStringList &CmdArgs) const {
 314   }
 315
 316   virtual void addMinVersionArgs(const llvm::opt::ArgList &Args,
 317                                  llvm::opt::ArgStringList &CmdArgs) const {}
 318
 319   /// On some iOS platforms, kernel and kernel modules were built statically. Is
 320   /// this such a target?
 321   virtual bool isKernelStatic() const { return false; }
 322
 323   /// Is the target either iOS or an iOS simulator?
 324   bool isTargetIOSBased() const { return false; }
 325
 326   void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
 327                          llvm::opt::ArgStringList &CmdArgs,
 328                          StringRef DarwinLibName, bool AlwaysLink = false,
 329                          bool IsEmbedded = false, bool AddRPath = false) const;
 330
 331   /// Add any profiling runtime libraries that are needed. This is essentially a
 332   /// MachO specific version of addProfileRT in Tools.cpp.
 333   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 334                         llvm::opt::ArgStringList &CmdArgs) const override {
 335     // There aren't any profiling libs for embedded targets currently.
 336   }
 337
 338   /// }
 339   /// @name ToolChain Implementation
 340   /// {
 341
 342   types::ID LookupTypeForExtension(StringRef Ext) const override;
 343
 344   bool HasNativeLLVMSupport() const override;
 345
 346   llvm::opt::DerivedArgList *
 347   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 348                 Action::OffloadKind DeviceOffloadKind) const override;
 349
 350   bool IsBlocksDefault() const override {
 351     // Always allow blocks on Apple; users interested in versioning are
 352     // expected to use /usr/include/Block.h.
 353     return true;
 354   }
 355   bool IsIntegratedAssemblerDefault() const override {
 356     // Default integrated assembler to on for Apple's MachO targets.
 357     return true;
 358   }
 359
 360   bool IsMathErrnoDefault() const override { return false; }
 361
 362   bool IsEncodeExtendedBlockSignatureDefault() const override { return true; }
 363
 364   bool IsObjCNonFragileABIDefault() const override {
 365     // Non-fragile ABI is default for everything but i386.
 366     return getTriple().getArch() != llvm::Triple::x86;
 367   }
 368
 369   bool UseObjCMixedDispatch() const override { return true; }
 370
 371   bool IsUnwindTablesDefault() const override;
 372
 373   RuntimeLibType GetDefaultRuntimeLibType() const override {
 374     return ToolChain::RLT_CompilerRT;
 375   }
 376
 377   bool isPICDefault() const override;
 378   bool isPIEDefault() const override;
 379   bool isPICDefaultForced() const override;
 380
 381   bool SupportsProfiling() const override;
 382
 383   bool SupportsObjCGC() const override { return false; }
 384
 385   bool UseDwarfDebugFlags() const override;
 386
 387   bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override {
 388     return false;
 389   }
 390
 391   /// }
 392 };
 393
 394 /// Darwin - The base Darwin tool chain.
 395 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
 396 public:
 397   /// Whether the information on the target has been initialized.
 398   //
 399   // FIXME: This should be eliminated. What we want to do is make this part of
 400   // the "default target for arguments" selection process, once we get out of
 401   // the argument translation business.
 402   mutable bool TargetInitialized;
 403
 404   enum DarwinPlatformKind {
 405     MacOS,
 406     IPhoneOS,
 407     IPhoneOSSimulator,
 408     TvOS,
 409     TvOSSimulator,
 410     WatchOS,
 411     WatchOSSimulator
 412   };
 413
 414   mutable DarwinPlatformKind TargetPlatform;
 415
 416   /// The OS version we are targeting.
 417   mutable VersionTuple TargetVersion;
 418
 419   CudaInstallationDetector CudaInstallation;
 420
 421 private:
 422   void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
 423
 424 public:
 425   Darwin(const Driver &D, const llvm::Triple &Triple,
 426          const llvm::opt::ArgList &Args);
 427   ~Darwin() override;
 428
 429   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 430                                           types::ID InputType) const override;
 431
 432   /// @name Apple Specific Toolchain Implementation
 433   /// {
 434
 435   void addMinVersionArgs(const llvm::opt::ArgList &Args,
 436                          llvm::opt::ArgStringList &CmdArgs) const override;
 437
 438   void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 439                               llvm::opt::ArgStringList &CmdArgs) const override;
 440
 441   bool isKernelStatic() const override {
 442     return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
 443             !isTargetWatchOS());
 444   }
 445
 446   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 447                         llvm::opt::ArgStringList &CmdArgs) const override;
 448
 449 protected:
 450   /// }
 451   /// @name Darwin specific Toolchain functions
 452   /// {
 453
 454   // FIXME: Eliminate these ...Target functions and derive separate tool chains
 455   // for these targets and put version in constructor.
 456   void setTarget(DarwinPlatformKind Platform, unsigned Major, unsigned Minor,
 457                  unsigned Micro) const {
 458     // FIXME: For now, allow reinitialization as long as values don't
 459     // change. This will go away when we move away from argument translation.
 460     if (TargetInitialized && TargetPlatform == Platform &&
 461         TargetVersion == VersionTuple(Major, Minor, Micro))
 462       return;
 463
 464     assert(!TargetInitialized && "Target already initialized!");
 465     TargetInitialized = true;
 466     TargetPlatform = Platform;
 467     TargetVersion = VersionTuple(Major, Minor, Micro);
 468   }
 469
 470   bool isTargetIPhoneOS() const {
 471     assert(TargetInitialized && "Target not initialized!");
 472     return TargetPlatform == IPhoneOS || TargetPlatform == TvOS;
 473   }
 474
 475   bool isTargetIOSSimulator() const {
 476     assert(TargetInitialized && "Target not initialized!");
 477     return TargetPlatform == IPhoneOSSimulator ||
 478            TargetPlatform == TvOSSimulator;
 479   }
 480
 481   bool isTargetIOSBased() const {
 482     assert(TargetInitialized && "Target not initialized!");
 483     return isTargetIPhoneOS() || isTargetIOSSimulator();
 484   }
 485
 486   bool isTargetTvOS() const {
 487     assert(TargetInitialized && "Target not initialized!");
 488     return TargetPlatform == TvOS;
 489   }
 490
 491   bool isTargetTvOSSimulator() const {
 492     assert(TargetInitialized && "Target not initialized!");
 493     return TargetPlatform == TvOSSimulator;
 494   }
 495
 496   bool isTargetTvOSBased() const {
 497     assert(TargetInitialized && "Target not initialized!");
 498     return TargetPlatform == TvOS || TargetPlatform == TvOSSimulator;
 499   }
 500
 501   bool isTargetWatchOS() const {
 502     assert(TargetInitialized && "Target not initialized!");
 503     return TargetPlatform == WatchOS;
 504   }
 505
 506   bool isTargetWatchOSSimulator() const {
 507     assert(TargetInitialized && "Target not initialized!");
 508     return TargetPlatform == WatchOSSimulator;
 509   }
 510
 511   bool isTargetWatchOSBased() const {
 512     assert(TargetInitialized && "Target not initialized!");
 513     return TargetPlatform == WatchOS || TargetPlatform == WatchOSSimulator;
 514   }
 515
 516   bool isTargetMacOS() const {
 517     assert(TargetInitialized && "Target not initialized!");
 518     return TargetPlatform == MacOS;
 519   }
 520
 521   bool isTargetInitialized() const { return TargetInitialized; }
 522
 523   VersionTuple getTargetVersion() const {
 524     assert(TargetInitialized && "Target not initialized!");
 525     return TargetVersion;
 526   }
 527
 528   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
 529                            unsigned V2 = 0) const {
 530     assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
 531     return TargetVersion < VersionTuple(V0, V1, V2);
 532   }
 533
 534   bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
 535     assert(isTargetMacOS() && "Unexpected call for non OS X target!");
 536     return TargetVersion < VersionTuple(V0, V1, V2);
 537   }
 538
 539   StringRef getPlatformFamily() const;
 540   static StringRef getSDKName(StringRef isysroot);
 541   StringRef getOSLibraryNameSuffix() const;
 542
 543 public:
 544   /// }
 545   /// @name ToolChain Implementation
 546   /// {
 547
 548   // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
 549   // most development is done against SDKs, so compiling for a different
 550   // architecture should not get any special treatment.
 551   bool isCrossCompiling() const override { return false; }
 552
 553   llvm::opt::DerivedArgList *
 554   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 555                 Action::OffloadKind DeviceOffloadKind) const override;
 556
 557   CXXStdlibType GetDefaultCXXStdlibType() const override;
 558   ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
 559   bool hasBlocksRuntime() const override;
 560
 561   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 562                           llvm::opt::ArgStringList &CC1Args) const override;
 563
 564   bool UseObjCMixedDispatch() const override {
 565     // This is only used with the non-fragile ABI and non-legacy dispatch.
 566
 567     // Mixed dispatch is used everywhere except OS X before 10.6.
 568     return !(isTargetMacOS() && isMacosxVersionLT(10, 6));
 569   }
 570
 571   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 572     // Stack protectors default to on for user code on 10.5,
 573     // and for everything in 10.6 and beyond
 574     if (isTargetIOSBased() || isTargetWatchOSBased())
 575       return 1;
 576     else if (isTargetMacOS() && !isMacosxVersionLT(10, 6))
 577       return 1;
 578     else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
 579       return 1;
 580
 581     return 0;
 582   }
 583
 584   bool SupportsObjCGC() const override;
 585
 586   void CheckObjCARC() const override;
 587
 588   bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override;
 589
 590   bool SupportsEmbeddedBitcode() const override;
 591
 592   SanitizerMask getSupportedSanitizers() const override;
 593
 594   void printVerboseInfo(raw_ostream &OS) const override;
 595 };
 596
 597 /// DarwinClang - The Darwin toolchain used by Clang.
 598 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
 599 public:
 600   DarwinClang(const Driver &D, const llvm::Triple &Triple,
 601               const llvm::opt::ArgList &Args);
 602
 603   /// @name Apple ToolChain Implementation
 604   /// {
 605
 606   RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
 607
 608   void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 609                              llvm::opt::ArgStringList &CmdArgs) const override;
 610
 611   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 612                            llvm::opt::ArgStringList &CmdArgs) const override;
 613
 614   void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
 615                         llvm::opt::ArgStringList &CmdArgs) const override;
 616
 617   void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
 618
 619   void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 620                       llvm::opt::ArgStringList &CmdArgs) const override;
 621
 622   unsigned GetDefaultDwarfVersion() const override;
 623   // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
 624   // Darwin defaults to standalone/full debug info.
 625   bool GetDefaultStandaloneDebug() const override { return true; }
 626   llvm::DebuggerKind getDefaultDebuggerTuning() const override {
 627     return llvm::DebuggerKind::LLDB;
 628   }
 629
 630   /// }
 631
 632 private:
 633   void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
 634                                llvm::opt::ArgStringList &CmdArgs,
 635                                StringRef Sanitizer) const;
 636 };
 637
 638 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
 639   virtual void anchor();
 640
 641 public:
 642   Generic_ELF(const Driver &D, const llvm::Triple &Triple,
 643               const llvm::opt::ArgList &Args)
 644       : Generic_GCC(D, Triple, Args) {}
 645
 646   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 647                              llvm::opt::ArgStringList &CC1Args) const override;
 648 };
 649
 650 class LLVM_LIBRARY_VISIBILITY CloudABI : public Generic_ELF {
 651 public:
 652   CloudABI(const Driver &D, const llvm::Triple &Triple,
 653            const llvm::opt::ArgList &Args);
 654   bool HasNativeLLVMSupport() const override { return true; }
 655
 656   bool IsMathErrnoDefault() const override { return false; }
 657   bool IsObjCNonFragileABIDefault() const override { return true; }
 658
 659   CXXStdlibType
 660   GetCXXStdlibType(const llvm::opt::ArgList &Args) const override {
 661     return ToolChain::CST_Libcxx;
 662   }
 663   std::string findLibCxxIncludePath() const override;
 664   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 665                            llvm::opt::ArgStringList &CmdArgs) const override;
 666
 667   bool isPIEDefault() const override;
 668   SanitizerMask getSupportedSanitizers() const override;
 669   SanitizerMask getDefaultSanitizers() const override;
 670
 671 protected:
 672   Tool *buildLinker() const override;
 673 };
 674
 675 class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
 676 public:
 677   Solaris(const Driver &D, const llvm::Triple &Triple,
 678           const llvm::opt::ArgList &Args);
 679
 680   bool IsIntegratedAssemblerDefault() const override { return true; }
 681
 682   void AddClangCXXStdlibIncludeArgs(
 683       const llvm::opt::ArgList &DriverArgs,
 684       llvm::opt::ArgStringList &CC1Args) const override;
 685
 686   unsigned GetDefaultDwarfVersion() const override { return 2; }
 687
 688 protected:
 689   Tool *buildAssembler() const override;
 690   Tool *buildLinker() const override;
 691 };
 692
 693 class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
 694 public:
 695   MinGW(const Driver &D, const llvm::Triple &Triple,
 696         const llvm::opt::ArgList &Args);
 697
 698   bool IsIntegratedAssemblerDefault() const override;
 699   bool IsUnwindTablesDefault() const override;
 700   bool isPICDefault() const override;
 701   bool isPIEDefault() const override;
 702   bool isPICDefaultForced() const override;
 703   bool UseSEHExceptions() const;
 704
 705   void
 706   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 707                             llvm::opt::ArgStringList &CC1Args) const override;
 708   void AddClangCXXStdlibIncludeArgs(
 709       const llvm::opt::ArgList &DriverArgs,
 710       llvm::opt::ArgStringList &CC1Args) const override;
 711
 712   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 713                           llvm::opt::ArgStringList &CC1Args) const override;
 714
 715   void printVerboseInfo(raw_ostream &OS) const override;
 716
 717 protected:
 718   Tool *getTool(Action::ActionClass AC) const override;
 719   Tool *buildLinker() const override;
 720   Tool *buildAssembler() const override;
 721
 722 private:
 723   CudaInstallationDetector CudaInstallation;
 724
 725   std::string Base;
 726   std::string GccLibDir;
 727   std::string Ver;
 728   std::string Arch;
 729   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor;
 730   mutable std::unique_ptr<tools::gcc::Compiler> Compiler;
 731   void findGccLibDir();
 732 };
 733
 734 class LLVM_LIBRARY_VISIBILITY Haiku : public Generic_ELF {
 735 public:
 736   Haiku(const Driver &D, const llvm::Triple &Triple,
 737           const llvm::opt::ArgList &Args);
 738
 739   bool isPIEDefault() const override {
 740     return getTriple().getArch() == llvm::Triple::x86_64;
 741   }
 742
 743   std::string findLibCxxIncludePath() const override;
 744   void addLibStdCxxIncludePaths(
 745       const llvm::opt::ArgList &DriverArgs,
 746       llvm::opt::ArgStringList &CC1Args) const override;
 747 };
 748
 749 class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
 750 public:
 751   OpenBSD(const Driver &D, const llvm::Triple &Triple,
 752           const llvm::opt::ArgList &Args);
 753
 754   bool IsMathErrnoDefault() const override { return false; }
 755   bool IsObjCNonFragileABIDefault() const override { return true; }
 756   bool isPIEDefault() const override { return true; }
 757
 758   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 759     return 2;
 760   }
 761   unsigned GetDefaultDwarfVersion() const override { return 2; }
 762
 763 protected:
 764   Tool *buildAssembler() const override;
 765   Tool *buildLinker() const override;
 766 };
 767
 768 class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
 769 public:
 770   Bitrig(const Driver &D, const llvm::Triple &Triple,
 771          const llvm::opt::ArgList &Args);
 772
 773   bool IsMathErrnoDefault() const override { return false; }
 774   bool IsObjCNonFragileABIDefault() const override { return true; }
 775
 776   CXXStdlibType GetDefaultCXXStdlibType() const override;
 777   void addLibStdCxxIncludePaths(
 778       const llvm::opt::ArgList &DriverArgs,
 779       llvm::opt::ArgStringList &CC1Args) const override;
 780   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 781                            llvm::opt::ArgStringList &CmdArgs) const override;
 782   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 783     return 1;
 784   }
 785
 786 protected:
 787   Tool *buildAssembler() const override;
 788   Tool *buildLinker() const override;
 789 };
 790
 791 class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
 792 public:
 793   FreeBSD(const Driver &D, const llvm::Triple &Triple,
 794           const llvm::opt::ArgList &Args);
 795   bool HasNativeLLVMSupport() const override;
 796
 797   bool IsMathErrnoDefault() const override { return false; }
 798   bool IsObjCNonFragileABIDefault() const override { return true; }
 799
 800   CXXStdlibType GetDefaultCXXStdlibType() const override;
 801   void addLibStdCxxIncludePaths(
 802       const llvm::opt::ArgList &DriverArgs,
 803       llvm::opt::ArgStringList &CC1Args) const override;
 804   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 805                            llvm::opt::ArgStringList &CmdArgs) const override;
 806
 807   bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override;
 808   bool isPIEDefault() const override;
 809   SanitizerMask getSupportedSanitizers() const override;
 810   unsigned GetDefaultDwarfVersion() const override { return 2; }
 811   // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
 812   // FreeBSD defaults to standalone/full debug info.
 813   bool GetDefaultStandaloneDebug() const override { return true; }
 814
 815 protected:
 816   Tool *buildAssembler() const override;
 817   Tool *buildLinker() const override;
 818 };
 819
 820 class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
 821 public:
 822   NetBSD(const Driver &D, const llvm::Triple &Triple,
 823          const llvm::opt::ArgList &Args);
 824
 825   bool IsMathErrnoDefault() const override { return false; }
 826   bool IsObjCNonFragileABIDefault() const override { return true; }
 827
 828   CXXStdlibType GetDefaultCXXStdlibType() const override;
 829
 830   std::string findLibCxxIncludePath() const override;
 831   void addLibStdCxxIncludePaths(
 832       const llvm::opt::ArgList &DriverArgs,
 833       llvm::opt::ArgStringList &CC1Args) const override;
 834
 835   bool IsUnwindTablesDefault() const override { return true; }
 836
 837 protected:
 838   Tool *buildAssembler() const override;
 839   Tool *buildLinker() const override;
 840 };
 841
 842 class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
 843 public:
 844   Minix(const Driver &D, const llvm::Triple &Triple,
 845         const llvm::opt::ArgList &Args);
 846
 847 protected:
 848   Tool *buildAssembler() const override;
 849   Tool *buildLinker() const override;
 850 };
 851
 852 class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
 853 public:
 854   DragonFly(const Driver &D, const llvm::Triple &Triple,
 855             const llvm::opt::ArgList &Args);
 856
 857   bool IsMathErrnoDefault() const override { return false; }
 858
 859 protected:
 860   Tool *buildAssembler() const override;
 861   Tool *buildLinker() const override;
 862 };
 863
 864 class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
 865 public:
 866   Linux(const Driver &D, const llvm::Triple &Triple,
 867         const llvm::opt::ArgList &Args);
 868
 869   bool HasNativeLLVMSupport() const override;
 870
 871   void
 872   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 873                             llvm::opt::ArgStringList &CC1Args) const override;
 874   std::string findLibCxxIncludePath() const override;
 875   void addLibStdCxxIncludePaths(
 876       const llvm::opt::ArgList &DriverArgs,
 877       llvm::opt::ArgStringList &CC1Args) const override;
 878   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 879                           llvm::opt::ArgStringList &CC1Args) const override;
 880   void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 881                            llvm::opt::ArgStringList &CC1Args) const override;
 882   bool isPIEDefault() const override;
 883   SanitizerMask getSupportedSanitizers() const override;
 884   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 885                         llvm::opt::ArgStringList &CmdArgs) const override;
 886   virtual std::string computeSysRoot() const;
 887
 888   virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const;
 889
 890   std::vector<std::string> ExtraOpts;
 891
 892 protected:
 893   Tool *buildAssembler() const override;
 894   Tool *buildLinker() const override;
 895 };
 896
 897 class LLVM_LIBRARY_VISIBILITY CudaToolChain : public ToolChain {
 898 public:
 899   CudaToolChain(const Driver &D, const llvm::Triple &Triple,
 900                 const ToolChain &HostTC, const llvm::opt::ArgList &Args);
 901
 902   virtual const llvm::Triple *getAuxTriple() const override {
 903     return &HostTC.getTriple();
 904   }
 905
 906   llvm::opt::DerivedArgList *
 907   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 908                 Action::OffloadKind DeviceOffloadKind) const override;
 909   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 910                              llvm::opt::ArgStringList &CC1Args) const override;
 911
 912   // Never try to use the integrated assembler with CUDA; always fork out to
 913   // ptxas.
 914   bool useIntegratedAs() const override { return false; }
 915   bool isCrossCompiling() const override { return true; }
 916   bool isPICDefault() const override { return false; }
 917   bool isPIEDefault() const override { return false; }
 918   bool isPICDefaultForced() const override { return false; }
 919   bool SupportsProfiling() const override { return false; }
 920   bool SupportsObjCGC() const override { return false; }
 921
 922   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 923                           llvm::opt::ArgStringList &CC1Args) const override;
 924
 925   void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
 926   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 927   void
 928   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 929                             llvm::opt::ArgStringList &CC1Args) const override;
 930   void AddClangCXXStdlibIncludeArgs(
 931       const llvm::opt::ArgList &Args,
 932       llvm::opt::ArgStringList &CC1Args) const override;
 933   void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 934                            llvm::opt::ArgStringList &CC1Args) const override;
 935
 936   SanitizerMask getSupportedSanitizers() const override;
 937
 938   VersionTuple
 939   computeMSVCVersion(const Driver *D,
 940                      const llvm::opt::ArgList &Args) const override;
 941
 942   const ToolChain &HostTC;
 943   CudaInstallationDetector CudaInstallation;
 944
 945 protected:
 946   Tool *buildAssembler() const override;  // ptxas
 947   Tool *buildLinker() const override;     // fatbinary (ok, not really a linker)
 948 };
 949
 950 class LLVM_LIBRARY_VISIBILITY MipsLLVMToolChain : public Linux {
 951 protected:
 952   Tool *buildLinker() const override;
 953
 954 public:
 955   MipsLLVMToolChain(const Driver &D, const llvm::Triple &Triple,
 956                     const llvm::opt::ArgList &Args);
 957
 958   void
 959   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 960                             llvm::opt::ArgStringList &CC1Args) const override;
 961
 962   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 963
 964   std::string findLibCxxIncludePath() const override;
 965
 966   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 967                            llvm::opt::ArgStringList &CmdArgs) const override;
 968
 969   std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component,
 970                             bool Shared = false) const override;
 971
 972   std::string computeSysRoot() const override;
 973
 974   RuntimeLibType GetDefaultRuntimeLibType() const override {
 975     return GCCInstallation.isValid() ? RuntimeLibType::RLT_Libgcc
 976                                      : RuntimeLibType::RLT_CompilerRT;
 977   }
 978
 979   const char *getDefaultLinker() const override {
 980     return "lld";
 981   }
 982
 983 private:
 984   Multilib SelectedMultilib;
 985   std::string LibSuffix;
 986 };
 987
 988 class LLVM_LIBRARY_VISIBILITY LanaiToolChain : public Generic_ELF {
 989 public:
 990   LanaiToolChain(const Driver &D, const llvm::Triple &Triple,
 991                  const llvm::opt::ArgList &Args)
 992       : Generic_ELF(D, Triple, Args) {}
 993
 994   // No support for finding a C++ standard library yet.
 995   std::string findLibCxxIncludePath() const override { return ""; }
 996   void addLibStdCxxIncludePaths(
 997       const llvm::opt::ArgList &DriverArgs,
 998       llvm::opt::ArgStringList &CC1Args) const override {}
 999
1000   bool IsIntegratedAssemblerDefault() const override { return true; }
1001 };
1002
1003 class LLVM_LIBRARY_VISIBILITY HexagonToolChain : public Linux {
1004 protected:
1005   GCCVersion GCCLibAndIncVersion;
1006   Tool *buildAssembler() const override;
1007   Tool *buildLinker() const override;
1008
1009 public:
1010   HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
1011                    const llvm::opt::ArgList &Args);
1012   ~HexagonToolChain() override;
1013
1014   void
1015   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1016                             llvm::opt::ArgStringList &CC1Args) const override;
1017   void addLibStdCxxIncludePaths(
1018       const llvm::opt::ArgList &DriverArgs,
1019       llvm::opt::ArgStringList &CC1Args) const override;
1020   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
1021
1022   StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; }
1023   bool IsIntegratedAssemblerDefault() const override {
1024     return true;
1025   }
1026
1027   std::string getHexagonTargetDir(
1028       const std::string &InstalledDir,
1029       const SmallVectorImpl<std::string> &PrefixDirs) const;
1030   void getHexagonLibraryPaths(const llvm::opt::ArgList &Args,
1031       ToolChain::path_list &LibPaths) const;
1032
1033   static const StringRef GetDefaultCPU();
1034   static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args);
1035
1036   static Optional<unsigned> getSmallDataThreshold(
1037       const llvm::opt::ArgList &Args);
1038 };
1039
1040 class LLVM_LIBRARY_VISIBILITY AMDGPUToolChain : public Generic_ELF {
1041 protected:
1042   Tool *buildLinker() const override;
1043
1044 public:
1045   AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
1046             const llvm::opt::ArgList &Args);
1047   unsigned GetDefaultDwarfVersion() const override { return 2; }
1048   bool IsIntegratedAssemblerDefault() const override { return true; }
1049 };
1050
1051 class LLVM_LIBRARY_VISIBILITY NaClToolChain : public Generic_ELF {
1052 public:
1053   NaClToolChain(const Driver &D, const llvm::Triple &Triple,
1054                 const llvm::opt::ArgList &Args);
1055
1056   void
1057   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1058                             llvm::opt::ArgStringList &CC1Args) const override;
1059   std::string findLibCxxIncludePath() const override;
1060
1061   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
1062
1063   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
1064                            llvm::opt::ArgStringList &CmdArgs) const override;
1065
1066   bool IsIntegratedAssemblerDefault() const override {
1067     return getTriple().getArch() == llvm::Triple::mipsel;
1068   }
1069
1070   // Get the path to the file containing NaCl's ARM macros.
1071   // It lives in NaClToolChain because the ARMAssembler tool needs a
1072   // const char * that it can pass around,
1073   const char *GetNaClArmMacrosPath() const { return NaClArmMacrosPath.c_str(); }
1074
1075   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
1076                                           types::ID InputType) const override;
1077
1078 protected:
1079   Tool *buildLinker() const override;
1080   Tool *buildAssembler() const override;
1081
1082 private:
1083   std::string NaClArmMacrosPath;
1084 };
1085
1086 class LLVM_LIBRARY_VISIBILITY Fuchsia : public Generic_ELF {
1087 public:
1088   Fuchsia(const Driver &D, const llvm::Triple &Triple,
1089           const llvm::opt::ArgList &Args);
1090
1091   bool isPIEDefault() const override { return true; }
1092   bool HasNativeLLVMSupport() const override { return true; }
1093   bool IsIntegratedAssemblerDefault() const override { return true; }
1094   llvm::DebuggerKind getDefaultDebuggerTuning() const override {
1095     return llvm::DebuggerKind::GDB;
1096   }
1097
1098   RuntimeLibType
1099   GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
1100   CXXStdlibType
1101   GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
1102
1103   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1104                              llvm::opt::ArgStringList &CC1Args) const override;
1105   void
1106   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1107                             llvm::opt::ArgStringList &CC1Args) const override;
1108   std::string findLibCxxIncludePath() const override;
1109   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
1110                            llvm::opt::ArgStringList &CmdArgs) const override;
1111
1112   const char *getDefaultLinker() const override {
1113     return "lld";
1114   }
1115
1116 protected:
1117   Tool *buildAssembler() const override;
1118   Tool *buildLinker() const override;
1119 };
1120
1121 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1122 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1123 class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
1124 public:
1125   TCEToolChain(const Driver &D, const llvm::Triple &Triple,
1126                const llvm::opt::ArgList &Args);
1127   ~TCEToolChain() override;
1128
1129   bool IsMathErrnoDefault() const override;
1130   bool isPICDefault() const override;
1131   bool isPIEDefault() const override;
1132   bool isPICDefaultForced() const override;
1133 };
1134
1135 /// Toolchain for little endian TCE cores.
1136 class LLVM_LIBRARY_VISIBILITY TCELEToolChain : public TCEToolChain {
1137 public:
1138   TCELEToolChain(const Driver &D, const llvm::Triple &Triple,
1139                  const llvm::opt::ArgList &Args);
1140   ~TCELEToolChain() override;
1141 };
1142
1143 class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
1144 public:
1145   MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
1146                 const llvm::opt::ArgList &Args);
1147
1148   llvm::opt::DerivedArgList *
1149   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
1150                 Action::OffloadKind DeviceOffloadKind) const override;
1151
1152   bool IsIntegratedAssemblerDefault() const override;
1153   bool IsUnwindTablesDefault() const override;
1154   bool isPICDefault() const override;
1155   bool isPIEDefault() const override;
1156   bool isPICDefaultForced() const override;
1157
1158   void
1159   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1160                             llvm::opt::ArgStringList &CC1Args) const override;
1161   void AddClangCXXStdlibIncludeArgs(
1162       const llvm::opt::ArgList &DriverArgs,
1163       llvm::opt::ArgStringList &CC1Args) const override;
1164
1165   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1166                           llvm::opt::ArgStringList &CC1Args) const override;
1167
1168   bool getWindowsSDKDir(std::string &path, int &major,
1169                         std::string &windowsSDKIncludeVersion,
1170                         std::string &windowsSDKLibVersion) const;
1171   bool getWindowsSDKLibraryPath(std::string &path) const;
1172   /// \brief Check if Universal CRT should be used if available
1173   bool useUniversalCRT(std::string &visualStudioDir) const;
1174   bool getUniversalCRTSdkDir(std::string &path, std::string &ucrtVersion) const;
1175   bool getUniversalCRTLibraryPath(std::string &path) const;
1176   bool getVisualStudioInstallDir(std::string &path) const;
1177   bool getVisualStudioBinariesFolder(const char *clangProgramPath,
1178                                      std::string &path) const;
1179   VersionTuple
1180   computeMSVCVersion(const Driver *D,
1181                      const llvm::opt::ArgList &Args) const override;
1182
1183   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
1184                                           types::ID InputType) const override;
1185   SanitizerMask getSupportedSanitizers() const override;
1186
1187   void printVerboseInfo(raw_ostream &OS) const override;
1188
1189 protected:
1190   void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs,
1191                                      llvm::opt::ArgStringList &CC1Args,
1192                                      const std::string &folder,
1193                                      const Twine &subfolder1,
1194                                      const Twine &subfolder2 = "",
1195                                      const Twine &subfolder3 = "") const;
1196
1197   Tool *buildLinker() const override;
1198   Tool *buildAssembler() const override;
1199 private:
1200   VersionTuple getMSVCVersionFromTriple() const;
1201   VersionTuple getMSVCVersionFromExe() const;
1202
1203   CudaInstallationDetector CudaInstallation;
1204 };
1205
1206 class LLVM_LIBRARY_VISIBILITY CrossWindowsToolChain : public Generic_GCC {
1207 public:
1208   CrossWindowsToolChain(const Driver &D, const llvm::Triple &T,
1209                         const llvm::opt::ArgList &Args);
1210
1211   bool IsIntegratedAssemblerDefault() const override { return true; }
1212   bool IsUnwindTablesDefault() const override;
1213   bool isPICDefault() const override;
1214   bool isPIEDefault() const override;
1215   bool isPICDefaultForced() const override;
1216
1217   unsigned int GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
1218     return 0;
1219   }
1220
1221   void
1222   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1223                             llvm::opt::ArgStringList &CC1Args) const override;
1224   void AddClangCXXStdlibIncludeArgs(
1225       const llvm::opt::ArgList &DriverArgs,
1226       llvm::opt::ArgStringList &CC1Args) const override;
1227   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
1228                            llvm::opt::ArgStringList &CmdArgs) const override;
1229
1230   SanitizerMask getSupportedSanitizers() const override;
1231
1232 protected:
1233   Tool *buildLinker() const override;
1234   Tool *buildAssembler() const override;
1235 };
1236
1237 class LLVM_LIBRARY_VISIBILITY XCoreToolChain : public ToolChain {
1238 public:
1239   XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
1240                  const llvm::opt::ArgList &Args);
1241
1242 protected:
1243   Tool *buildAssembler() const override;
1244   Tool *buildLinker() const override;
1245
1246 public:
1247   bool isPICDefault() const override;
1248   bool isPIEDefault() const override;
1249   bool isPICDefaultForced() const override;
1250   bool SupportsProfiling() const override;
1251   bool hasBlocksRuntime() const override;
1252   void
1253   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1254                             llvm::opt::ArgStringList &CC1Args) const override;
1255   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1256                              llvm::opt::ArgStringList &CC1Args) const override;
1257   void AddClangCXXStdlibIncludeArgs(
1258       const llvm::opt::ArgList &DriverArgs,
1259       llvm::opt::ArgStringList &CC1Args) const override;
1260   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
1261                            llvm::opt::ArgStringList &CmdArgs) const override;
1262 };
1263
1264 /// MyriadToolChain - A tool chain using either clang or the external compiler
1265 /// installed by the Movidius SDK to perform all subcommands.
1266 class LLVM_LIBRARY_VISIBILITY MyriadToolChain : public Generic_ELF {
1267 public:
1268   MyriadToolChain(const Driver &D, const llvm::Triple &Triple,
1269                   const llvm::opt::ArgList &Args);
1270   ~MyriadToolChain() override;
1271
1272   void
1273   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
1274                             llvm::opt::ArgStringList &CC1Args) const override;
1275   std::string findLibCxxIncludePath() const override;
1276   void addLibStdCxxIncludePaths(
1277       const llvm::opt::ArgList &DriverArgs,
1278       llvm::opt::ArgStringList &CC1Args) const override;
1279   Tool *SelectTool(const JobAction &JA) const override;
1280   unsigned GetDefaultDwarfVersion() const override { return 2; }
1281   SanitizerMask getSupportedSanitizers() const override;
1282
1283 protected:
1284   Tool *buildLinker() const override;
1285   bool isShaveCompilation(const llvm::Triple &T) const {
1286     return T.getArch() == llvm::Triple::shave;
1287   }
1288
1289 private:
1290   mutable std::unique_ptr<Tool> Compiler;
1291   mutable std::unique_ptr<Tool> Assembler;
1292 };
1293
1294 class LLVM_LIBRARY_VISIBILITY WebAssembly final : public ToolChain {
1295 public:
1296   WebAssembly(const Driver &D, const llvm::Triple &Triple,
1297               const llvm::opt::ArgList &Args);
1298
1299 private:
1300   bool IsMathErrnoDefault() const override;
1301   bool IsObjCNonFragileABIDefault() const override;
1302   bool UseObjCMixedDispatch() const override;
1303   bool isPICDefault() const override;
1304   bool isPIEDefault() const override;
1305   bool isPICDefaultForced() const override;
1306   bool IsIntegratedAssemblerDefault() const override;
1307   bool hasBlocksRuntime() const override;
1308   bool SupportsObjCGC() const override;
1309   bool SupportsProfiling() const override;
1310   bool HasNativeLLVMSupport() const override;
1311   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1312                              llvm::opt::ArgStringList &CC1Args) const override;
1313   RuntimeLibType GetDefaultRuntimeLibType() const override;
1314   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
1315   void AddClangSystemIncludeArgs(
1316       const llvm::opt::ArgList &DriverArgs,
1317       llvm::opt::ArgStringList &CC1Args) const override;
1318   void AddClangCXXStdlibIncludeArgs(
1319       const llvm::opt::ArgList &DriverArgs,
1320       llvm::opt::ArgStringList &CC1Args) const override;
1321
1322   const char *getDefaultLinker() const override {
1323     return "lld";
1324   }
1325
1326   Tool *buildLinker() const override;
1327 };
1328
1329 class LLVM_LIBRARY_VISIBILITY PS4CPU : public Generic_ELF {
1330 public:
1331   PS4CPU(const Driver &D, const llvm::Triple &Triple,
1332          const llvm::opt::ArgList &Args);
1333
1334   // No support for finding a C++ standard library yet.
1335   std::string findLibCxxIncludePath() const override { return ""; }
1336   void addLibStdCxxIncludePaths(
1337       const llvm::opt::ArgList &DriverArgs,
1338       llvm::opt::ArgStringList &CC1Args) const override {}
1339
1340   bool IsMathErrnoDefault() const override { return false; }
1341   bool IsObjCNonFragileABIDefault() const override { return true; }
1342   bool HasNativeLLVMSupport() const override;
1343   bool isPICDefault() const override;
1344
1345   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
1346     return 2; // SSPStrong
1347   }
1348
1349   llvm::DebuggerKind getDefaultDebuggerTuning() const override {
1350     return llvm::DebuggerKind::SCE;
1351   }
1352
1353   SanitizerMask getSupportedSanitizers() const override;
1354
1355 protected:
1356   Tool *buildAssembler() const override;
1357   Tool *buildLinker() const override;
1358 };
1359
1360 class LLVM_LIBRARY_VISIBILITY Contiki : public Generic_ELF {
1361 public:
1362   Contiki(const Driver &D, const llvm::Triple &Triple,
1363           const llvm::opt::ArgList &Args);
1364
1365   // No support for finding a C++ standard library yet.
1366   std::string findLibCxxIncludePath() const override { return ""; }
1367   void addLibStdCxxIncludePaths(
1368       const llvm::opt::ArgList &DriverArgs,
1369       llvm::opt::ArgStringList &CC1Args) const override {}
1370
1371   SanitizerMask getSupportedSanitizers() const override;
1372 };
1373
1374 class LLVM_LIBRARY_VISIBILITY AVRToolChain : public Generic_ELF {
1375 protected:
1376   Tool *buildLinker() const override;
1377 public:
1378   AVRToolChain(const Driver &D, const llvm::Triple &Triple,
1379                const llvm::opt::ArgList &Args);
1380   bool IsIntegratedAssemblerDefault() const override { return true; }
1381 };
1382
1383
1384 } // end namespace toolchains
1385 } // end namespace driver
1386 } // end namespace clang
1387
1388 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H