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 CLANG_LIB_DRIVER_TOOLCHAINS_H_
  11 #define 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/ToolChain.h"
  17 #include "llvm/ADT/DenseMap.h"
  18 #include "llvm/Support/Compiler.h"
  19 #include <vector>
  20 #include <set>
  21
  22 namespace clang {
  23 namespace driver {
  24 namespace toolchains {
  25
  26 /// Generic_GCC - A tool chain using the 'gcc' command to perform
  27 /// all subcommands; this relies on gcc translating the majority of
  28 /// command line options.
  29 class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
  30 protected:
  31   /// \brief Struct to store and manipulate GCC versions.
  32   ///
  33   /// We rely on assumptions about the form and structure of GCC version
  34   /// numbers: they consist of at most three '.'-separated components, and each
  35   /// component is a non-negative integer except for the last component. For
  36   /// the last component we are very flexible in order to tolerate release
  37   /// candidates or 'x' wildcards.
  38   ///
  39   /// Note that the ordering established among GCCVersions is based on the
  40   /// preferred version string to use. For example we prefer versions without
  41   /// a hard-coded patch number to those with a hard coded patch number.
  42   ///
  43   /// Currently this doesn't provide any logic for textual suffixes to patches
  44   /// in the way that (for example) Debian's version format does. If that ever
  45   /// becomes necessary, it can be added.
  46   struct GCCVersion {
  47     /// \brief The unparsed text of the version.
  48     std::string Text;
  49
  50     /// \brief The parsed major, minor, and patch numbers.
  51     int Major, Minor, Patch;
  52
  53     /// \brief The text of the parsed major, and major+minor versions.
  54     std::string MajorStr, MinorStr;
  55
  56     /// \brief Any textual suffix on the patch number.
  57     std::string PatchSuffix;
  58
  59     static GCCVersion Parse(StringRef VersionText);
  60     bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch,
  61                      StringRef RHSPatchSuffix = StringRef()) const;
  62     bool operator<(const GCCVersion &RHS) const {
  63       return isOlderThan(RHS.Major, RHS.Minor, RHS.Patch, RHS.PatchSuffix);
  64     }
  65     bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
  66     bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
  67     bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
  68   };
  69
  70
  71   /// \brief This is a class to find a viable GCC installation for Clang to
  72   /// use.
  73   ///
  74   /// This class tries to find a GCC installation on the system, and report
  75   /// information about it. It starts from the host information provided to the
  76   /// Driver, and has logic for fuzzing that where appropriate.
  77   class GCCInstallationDetector {
  78     bool IsValid;
  79     const Driver &D;
  80     llvm::Triple GCCTriple;
  81
  82     // FIXME: These might be better as path objects.
  83     std::string GCCInstallPath;
  84     std::string GCCBiarchSuffix;
  85     std::string GCCParentLibPath;
  86     std::string GCCMIPSABIDirSuffix;
  87
  88     GCCVersion Version;
  89
  90     // We retain the list of install paths that were considered and rejected in
  91     // order to print out detailed information in verbose mode.
  92     std::set<std::string> CandidateGCCInstallPaths;
  93
  94   public:
  95     GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
  96     void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args);
  97
  98     /// \brief Check whether we detected a valid GCC install.
  99     bool isValid() const { return IsValid; }
 100
 101     /// \brief Get the GCC triple for the detected install.
 102     const llvm::Triple &getTriple() const { return GCCTriple; }
 103
 104     /// \brief Get the detected GCC installation path.
 105     StringRef getInstallPath() const { return GCCInstallPath; }
 106
 107     /// \brief Get the detected GCC installation path suffix for the bi-arch
 108     /// target variant.
 109     StringRef getBiarchSuffix() const { return GCCBiarchSuffix; }
 110
 111     /// \brief Get the detected GCC parent lib path.
 112     StringRef getParentLibPath() const { return GCCParentLibPath; }
 113
 114     /// \brief Get the detected GCC MIPS ABI directory suffix.
 115     ///
 116     /// This is used as a suffix both to the install directory of GCC and as
 117     /// a suffix to its parent lib path in order to select a MIPS ABI-specific
 118     /// subdirectory.
 119     ///
 120     /// This will always be empty for any non-MIPS target.
 121     ///
 122     // FIXME: This probably shouldn't exist at all, and should be factored
 123     // into the multiarch and/or biarch support. Please don't add more uses of
 124     // this interface, it is meant as a legacy crutch for the MIPS driver
 125     // logic.
 126     StringRef getMIPSABIDirSuffix() const { return GCCMIPSABIDirSuffix; }
 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(llvm::Triple::ArchType TargetArch,
 144                                 const llvm::opt::ArgList &Args,
 145                                 const std::string &LibDir,
 146                                 StringRef CandidateTriple,
 147                                 bool NeedsBiarchSuffix = false);
 148
 149     void findMIPSABIDirSuffix(std::string &Suffix,
 150                               llvm::Triple::ArchType TargetArch, StringRef Path,
 151                               const llvm::opt::ArgList &Args);
 152   };
 153
 154   GCCInstallationDetector GCCInstallation;
 155
 156 public:
 157   Generic_GCC(const Driver &D, const llvm::Triple &Triple,
 158               const llvm::opt::ArgList &Args);
 159   ~Generic_GCC();
 160
 161   virtual void printVerboseInfo(raw_ostream &OS) const;
 162
 163   virtual bool IsUnwindTablesDefault() const;
 164   virtual bool isPICDefault() const;
 165   virtual bool isPIEDefault() const;
 166   virtual bool isPICDefaultForced() const;
 167   virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 168                                      llvm::opt::ArgStringList &CC1Args) const;
 169
 170 protected:
 171   virtual Tool *getTool(Action::ActionClass AC) const;
 172   virtual Tool *buildAssembler() const;
 173   virtual Tool *buildLinker() const;
 174
 175   /// \name ToolChain Implementation Helper Functions
 176   /// @{
 177
 178   /// \brief Check whether the target triple's architecture is 64-bits.
 179   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 180
 181   /// \brief Check whether the target triple's architecture is 32-bits.
 182   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
 183
 184   /// @}
 185
 186 private:
 187   mutable OwningPtr<tools::gcc::Preprocess> Preprocess;
 188   mutable OwningPtr<tools::gcc::Precompile> Precompile;
 189   mutable OwningPtr<tools::gcc::Compile> Compile;
 190 };
 191
 192   /// Darwin - The base Darwin tool chain.
 193 class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
 194 public:
 195   /// The host version.
 196   unsigned DarwinVersion[3];
 197
 198 protected:
 199   virtual Tool *buildAssembler() const;
 200   virtual Tool *buildLinker() const;
 201   virtual Tool *getTool(Action::ActionClass AC) const;
 202
 203 private:
 204   mutable OwningPtr<tools::darwin::Lipo> Lipo;
 205   mutable OwningPtr<tools::darwin::Dsymutil> Dsymutil;
 206   mutable OwningPtr<tools::darwin::VerifyDebug> VerifyDebug;
 207
 208   /// Whether the information on the target has been initialized.
 209   //
 210   // FIXME: This should be eliminated. What we want to do is make this part of
 211   // the "default target for arguments" selection process, once we get out of
 212   // the argument translation business.
 213   mutable bool TargetInitialized;
 214
 215   /// Whether we are targeting iPhoneOS target.
 216   mutable bool TargetIsIPhoneOS;
 217
 218   /// Whether we are targeting the iPhoneOS simulator target.
 219   mutable bool TargetIsIPhoneOSSimulator;
 220
 221   /// The OS version we are targeting.
 222   mutable VersionTuple TargetVersion;
 223
 224 private:
 225   /// The default macosx-version-min of this tool chain; empty until
 226   /// initialized.
 227   std::string MacosxVersionMin;
 228
 229   /// The default ios-version-min of this tool chain; empty until
 230   /// initialized.
 231   std::string iOSVersionMin;
 232
 233 private:
 234   void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
 235
 236 public:
 237   Darwin(const Driver &D, const llvm::Triple &Triple,
 238          const llvm::opt::ArgList &Args);
 239   ~Darwin();
 240
 241   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 242                                           types::ID InputType) const;
 243
 244   /// @name Darwin Specific Toolchain API
 245   /// {
 246
 247   // FIXME: Eliminate these ...Target functions and derive separate tool chains
 248   // for these targets and put version in constructor.
 249   void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor,
 250                  unsigned Micro, bool IsIOSSim) const {
 251     assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!");
 252
 253     // FIXME: For now, allow reinitialization as long as values don't
 254     // change. This will go away when we move away from argument translation.
 255     if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS &&
 256         TargetIsIPhoneOSSimulator == IsIOSSim &&
 257         TargetVersion == VersionTuple(Major, Minor, Micro))
 258       return;
 259
 260     assert(!TargetInitialized && "Target already initialized!");
 261     TargetInitialized = true;
 262     TargetIsIPhoneOS = IsIPhoneOS;
 263     TargetIsIPhoneOSSimulator = IsIOSSim;
 264     TargetVersion = VersionTuple(Major, Minor, Micro);
 265   }
 266
 267   bool isTargetIPhoneOS() const {
 268     assert(TargetInitialized && "Target not initialized!");
 269     return TargetIsIPhoneOS;
 270   }
 271
 272   bool isTargetIOSSimulator() const {
 273     assert(TargetInitialized && "Target not initialized!");
 274     return TargetIsIPhoneOSSimulator;
 275   }
 276
 277   bool isTargetMacOS() const {
 278     return !isTargetIOSSimulator() && !isTargetIPhoneOS();
 279   }
 280
 281   bool isTargetInitialized() const { return TargetInitialized; }
 282
 283   VersionTuple getTargetVersion() const {
 284     assert(TargetInitialized && "Target not initialized!");
 285     return TargetVersion;
 286   }
 287
 288   /// getDarwinArchName - Get the "Darwin" arch name for a particular compiler
 289   /// invocation. For example, Darwin treats different ARM variations as
 290   /// distinct architectures.
 291   StringRef getDarwinArchName(const llvm::opt::ArgList &Args) const;
 292
 293   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
 294     assert(isTargetIPhoneOS() && "Unexpected call for OS X target!");
 295     return TargetVersion < VersionTuple(V0, V1, V2);
 296   }
 297
 298   bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
 299     assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!");
 300     return TargetVersion < VersionTuple(V0, V1, V2);
 301   }
 302
 303   /// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library.
 304   virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 305                               llvm::opt::ArgStringList &CmdArgs) const = 0;
 306
 307   /// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler
 308   /// runtime library.
 309   virtual void
 310   AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 311                         llvm::opt::ArgStringList &CmdArgs) const = 0;
 312
 313   /// }
 314   /// @name ToolChain Implementation
 315   /// {
 316
 317   virtual types::ID LookupTypeForExtension(const char *Ext) const;
 318
 319   virtual bool HasNativeLLVMSupport() const;
 320
 321   virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
 322   virtual bool hasBlocksRuntime() const;
 323
 324   virtual llvm::opt::DerivedArgList *
 325   TranslateArgs(const llvm::opt::DerivedArgList &Args,
 326                 const char *BoundArch) const;
 327
 328   virtual bool IsBlocksDefault() const {
 329     // Always allow blocks on Darwin; users interested in versioning are
 330     // expected to use /usr/include/Blocks.h.
 331     return true;
 332   }
 333   virtual bool IsIntegratedAssemblerDefault() const {
 334     // Default integrated assembler to on for Darwin.
 335     return true;
 336   }
 337
 338   virtual bool IsMathErrnoDefault() const {
 339     return false;
 340   }
 341
 342   virtual bool IsEncodeExtendedBlockSignatureDefault() const {
 343     return true;
 344   }
 345
 346   virtual bool IsObjCNonFragileABIDefault() const {
 347     // Non-fragile ABI is default for everything but i386.
 348     return getTriple().getArch() != llvm::Triple::x86;
 349   }
 350
 351   virtual bool UseObjCMixedDispatch() const {
 352     // This is only used with the non-fragile ABI and non-legacy dispatch.
 353
 354     // Mixed dispatch is used everywhere except OS X before 10.6.
 355     return !(!isTargetIPhoneOS() && isMacosxVersionLT(10, 6));
 356   }
 357   virtual bool IsUnwindTablesDefault() const;
 358   virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
 359     // Stack protectors default to on for user code on 10.5,
 360     // and for everything in 10.6 and beyond
 361     return isTargetIPhoneOS() ||
 362       (!isMacosxVersionLT(10, 6) ||
 363          (!isMacosxVersionLT(10, 5) && !KernelOrKext));
 364   }
 365   virtual RuntimeLibType GetDefaultRuntimeLibType() const {
 366     return ToolChain::RLT_CompilerRT;
 367   }
 368   virtual bool isPICDefault() const;
 369   virtual bool isPIEDefault() const;
 370   virtual bool isPICDefaultForced() const;
 371
 372   virtual bool SupportsProfiling() const;
 373
 374   virtual bool SupportsObjCGC() const;
 375
 376   virtual void CheckObjCARC() const;
 377
 378   virtual bool UseDwarfDebugFlags() const;
 379
 380   virtual bool UseSjLjExceptions() const;
 381
 382   /// }
 383 };
 384
 385 /// DarwinClang - The Darwin toolchain used by Clang.
 386 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
 387 public:
 388   DarwinClang(const Driver &D, const llvm::Triple &Triple,
 389               const llvm::opt::ArgList &Args);
 390
 391   /// @name Darwin ToolChain Implementation
 392   /// {
 393
 394   virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 395                                      llvm::opt::ArgStringList &CmdArgs) const;
 396   void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
 397                          llvm::opt::ArgStringList &CmdArgs,
 398                          const char *DarwinStaticLib,
 399                          bool AlwaysLink = false) const;
 400
 401   virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 402                                    llvm::opt::ArgStringList &CmdArgs) const;
 403
 404   virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
 405                                 llvm::opt::ArgStringList &CmdArgs) const;
 406
 407   virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 408                               llvm::opt::ArgStringList &CmdArgs) const;
 409   /// }
 410 };
 411
 412 /// Darwin_Generic_GCC - Generic Darwin tool chain using gcc.
 413 class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC {
 414 public:
 415   Darwin_Generic_GCC(const Driver &D, const llvm::Triple &Triple,
 416                      const llvm::opt::ArgList &Args)
 417       : Generic_GCC(D, Triple, Args) {}
 418
 419   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 420                                           types::ID InputType) const;
 421
 422   virtual bool isPICDefault() const { return false; }
 423 };
 424
 425 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
 426   virtual void anchor();
 427 public:
 428   Generic_ELF(const Driver &D, const llvm::Triple &Triple,
 429               const llvm::opt::ArgList &Args)
 430       : Generic_GCC(D, Triple, Args) {}
 431
 432   virtual bool IsIntegratedAssemblerDefault() const {
 433     // Default integrated assembler to on for x86.
 434     return (getTriple().getArch() == llvm::Triple::aarch64 ||
 435             getTriple().getArch() == llvm::Triple::x86 ||
 436             getTriple().getArch() == llvm::Triple::x86_64);
 437   }
 438 };
 439
 440 class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC {
 441 public:
 442   AuroraUX(const Driver &D, const llvm::Triple &Triple,
 443            const llvm::opt::ArgList &Args);
 444
 445 protected:
 446   virtual Tool *buildAssembler() const;
 447   virtual Tool *buildLinker() const;
 448 };
 449
 450 class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
 451 public:
 452   Solaris(const Driver &D, const llvm::Triple &Triple,
 453           const llvm::opt::ArgList &Args);
 454
 455   virtual bool IsIntegratedAssemblerDefault() const { return true; }
 456 protected:
 457   virtual Tool *buildAssembler() const;
 458   virtual Tool *buildLinker() const;
 459
 460 };
 461
 462
 463 class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
 464 public:
 465   OpenBSD(const Driver &D, const llvm::Triple &Triple,
 466           const llvm::opt::ArgList &Args);
 467
 468   virtual bool IsMathErrnoDefault() const { return false; }
 469   virtual bool IsObjCNonFragileABIDefault() const { return true; }
 470   virtual bool isPIEDefault() const { return true; }
 471
 472   virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
 473     return 1;
 474   }
 475
 476 protected:
 477   virtual Tool *buildAssembler() const;
 478   virtual Tool *buildLinker() const;
 479 };
 480
 481 class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
 482 public:
 483   Bitrig(const Driver &D, const llvm::Triple &Triple,
 484          const llvm::opt::ArgList &Args);
 485
 486   virtual bool IsMathErrnoDefault() const { return false; }
 487   virtual bool IsObjCNonFragileABIDefault() const { return true; }
 488   virtual bool IsObjCLegacyDispatchDefault() const { return false; }
 489
 490   virtual void
 491   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 492                                llvm::opt::ArgStringList &CC1Args) const;
 493   virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 494                                    llvm::opt::ArgStringList &CmdArgs) const;
 495   virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
 496      return 1;
 497   }
 498
 499 protected:
 500   virtual Tool *buildAssembler() const;
 501   virtual Tool *buildLinker() const;
 502 };
 503
 504 class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
 505 public:
 506   FreeBSD(const Driver &D, const llvm::Triple &Triple,
 507           const llvm::opt::ArgList &Args);
 508   virtual bool HasNativeLLVMSupport() const;
 509
 510   virtual bool IsMathErrnoDefault() const { return false; }
 511   virtual bool IsObjCNonFragileABIDefault() const { return true; }
 512
 513   virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
 514   virtual void
 515   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 516                                llvm::opt::ArgStringList &CC1Args) const;
 517   virtual bool IsIntegratedAssemblerDefault() const {
 518     if (getTriple().getArch() == llvm::Triple::ppc ||
 519         getTriple().getArch() == llvm::Triple::ppc64)
 520       return true;
 521     return Generic_ELF::IsIntegratedAssemblerDefault();
 522   }
 523
 524   virtual bool UseSjLjExceptions() const;
 525 protected:
 526   virtual Tool *buildAssembler() const;
 527   virtual Tool *buildLinker() const;
 528 };
 529
 530 class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
 531 public:
 532   NetBSD(const Driver &D, const llvm::Triple &Triple,
 533          const llvm::opt::ArgList &Args);
 534
 535   virtual bool IsMathErrnoDefault() const { return false; }
 536   virtual bool IsObjCNonFragileABIDefault() const { return true; }
 537
 538   virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
 539
 540   virtual void
 541   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 542                                llvm::opt::ArgStringList &CC1Args) const;
 543   virtual bool IsUnwindTablesDefault() const {
 544     return true;
 545   }
 546   virtual bool IsIntegratedAssemblerDefault() const {
 547     if (getTriple().getArch() == llvm::Triple::ppc)
 548       return true;
 549     return Generic_ELF::IsIntegratedAssemblerDefault();
 550   }
 551
 552 protected:
 553   virtual Tool *buildAssembler() const;
 554   virtual Tool *buildLinker() const;
 555 };
 556
 557 class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
 558 public:
 559   Minix(const Driver &D, const llvm::Triple &Triple,
 560         const llvm::opt::ArgList &Args);
 561
 562 protected:
 563   virtual Tool *buildAssembler() const;
 564   virtual Tool *buildLinker() const;
 565 };
 566
 567 class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
 568 public:
 569   DragonFly(const Driver &D, const llvm::Triple &Triple,
 570             const llvm::opt::ArgList &Args);
 571
 572   virtual bool IsMathErrnoDefault() const { return false; }
 573
 574 protected:
 575   virtual Tool *buildAssembler() const;
 576   virtual Tool *buildLinker() const;
 577 };
 578
 579 class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
 580 public:
 581   Linux(const Driver &D, const llvm::Triple &Triple,
 582         const llvm::opt::ArgList &Args);
 583
 584   virtual bool HasNativeLLVMSupport() const;
 585
 586   virtual void
 587   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 588                             llvm::opt::ArgStringList &CC1Args) const;
 589   virtual void
 590   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 591                                llvm::opt::ArgStringList &CC1Args) const;
 592   virtual bool isPIEDefault() const;
 593
 594   std::string Linker;
 595   std::vector<std::string> ExtraOpts;
 596
 597 protected:
 598   virtual Tool *buildAssembler() const;
 599   virtual Tool *buildLinker() const;
 600
 601 private:
 602   static bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
 603                                        Twine TargetArchDir,
 604                                        Twine BiarchSuffix,
 605                                        Twine MIPSABIDirSuffix,
 606                                        const llvm::opt::ArgList &DriverArgs,
 607                                        llvm::opt::ArgStringList &CC1Args);
 608   static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
 609                                        const llvm::opt::ArgList &DriverArgs,
 610                                        llvm::opt::ArgStringList &CC1Args);
 611
 612   std::string computeSysRoot() const;
 613 };
 614
 615 class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux {
 616 protected:
 617   GCCVersion GCCLibAndIncVersion;
 618   virtual Tool *buildAssembler() const;
 619   virtual Tool *buildLinker() const;
 620
 621 public:
 622   Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
 623              const llvm::opt::ArgList &Args);
 624   ~Hexagon_TC();
 625
 626   virtual void
 627   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 628                             llvm::opt::ArgStringList &CC1Args) const;
 629   virtual void
 630   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 631                                llvm::opt::ArgStringList &CC1Args) const;
 632   virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
 633
 634   StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; }
 635
 636   static std::string GetGnuDir(const std::string &InstalledDir);
 637
 638   static StringRef GetTargetCPU(const llvm::opt::ArgList &Args);
 639 };
 640
 641 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
 642 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
 643 class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
 644 public:
 645   TCEToolChain(const Driver &D, const llvm::Triple &Triple,
 646                const llvm::opt::ArgList &Args);
 647   ~TCEToolChain();
 648
 649   bool IsMathErrnoDefault() const;
 650   bool isPICDefault() const;
 651   bool isPIEDefault() const;
 652   bool isPICDefaultForced() const;
 653 };
 654
 655 class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
 656 public:
 657   Windows(const Driver &D, const llvm::Triple &Triple,
 658           const llvm::opt::ArgList &Args);
 659
 660   virtual bool IsIntegratedAssemblerDefault() const;
 661   virtual bool IsUnwindTablesDefault() const;
 662   virtual bool isPICDefault() const;
 663   virtual bool isPIEDefault() const;
 664   virtual bool isPICDefaultForced() const;
 665
 666   virtual void
 667   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 668                             llvm::opt::ArgStringList &CC1Args) const;
 669   virtual void
 670   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 671                                llvm::opt::ArgStringList &CC1Args) const;
 672
 673 protected:
 674   virtual Tool *buildLinker() const;
 675   virtual Tool *buildAssembler() const;
 676 };
 677
 678
 679 class LLVM_LIBRARY_VISIBILITY XCore : public ToolChain {
 680 public:
 681   XCore(const Driver &D, const llvm::Triple &Triple,
 682           const llvm::opt::ArgList &Args);
 683 protected:
 684   virtual Tool *buildAssembler() const;
 685   virtual Tool *buildLinker() const;
 686 public:
 687   virtual bool isPICDefault() const;
 688   virtual bool isPIEDefault() const;
 689   virtual bool isPICDefaultForced() const;
 690   virtual bool SupportsProfiling() const;
 691   virtual bool hasBlocksRuntime() const;
 692   virtual void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 693                             llvm::opt::ArgStringList &CC1Args) const;
 694   virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
 695                                      llvm::opt::ArgStringList &CC1Args) const;
 696   virtual void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 697                                llvm::opt::ArgStringList &CC1Args) const;
 698   virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 699                                    llvm::opt::ArgStringList &CmdArgs) const;
 700 };
 701
 702 } // end namespace toolchains
 703 } // end namespace driver
 704 } // end namespace clang
 705
 706 #endif