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