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/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 protected:
  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
  82     // FIXME: These might be better as path objects.
  83     std::string GCCInstallPath;
  84     std::string GCCParentLibPath;
  85
  86     /// The primary multilib appropriate for the given flags.
  87     Multilib SelectedMultilib;
  88     /// On Biarch systems, this corresponds to the default multilib when
  89     /// targeting the non-default multilib. Otherwise, it is empty.
  90     llvm::Optional<Multilib> BiarchSibling;
  91
  92     GCCVersion Version;
  93
  94     // We retain the list of install paths that were considered and rejected in
  95     // order to print out detailed information in verbose mode.
  96     std::set<std::string> CandidateGCCInstallPaths;
  97
  98     /// The set of multilibs that the detected installation supports.
  99     MultilibSet Multilibs;
 100
 101   public:
 102     GCCInstallationDetector() : IsValid(false) {}
 103     void init(const Driver &D, const llvm::Triple &TargetTriple,
 104               const llvm::opt::ArgList &Args);
 105
 106     /// \brief Check whether we detected a valid GCC install.
 107     bool isValid() const { return IsValid; }
 108
 109     /// \brief Get the GCC triple for the detected install.
 110     const llvm::Triple &getTriple() const { return GCCTriple; }
 111
 112     /// \brief Get the detected GCC installation path.
 113     StringRef getInstallPath() const { return GCCInstallPath; }
 114
 115     /// \brief Get the detected GCC parent lib path.
 116     StringRef getParentLibPath() const { return GCCParentLibPath; }
 117
 118     /// \brief Get the detected Multilib
 119     const Multilib &getMultilib() const { return SelectedMultilib; }
 120
 121     /// \brief Get the whole MultilibSet
 122     const MultilibSet &getMultilibs() const { return Multilibs; }
 123
 124     /// Get the biarch sibling multilib (if it exists).
 125     /// \return true iff such a sibling exists
 126     bool getBiarchSibling(Multilib &M) const;
 127
 128     /// \brief Get the detected GCC version string.
 129     const GCCVersion &getVersion() const { return Version; }
 130
 131     /// \brief Print information about the detected GCC installation.
 132     void print(raw_ostream &OS) const;
 133
 134   private:
 135     static void
 136     CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
 137                              const llvm::Triple &BiarchTriple,
 138                              SmallVectorImpl<StringRef> &LibDirs,
 139                              SmallVectorImpl<StringRef> &TripleAliases,
 140                              SmallVectorImpl<StringRef> &BiarchLibDirs,
 141                              SmallVectorImpl<StringRef> &BiarchTripleAliases);
 142
 143     void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
 144                                 const llvm::opt::ArgList &Args,
 145                                 const std::string &LibDir,
 146                                 StringRef CandidateTriple,
 147                                 bool NeedsBiarchSuffix = false);
 148   };
 149
 150   GCCInstallationDetector GCCInstallation;
 151
 152 public:
 153   Generic_GCC(const Driver &D, const llvm::Triple &Triple,
 154               const llvm::opt::ArgList &Args);
 155   ~Generic_GCC() override;
 156
 157   void printVerboseInfo(raw_ostream &OS) const override;
 158
 159   bool IsUnwindTablesDefault() const override;
 160   bool isPICDefault() const override;
 161   bool isPIEDefault() const override;
 162   bool isPICDefaultForced() const override;
 163   bool IsIntegratedAssemblerDefault() const override;
 164
 165 protected:
 166   Tool *getTool(Action::ActionClass AC) const override;
 167   Tool *buildAssembler() const override;
 168   Tool *buildLinker() const override;
 169
 170   /// \name ToolChain Implementation Helper Functions
 171   /// @{
 172
 173   /// \brief Check whether the target triple's architecture is 64-bits.
 174   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 175
 176   /// \brief Check whether the target triple's architecture is 32-bits.
 177   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
 178
 179   /// @}
 180
 181 private:
 182   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
 183   mutable std::unique_ptr<tools::gcc::Compiler> Compile;
 184 };
 185
 186 class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
 187 protected:
 188   Tool *buildAssembler() const override;
 189   Tool *buildLinker() const override;
 190   Tool *getTool(Action::ActionClass AC) const override;
 191
 192 private:
 193   mutable std::unique_ptr<tools::darwin::Lipo> Lipo;
 194   mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil;
 195   mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug;
 196
 197 public:
 198   MachO(const Driver &D, const llvm::Triple &Triple,
 199         const llvm::opt::ArgList &Args);
 200   ~MachO() override;
 201
 202   /// @name MachO specific toolchain API
 203   /// {
 204
 205   /// Get the "MachO" arch name for a particular compiler invocation. For
 206   /// example, Apple treats different ARM variations as distinct architectures.
 207   StringRef getMachOArchName(const llvm::opt::ArgList &Args) const;
 208
 209   /// Add the linker arguments to link the ARC runtime library.
 210   virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 211                               llvm::opt::ArgStringList &CmdArgs) const {}
 212
 213   /// Add the linker arguments to link the compiler runtime library.
 214   virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 215                                      llvm::opt::ArgStringList &CmdArgs) const;
 216
 217   virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 218                                       llvm::opt::ArgStringList &CmdArgs) const {
 219   }
 220
 221   virtual void addMinVersionArgs(const llvm::opt::ArgList &Args,
 222                                  llvm::opt::ArgStringList &CmdArgs) const {}
 223
 224   /// On some iOS platforms, kernel and kernel modules were built statically. Is
 225   /// this such a target?
 226   virtual bool isKernelStatic() const { return false; }
 227
 228   /// Is the target either iOS or an iOS simulator?
 229   bool isTargetIOSBased() const { return false; }
 230
 231   void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
 232                          llvm::opt::ArgStringList &CmdArgs,
 233                          StringRef DarwinLibName, bool AlwaysLink = false,
 234                          bool IsEmbedded = false, bool AddRPath = false) const;
 235
 236   /// Add any profiling runtime libraries that are needed. This is essentially a
 237   /// MachO specific version of addProfileRT in Tools.cpp.
 238   virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
 239                                 llvm::opt::ArgStringList &CmdArgs) const {
 240     // There aren't any profiling libs for embedded targets currently.
 241   }
 242
 243   /// }
 244   /// @name ToolChain Implementation
 245   /// {
 246
 247   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 248                                           types::ID InputType) const override;
 249
 250   types::ID LookupTypeForExtension(const char *Ext) const override;
 251
 252   bool HasNativeLLVMSupport() const override;
 253
 254   llvm::opt::DerivedArgList *
 255   TranslateArgs(const llvm::opt::DerivedArgList &Args,
 256                 const char *BoundArch) const override;
 257
 258   bool IsBlocksDefault() const override {
 259     // Always allow blocks on Apple; users interested in versioning are
 260     // expected to use /usr/include/Block.h.
 261     return true;
 262   }
 263   bool IsIntegratedAssemblerDefault() const override {
 264     // Default integrated assembler to on for Apple's MachO targets.
 265     return true;
 266   }
 267
 268   bool IsMathErrnoDefault() const override { return false; }
 269
 270   bool IsEncodeExtendedBlockSignatureDefault() const override { return true; }
 271
 272   bool IsObjCNonFragileABIDefault() const override {
 273     // Non-fragile ABI is default for everything but i386.
 274     return getTriple().getArch() != llvm::Triple::x86;
 275   }
 276
 277   bool UseObjCMixedDispatch() const override { return true; }
 278
 279   bool IsUnwindTablesDefault() const override;
 280
 281   RuntimeLibType GetDefaultRuntimeLibType() const override {
 282     return ToolChain::RLT_CompilerRT;
 283   }
 284
 285   bool isPICDefault() const override;
 286   bool isPIEDefault() const override;
 287   bool isPICDefaultForced() const override;
 288
 289   bool SupportsProfiling() const override;
 290
 291   bool SupportsObjCGC() const override { return false; }
 292
 293   bool UseDwarfDebugFlags() const override;
 294
 295   bool UseSjLjExceptions() const override { return false; }
 296
 297   /// }
 298 };
 299
 300 /// Darwin - The base Darwin tool chain.
 301 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
 302 public:
 303   /// Whether the information on the target has been initialized.
 304   //
 305   // FIXME: This should be eliminated. What we want to do is make this part of
 306   // the "default target for arguments" selection process, once we get out of
 307   // the argument translation business.
 308   mutable bool TargetInitialized;
 309
 310   enum DarwinPlatformKind { MacOS, IPhoneOS, IPhoneOSSimulator };
 311
 312   mutable DarwinPlatformKind TargetPlatform;
 313
 314   /// The OS version we are targeting.
 315   mutable VersionTuple TargetVersion;
 316
 317 private:
 318   void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
 319
 320 public:
 321   Darwin(const Driver &D, const llvm::Triple &Triple,
 322          const llvm::opt::ArgList &Args);
 323   ~Darwin() override;
 324
 325   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 326                                           types::ID InputType) const override;
 327
 328   /// @name Apple Specific Toolchain Implementation
 329   /// {
 330
 331   void addMinVersionArgs(const llvm::opt::ArgList &Args,
 332                          llvm::opt::ArgStringList &CmdArgs) const override;
 333
 334   void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 335                               llvm::opt::ArgStringList &CmdArgs) const override;
 336
 337   bool isKernelStatic() const override {
 338     return !isTargetIPhoneOS() || isIPhoneOSVersionLT(6, 0);
 339   }
 340
 341   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 342                         llvm::opt::ArgStringList &CmdArgs) const override;
 343
 344 protected:
 345   /// }
 346   /// @name Darwin specific Toolchain functions
 347   /// {
 348
 349   // FIXME: Eliminate these ...Target functions and derive separate tool chains
 350   // for these targets and put version in constructor.
 351   void setTarget(DarwinPlatformKind Platform, unsigned Major, unsigned Minor,
 352                  unsigned Micro) const {
 353     // FIXME: For now, allow reinitialization as long as values don't
 354     // change. This will go away when we move away from argument translation.
 355     if (TargetInitialized && TargetPlatform == Platform &&
 356         TargetVersion == VersionTuple(Major, Minor, Micro))
 357       return;
 358
 359     assert(!TargetInitialized && "Target already initialized!");
 360     TargetInitialized = true;
 361     TargetPlatform = Platform;
 362     TargetVersion = VersionTuple(Major, Minor, Micro);
 363   }
 364
 365   bool isTargetIPhoneOS() const {
 366     assert(TargetInitialized && "Target not initialized!");
 367     return TargetPlatform == IPhoneOS;
 368   }
 369
 370   bool isTargetIOSSimulator() const {
 371     assert(TargetInitialized && "Target not initialized!");
 372     return TargetPlatform == IPhoneOSSimulator;
 373   }
 374
 375   bool isTargetIOSBased() const {
 376     assert(TargetInitialized && "Target not initialized!");
 377     return isTargetIPhoneOS() || isTargetIOSSimulator();
 378   }
 379
 380   bool isTargetMacOS() const {
 381     assert(TargetInitialized && "Target not initialized!");
 382     return TargetPlatform == MacOS;
 383   }
 384
 385   bool isTargetInitialized() const { return TargetInitialized; }
 386
 387   VersionTuple getTargetVersion() const {
 388     assert(TargetInitialized && "Target not initialized!");
 389     return TargetVersion;
 390   }
 391
 392   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
 393                            unsigned V2 = 0) const {
 394     assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
 395     return TargetVersion < VersionTuple(V0, V1, V2);
 396   }
 397
 398   bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
 399     assert(isTargetMacOS() && "Unexpected call for non OS X target!");
 400     return TargetVersion < VersionTuple(V0, V1, V2);
 401   }
 402
 403 public:
 404   /// }
 405   /// @name ToolChain Implementation
 406   /// {
 407
 408   // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
 409   // most development is done against SDKs, so compiling for a different
 410   // architecture should not get any special treatment.
 411   bool isCrossCompiling() const override { return false; }
 412
 413   llvm::opt::DerivedArgList *
 414   TranslateArgs(const llvm::opt::DerivedArgList &Args,
 415                 const char *BoundArch) const override;
 416
 417   ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
 418   bool hasBlocksRuntime() const override;
 419
 420   bool UseObjCMixedDispatch() const override {
 421     // This is only used with the non-fragile ABI and non-legacy dispatch.
 422
 423     // Mixed dispatch is used everywhere except OS X before 10.6.
 424     return !(isTargetMacOS() && isMacosxVersionLT(10, 6));
 425   }
 426
 427   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 428     // Stack protectors default to on for user code on 10.5,
 429     // and for everything in 10.6 and beyond
 430     if (isTargetIOSBased())
 431       return 1;
 432     else if (isTargetMacOS() && !isMacosxVersionLT(10, 6))
 433       return 1;
 434     else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
 435       return 1;
 436
 437     return 0;
 438   }
 439
 440   bool SupportsObjCGC() const override;
 441
 442   void CheckObjCARC() const override;
 443
 444   bool UseSjLjExceptions() const override;
 445
 446   SanitizerMask getSupportedSanitizers() const override;
 447 };
 448
 449 /// DarwinClang - The Darwin toolchain used by Clang.
 450 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
 451 public:
 452   DarwinClang(const Driver &D, const llvm::Triple &Triple,
 453               const llvm::opt::ArgList &Args);
 454
 455   /// @name Apple ToolChain Implementation
 456   /// {
 457
 458   void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 459                              llvm::opt::ArgStringList &CmdArgs) const override;
 460
 461   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 462                            llvm::opt::ArgStringList &CmdArgs) const override;
 463
 464   void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
 465                         llvm::opt::ArgStringList &CmdArgs) const override;
 466
 467   void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
 468
 469   void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 470                       llvm::opt::ArgStringList &CmdArgs) const override;
 471   /// }
 472
 473 private:
 474   void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
 475                                llvm::opt::ArgStringList &CmdArgs,
 476                                StringRef Sanitizer) const;
 477 };
 478
 479 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
 480   virtual void anchor();
 481
 482 public:
 483   Generic_ELF(const Driver &D, const llvm::Triple &Triple,
 484               const llvm::opt::ArgList &Args)
 485       : Generic_GCC(D, Triple, Args) {}
 486
 487   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 488                              llvm::opt::ArgStringList &CC1Args) const override;
 489 };
 490
 491 class LLVM_LIBRARY_VISIBILITY CloudABI : public Generic_ELF {
 492 public:
 493   CloudABI(const Driver &D, const llvm::Triple &Triple,
 494            const llvm::opt::ArgList &Args);
 495   bool HasNativeLLVMSupport() const override { return true; }
 496
 497   bool IsMathErrnoDefault() const override { return false; }
 498   bool IsObjCNonFragileABIDefault() const override { return true; }
 499
 500   CXXStdlibType
 501   GetCXXStdlibType(const llvm::opt::ArgList &Args) const override {
 502     return ToolChain::CST_Libcxx;
 503   }
 504   void AddClangCXXStdlibIncludeArgs(
 505       const llvm::opt::ArgList &DriverArgs,
 506       llvm::opt::ArgStringList &CC1Args) const override;
 507   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 508                            llvm::opt::ArgStringList &CmdArgs) const override;
 509
 510   bool isPIEDefault() const override { return false; }
 511
 512 protected:
 513   Tool *buildLinker() const override;
 514 };
 515
 516 class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
 517 public:
 518   Solaris(const Driver &D, const llvm::Triple &Triple,
 519           const llvm::opt::ArgList &Args);
 520
 521   bool IsIntegratedAssemblerDefault() const override { return true; }
 522
 523 protected:
 524   Tool *buildAssembler() const override;
 525   Tool *buildLinker() const override;
 526 };
 527
 528 class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
 529 public:
 530   MinGW(const Driver &D, const llvm::Triple &Triple,
 531         const llvm::opt::ArgList &Args);
 532
 533   bool IsIntegratedAssemblerDefault() const override;
 534   bool IsUnwindTablesDefault() const override;
 535   bool isPICDefault() const override;
 536   bool isPIEDefault() const override;
 537   bool isPICDefaultForced() const override;
 538   bool UseSEHExceptions() const;
 539
 540   void
 541   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 542                             llvm::opt::ArgStringList &CC1Args) const override;
 543   void AddClangCXXStdlibIncludeArgs(
 544       const llvm::opt::ArgList &DriverArgs,
 545       llvm::opt::ArgStringList &CC1Args) const override;
 546
 547 protected:
 548   Tool *getTool(Action::ActionClass AC) const override;
 549   Tool *buildLinker() const override;
 550   Tool *buildAssembler() const override;
 551
 552 private:
 553   std::string Base;
 554   std::string GccLibDir;
 555   std::string Ver;
 556   std::string Arch;
 557   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor;
 558   mutable std::unique_ptr<tools::gcc::Compiler> Compiler;
 559 };
 560
 561 class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
 562 public:
 563   OpenBSD(const Driver &D, const llvm::Triple &Triple,
 564           const llvm::opt::ArgList &Args);
 565
 566   bool IsMathErrnoDefault() const override { return false; }
 567   bool IsObjCNonFragileABIDefault() const override { return true; }
 568   bool isPIEDefault() const override { return true; }
 569
 570   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 571     return 2;
 572   }
 573
 574 protected:
 575   Tool *buildAssembler() const override;
 576   Tool *buildLinker() const override;
 577 };
 578
 579 class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
 580 public:
 581   Bitrig(const Driver &D, const llvm::Triple &Triple,
 582          const llvm::opt::ArgList &Args);
 583
 584   bool IsMathErrnoDefault() const override { return false; }
 585   bool IsObjCNonFragileABIDefault() const override { return true; }
 586
 587   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 588   void AddClangCXXStdlibIncludeArgs(
 589       const llvm::opt::ArgList &DriverArgs,
 590       llvm::opt::ArgStringList &CC1Args) const override;
 591   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 592                            llvm::opt::ArgStringList &CmdArgs) const override;
 593   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 594     return 1;
 595   }
 596
 597 protected:
 598   Tool *buildAssembler() const override;
 599   Tool *buildLinker() const override;
 600 };
 601
 602 class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
 603 public:
 604   FreeBSD(const Driver &D, const llvm::Triple &Triple,
 605           const llvm::opt::ArgList &Args);
 606   bool HasNativeLLVMSupport() const override;
 607
 608   bool IsMathErrnoDefault() const override { return false; }
 609   bool IsObjCNonFragileABIDefault() const override { return true; }
 610
 611   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 612   void AddClangCXXStdlibIncludeArgs(
 613       const llvm::opt::ArgList &DriverArgs,
 614       llvm::opt::ArgStringList &CC1Args) const override;
 615
 616   bool UseSjLjExceptions() const override;
 617   bool isPIEDefault() const override;
 618   SanitizerMask getSupportedSanitizers() const override;
 619
 620 protected:
 621   Tool *buildAssembler() const override;
 622   Tool *buildLinker() const override;
 623 };
 624
 625 class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
 626 public:
 627   NetBSD(const Driver &D, const llvm::Triple &Triple,
 628          const llvm::opt::ArgList &Args);
 629
 630   bool IsMathErrnoDefault() const override { return false; }
 631   bool IsObjCNonFragileABIDefault() const override { return true; }
 632
 633   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 634
 635   void AddClangCXXStdlibIncludeArgs(
 636       const llvm::opt::ArgList &DriverArgs,
 637       llvm::opt::ArgStringList &CC1Args) const override;
 638   bool IsUnwindTablesDefault() const override { return true; }
 639
 640 protected:
 641   Tool *buildAssembler() const override;
 642   Tool *buildLinker() const override;
 643 };
 644
 645 class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
 646 public:
 647   Minix(const Driver &D, const llvm::Triple &Triple,
 648         const llvm::opt::ArgList &Args);
 649
 650 protected:
 651   Tool *buildAssembler() const override;
 652   Tool *buildLinker() const override;
 653 };
 654
 655 class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
 656 public:
 657   DragonFly(const Driver &D, const llvm::Triple &Triple,
 658             const llvm::opt::ArgList &Args);
 659
 660   bool IsMathErrnoDefault() const override { return false; }
 661
 662 protected:
 663   Tool *buildAssembler() const override;
 664   Tool *buildLinker() const override;
 665 };
 666
 667 class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
 668 public:
 669   Linux(const Driver &D, const llvm::Triple &Triple,
 670         const llvm::opt::ArgList &Args);
 671
 672   bool HasNativeLLVMSupport() const override;
 673
 674   void
 675   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 676                             llvm::opt::ArgStringList &CC1Args) const override;
 677   void AddClangCXXStdlibIncludeArgs(
 678       const llvm::opt::ArgList &DriverArgs,
 679       llvm::opt::ArgStringList &CC1Args) const override;
 680   bool isPIEDefault() const override;
 681   SanitizerMask getSupportedSanitizers() const override;
 682
 683   std::string Linker;
 684   std::vector<std::string> ExtraOpts;
 685
 686 protected:
 687   Tool *buildAssembler() const override;
 688   Tool *buildLinker() const override;
 689
 690 private:
 691   static bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
 692                                        StringRef GCCTriple,
 693                                        StringRef GCCMultiarchTriple,
 694                                        StringRef TargetMultiarchTriple,
 695                                        Twine IncludeSuffix,
 696                                        const llvm::opt::ArgList &DriverArgs,
 697                                        llvm::opt::ArgStringList &CC1Args);
 698
 699   std::string computeSysRoot() const;
 700 };
 701
 702 class LLVM_LIBRARY_VISIBILITY CudaToolChain : public Linux {
 703 public:
 704   CudaToolChain(const Driver &D, const llvm::Triple &Triple,
 705                 const llvm::opt::ArgList &Args);
 706
 707   llvm::opt::DerivedArgList *
 708   TranslateArgs(const llvm::opt::DerivedArgList &Args,
 709                 const char *BoundArch) const override;
 710   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 711                              llvm::opt::ArgStringList &CC1Args) const override;
 712 };
 713
 714 class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux {
 715 protected:
 716   GCCVersion GCCLibAndIncVersion;
 717   Tool *buildAssembler() const override;
 718   Tool *buildLinker() const override;
 719
 720 public:
 721   Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
 722              const llvm::opt::ArgList &Args);
 723   ~Hexagon_TC() override;
 724
 725   void
 726   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 727                             llvm::opt::ArgStringList &CC1Args) const override;
 728   void AddClangCXXStdlibIncludeArgs(
 729       const llvm::opt::ArgList &DriverArgs,
 730       llvm::opt::ArgStringList &CC1Args) const override;
 731   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 732
 733   StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; }
 734
 735   static std::string GetGnuDir(const std::string &InstalledDir,
 736                                const llvm::opt::ArgList &Args);
 737
 738   static StringRef GetTargetCPU(const llvm::opt::ArgList &Args);
 739
 740   static const char *GetSmallDataThreshold(const llvm::opt::ArgList &Args);
 741
 742   static bool UsesG0(const char *smallDataThreshold);
 743 };
 744
 745 class LLVM_LIBRARY_VISIBILITY NaCl_TC : public Generic_ELF {
 746 public:
 747   NaCl_TC(const Driver &D, const llvm::Triple &Triple,
 748           const llvm::opt::ArgList &Args);
 749
 750   void
 751   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 752                             llvm::opt::ArgStringList &CC1Args) const override;
 753   void AddClangCXXStdlibIncludeArgs(
 754       const llvm::opt::ArgList &DriverArgs,
 755       llvm::opt::ArgStringList &CC1Args) const override;
 756
 757   CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 758
 759   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 760                            llvm::opt::ArgStringList &CmdArgs) const override;
 761
 762   bool IsIntegratedAssemblerDefault() const override {
 763     return getTriple().getArch() == llvm::Triple::mipsel;
 764   }
 765
 766   // Get the path to the file containing NaCl's ARM macros. It lives in NaCl_TC
 767   // because the AssembleARM tool needs a const char * that it can pass around
 768   // and the toolchain outlives all the jobs.
 769   const char *GetNaClArmMacrosPath() const { return NaClArmMacrosPath.c_str(); }
 770
 771   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 772                                           types::ID InputType) const override;
 773   std::string Linker;
 774
 775 protected:
 776   Tool *buildLinker() const override;
 777   Tool *buildAssembler() const override;
 778
 779 private:
 780   std::string NaClArmMacrosPath;
 781 };
 782
 783 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
 784 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
 785 class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
 786 public:
 787   TCEToolChain(const Driver &D, const llvm::Triple &Triple,
 788                const llvm::opt::ArgList &Args);
 789   ~TCEToolChain() override;
 790
 791   bool IsMathErrnoDefault() const override;
 792   bool isPICDefault() const override;
 793   bool isPIEDefault() const override;
 794   bool isPICDefaultForced() const override;
 795 };
 796
 797 class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
 798 public:
 799   MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
 800                 const llvm::opt::ArgList &Args);
 801
 802   bool IsIntegratedAssemblerDefault() const override;
 803   bool IsUnwindTablesDefault() const override;
 804   bool isPICDefault() const override;
 805   bool isPIEDefault() const override;
 806   bool isPICDefaultForced() const override;
 807
 808   void
 809   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 810                             llvm::opt::ArgStringList &CC1Args) const override;
 811   void AddClangCXXStdlibIncludeArgs(
 812       const llvm::opt::ArgList &DriverArgs,
 813       llvm::opt::ArgStringList &CC1Args) const override;
 814
 815   bool getWindowsSDKDir(std::string &path, int &major, int &minor) const;
 816   bool getWindowsSDKLibraryPath(std::string &path) const;
 817   bool getVisualStudioInstallDir(std::string &path) const;
 818   bool getVisualStudioBinariesFolder(const char *clangProgramPath,
 819                                      std::string &path) const;
 820
 821   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 822                                           types::ID InputType) const override;
 823   SanitizerMask getSupportedSanitizers() const override;
 824
 825 protected:
 826   void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs,
 827                                      llvm::opt::ArgStringList &CC1Args,
 828                                      const std::string &folder,
 829                                      const char *subfolder) const;
 830
 831   Tool *buildLinker() const override;
 832   Tool *buildAssembler() const override;
 833 };
 834
 835 class LLVM_LIBRARY_VISIBILITY CrossWindowsToolChain : public Generic_GCC {
 836 public:
 837   CrossWindowsToolChain(const Driver &D, const llvm::Triple &T,
 838                         const llvm::opt::ArgList &Args);
 839
 840   bool IsIntegratedAssemblerDefault() const override { return true; }
 841   bool IsUnwindTablesDefault() const override;
 842   bool isPICDefault() const override;
 843   bool isPIEDefault() const override;
 844   bool isPICDefaultForced() const override;
 845
 846   unsigned int GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 847     return 0;
 848   }
 849
 850   void
 851   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 852                             llvm::opt::ArgStringList &CC1Args) const override;
 853   void AddClangCXXStdlibIncludeArgs(
 854       const llvm::opt::ArgList &DriverArgs,
 855       llvm::opt::ArgStringList &CC1Args) const override;
 856   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 857                            llvm::opt::ArgStringList &CmdArgs) const override;
 858
 859 protected:
 860   Tool *buildLinker() const override;
 861   Tool *buildAssembler() const override;
 862 };
 863
 864 class LLVM_LIBRARY_VISIBILITY XCore : public ToolChain {
 865 public:
 866   XCore(const Driver &D, const llvm::Triple &Triple,
 867         const llvm::opt::ArgList &Args);
 868
 869 protected:
 870   Tool *buildAssembler() const override;
 871   Tool *buildLinker() const override;
 872
 873 public:
 874   bool isPICDefault() const override;
 875   bool isPIEDefault() const override;
 876   bool isPICDefaultForced() const override;
 877   bool SupportsProfiling() const override;
 878   bool hasBlocksRuntime() const override;
 879   void
 880   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 881                             llvm::opt::ArgStringList &CC1Args) const override;
 882   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 883                              llvm::opt::ArgStringList &CC1Args) const override;
 884   void AddClangCXXStdlibIncludeArgs(
 885       const llvm::opt::ArgList &DriverArgs,
 886       llvm::opt::ArgStringList &CC1Args) const override;
 887   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 888                            llvm::opt::ArgStringList &CmdArgs) const override;
 889 };
 890
 891 /// SHAVEToolChain - A tool chain using the compiler installed by the the
 892 // Movidius SDK into MV_TOOLS_DIR (which we assume will be copied to llvm's
 893 // installation dir) to perform all subcommands.
 894 class LLVM_LIBRARY_VISIBILITY SHAVEToolChain : public Generic_GCC {
 895 public:
 896   SHAVEToolChain(const Driver &D, const llvm::Triple &Triple,
 897                  const llvm::opt::ArgList &Args);
 898   ~SHAVEToolChain() override;
 899
 900   virtual Tool *SelectTool(const JobAction &JA) const override;
 901
 902 protected:
 903   Tool *getTool(Action::ActionClass AC) const override;
 904   Tool *buildAssembler() const override;
 905   Tool *buildLinker() const override;
 906
 907 private:
 908   mutable std::unique_ptr<Tool> Compiler;
 909   mutable std::unique_ptr<Tool> Assembler;
 910 };
 911
 912 } // end namespace toolchains
 913 } // end namespace driver
 914 } // end namespace clang
 915
 916 #endif