Home | History | Annotate | Download | only in Driver 
      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 "clang/Driver/Action.h"
     14 #include "clang/Driver/ToolChain.h"
     15 
     16 #include "clang/Basic/VersionTuple.h"
     17 #include "llvm/ADT/DenseMap.h"
     18 #include "llvm/Support/Compiler.h"
     19 
     20 #include "Tools.h"
     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 Any textual suffix on the patch number.
     54     std::string PatchSuffix;
     55 
     56     static GCCVersion Parse(StringRef VersionText);
     57     bool operator<(const GCCVersion &RHS) const;
     58     bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
     59     bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
     60     bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
     61   };
     62 
     63 
     64   /// \brief This is a class to find a viable GCC installation for Clang to
     65   /// use.
     66   ///
     67   /// This class tries to find a GCC installation on the system, and report
     68   /// information about it. It starts from the host information provided to the
     69   /// Driver, and has logic for fuzzing that where appropriate.
     70   class GCCInstallationDetector {
     71 
     72     bool IsValid;
     73     llvm::Triple GCCTriple;
     74 
     75     // FIXME: These might be better as path objects.
     76     std::string GCCInstallPath;
     77     std::string GCCMultiarchSuffix;
     78     std::string GCCParentLibPath;
     79 
     80     GCCVersion Version;
     81 
     82   public:
     83     GCCInstallationDetector(const Driver &D, const llvm::Triple &TargetTriple,
     84                             const ArgList &Args);
     85 
     86     /// \brief Check whether we detected a valid GCC install.
     87     bool isValid() const { return IsValid; }
     88 
     89     /// \brief Get the GCC triple for the detected install.
     90     const llvm::Triple &getTriple() const { return GCCTriple; }
     91 
     92     /// \brief Get the detected GCC installation path.
     93     StringRef getInstallPath() const { return GCCInstallPath; }
     94 
     95     /// \brief Get the detected GCC installation path suffix for multiarch GCCs.
     96     StringRef getMultiarchSuffix() const { return GCCMultiarchSuffix; }
     97 
     98     /// \brief Get the detected GCC parent lib path.
     99     StringRef getParentLibPath() const { return GCCParentLibPath; }
    100 
    101     /// \brief Get the detected GCC version string.
    102     StringRef getVersion() const { return Version.Text; }
    103 
    104   private:
    105     static void CollectLibDirsAndTriples(
    106       const llvm::Triple &TargetTriple,
    107       const llvm::Triple &MultiarchTriple,
    108       SmallVectorImpl<StringRef> &LibDirs,
    109       SmallVectorImpl<StringRef> &TripleAliases,
    110       SmallVectorImpl<StringRef> &MultiarchLibDirs,
    111       SmallVectorImpl<StringRef> &MultiarchTripleAliases);
    112 
    113     void ScanLibDirForGCCTriple(llvm::Triple::ArchType TargetArch,
    114                                 const std::string &LibDir,
    115                                 StringRef CandidateTriple,
    116                                 bool NeedsMultiarchSuffix = false);
    117   };
    118 
    119   GCCInstallationDetector GCCInstallation;
    120 
    121   mutable llvm::DenseMap<unsigned, Tool*> Tools;
    122 
    123 public:
    124   Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    125   ~Generic_GCC();
    126 
    127   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    128                            const ActionList &Inputs) const;
    129 
    130   virtual bool IsUnwindTablesDefault() const;
    131   virtual const char *GetDefaultRelocationModel() const;
    132   virtual const char *GetForcedPicModel() const;
    133 
    134 protected:
    135   /// \name ToolChain Implementation Helper Functions
    136   /// @{
    137 
    138   /// \brief Check whether the target triple's architecture is 64-bits.
    139   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
    140 
    141   /// \brief Check whether the target triple's architecture is 32-bits.
    142   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
    143 
    144   /// @}
    145 };
    146 
    147 class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public ToolChain {
    148 protected:
    149   mutable llvm::DenseMap<unsigned, Tool*> Tools;
    150 
    151 public:
    152   Hexagon_TC(const Driver &D, const llvm::Triple& Triple);
    153   ~Hexagon_TC();
    154 
    155   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    156                            const ActionList &Inputs) const;
    157 
    158   virtual bool IsUnwindTablesDefault() const;
    159   virtual const char *GetDefaultRelocationModel() const;
    160   virtual const char *GetForcedPicModel() const;
    161 };
    162 
    163   /// Darwin - The base Darwin tool chain.
    164 class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
    165 public:
    166   /// The host version.
    167   unsigned DarwinVersion[3];
    168 
    169 private:
    170   mutable llvm::DenseMap<unsigned, Tool*> Tools;
    171 
    172   /// Whether the information on the target has been initialized.
    173   //
    174   // FIXME: This should be eliminated. What we want to do is make this part of
    175   // the "default target for arguments" selection process, once we get out of
    176   // the argument translation business.
    177   mutable bool TargetInitialized;
    178 
    179   // FIXME: Remove this once there is a proper way to detect an ARC runtime
    180   // for the simulator.
    181  public:
    182   mutable enum {
    183     ARCSimulator_None,
    184     ARCSimulator_HasARCRuntime,
    185     ARCSimulator_NoARCRuntime
    186   } ARCRuntimeForSimulator;
    187 
    188   mutable enum {
    189     LibCXXSimulator_None,
    190     LibCXXSimulator_NotAvailable,
    191     LibCXXSimulator_Available
    192   } LibCXXForSimulator;
    193 
    194 private:
    195   /// Whether we are targeting iPhoneOS target.
    196   mutable bool TargetIsIPhoneOS;
    197 
    198   /// Whether we are targeting the iPhoneOS simulator target.
    199   mutable bool TargetIsIPhoneOSSimulator;
    200 
    201   /// The OS version we are targeting.
    202   mutable VersionTuple TargetVersion;
    203 
    204   /// The default macosx-version-min of this tool chain; empty until
    205   /// initialized.
    206   std::string MacosxVersionMin;
    207 
    208   bool hasARCRuntime() const;
    209   bool hasSubscriptingRuntime() const;
    210 
    211 private:
    212   void AddDeploymentTarget(DerivedArgList &Args) const;
    213 
    214 public:
    215   Darwin(const Driver &D, const llvm::Triple& Triple);
    216   ~Darwin();
    217 
    218   std::string ComputeEffectiveClangTriple(const ArgList &Args,
    219                                           types::ID InputType) const;
    220 
    221   /// @name Darwin Specific Toolchain API
    222   /// {
    223 
    224   // FIXME: Eliminate these ...Target functions and derive separate tool chains
    225   // for these targets and put version in constructor.
    226   void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor,
    227                  unsigned Micro, bool IsIOSSim) const {
    228     assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!");
    229 
    230     // FIXME: For now, allow reinitialization as long as values don't
    231     // change. This will go away when we move away from argument translation.
    232     if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS &&
    233         TargetIsIPhoneOSSimulator == IsIOSSim &&
    234         TargetVersion == VersionTuple(Major, Minor, Micro))
    235       return;
    236 
    237     assert(!TargetInitialized && "Target already initialized!");
    238     TargetInitialized = true;
    239     TargetIsIPhoneOS = IsIPhoneOS;
    240     TargetIsIPhoneOSSimulator = IsIOSSim;
    241     TargetVersion = VersionTuple(Major, Minor, Micro);
    242   }
    243 
    244   bool isTargetIPhoneOS() const {
    245     assert(TargetInitialized && "Target not initialized!");
    246     return TargetIsIPhoneOS;
    247   }
    248 
    249   bool isTargetIOSSimulator() const {
    250     assert(TargetInitialized && "Target not initialized!");
    251     return TargetIsIPhoneOSSimulator;
    252   }
    253 
    254   bool isTargetMacOS() const {
    255     return !isTargetIOSSimulator() &&
    256            !isTargetIPhoneOS() &&
    257            ARCRuntimeForSimulator == ARCSimulator_None;
    258   }
    259 
    260   bool isTargetInitialized() const { return TargetInitialized; }
    261 
    262   VersionTuple getTargetVersion() const {
    263     assert(TargetInitialized && "Target not initialized!");
    264     return TargetVersion;
    265   }
    266 
    267   /// getDarwinArchName - Get the "Darwin" arch name for a particular compiler
    268   /// invocation. For example, Darwin treats different ARM variations as
    269   /// distinct architectures.
    270   StringRef getDarwinArchName(const ArgList &Args) const;
    271 
    272   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
    273     assert(isTargetIPhoneOS() && "Unexpected call for OS X target!");
    274     return TargetVersion < VersionTuple(V0, V1, V2);
    275   }
    276 
    277   bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
    278     assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!");
    279     return TargetVersion < VersionTuple(V0, V1, V2);
    280   }
    281 
    282   /// AddLinkSearchPathArgs - Add the linker search paths to \arg CmdArgs.
    283   ///
    284   /// \param Args - The input argument list.
    285   /// \param CmdArgs [out] - The command argument list to append the paths
    286   /// (prefixed by -L) to.
    287   virtual void AddLinkSearchPathArgs(const ArgList &Args,
    288                                      ArgStringList &CmdArgs) const = 0;
    289 
    290   /// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library.
    291   virtual void AddLinkARCArgs(const ArgList &Args,
    292                               ArgStringList &CmdArgs) const = 0;
    293 
    294   /// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler
    295   /// runtime library.
    296   virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
    297                                      ArgStringList &CmdArgs) const = 0;
    298 
    299   /// }
    300   /// @name ToolChain Implementation
    301   /// {
    302 
    303   virtual types::ID LookupTypeForExtension(const char *Ext) const;
    304 
    305   virtual bool HasNativeLLVMSupport() const;
    306 
    307   virtual void configureObjCRuntime(ObjCRuntime &runtime) const;
    308   virtual bool hasBlocksRuntime() const;
    309 
    310   virtual DerivedArgList *TranslateArgs(const DerivedArgList &Args,
    311                                         const char *BoundArch) const;
    312 
    313   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    314                            const ActionList &Inputs) const;
    315 
    316   virtual bool IsBlocksDefault() const {
    317     // Always allow blocks on Darwin; users interested in versioning are
    318     // expected to use /usr/include/Blocks.h.
    319     return true;
    320   }
    321   virtual bool IsIntegratedAssemblerDefault() const {
    322 #ifdef DISABLE_DEFAULT_INTEGRATED_ASSEMBLER
    323     return false;
    324 #else
    325     // Default integrated assembler to on for Darwin.
    326     return true;
    327 #endif
    328   }
    329   virtual bool IsStrictAliasingDefault() const {
    330 #ifdef DISABLE_DEFAULT_STRICT_ALIASING
    331     return false;
    332 #else
    333     return ToolChain::IsStrictAliasingDefault();
    334 #endif
    335   }
    336 
    337   virtual bool IsObjCDefaultSynthPropertiesDefault() const {
    338     return true;
    339   }
    340 
    341   virtual bool IsObjCNonFragileABIDefault() const {
    342     // Non-fragile ABI is default for everything but i386.
    343     return getTriple().getArch() != llvm::Triple::x86;
    344   }
    345   virtual bool IsObjCLegacyDispatchDefault() const {
    346     // This is only used with the non-fragile ABI.
    347 
    348     // Legacy dispatch is used everywhere except on x86_64.
    349     return getTriple().getArch() != llvm::Triple::x86_64;
    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 const char *GetDefaultRelocationModel() const;
    369   virtual const char *GetForcedPicModel() const;
    370 
    371   virtual bool SupportsProfiling() const;
    372 
    373   virtual bool SupportsObjCGC() const;
    374 
    375   virtual bool SupportsObjCARC() const;
    376 
    377   virtual bool UseDwarfDebugFlags() const;
    378 
    379   virtual bool UseSjLjExceptions() const;
    380 
    381   /// }
    382 };
    383 
    384 /// DarwinClang - The Darwin toolchain used by Clang.
    385 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
    386 private:
    387   void AddGCCLibexecPath(unsigned darwinVersion);
    388 
    389 public:
    390   DarwinClang(const Driver &D, const llvm::Triple& Triple);
    391 
    392   /// @name Darwin ToolChain Implementation
    393   /// {
    394 
    395   virtual void AddLinkSearchPathArgs(const ArgList &Args,
    396                                     ArgStringList &CmdArgs) const;
    397 
    398   virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
    399                                      ArgStringList &CmdArgs) const;
    400   void AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
    401                          const char *DarwinStaticLib) const;
    402 
    403   virtual void AddCXXStdlibLibArgs(const ArgList &Args,
    404                                    ArgStringList &CmdArgs) const;
    405 
    406   virtual void AddCCKextLibArgs(const ArgList &Args,
    407                                 ArgStringList &CmdArgs) const;
    408 
    409   virtual void AddLinkARCArgs(const ArgList &Args,
    410                               ArgStringList &CmdArgs) const;
    411   /// }
    412 };
    413 
    414 /// Darwin_Generic_GCC - Generic Darwin tool chain using gcc.
    415 class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC {
    416 public:
    417   Darwin_Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
    418     : Generic_GCC(D, Triple, Args) {}
    419 
    420   std::string ComputeEffectiveClangTriple(const ArgList &Args,
    421                                           types::ID InputType) const;
    422 
    423   virtual const char *GetDefaultRelocationModel() const { return "pic"; }
    424 };
    425 
    426 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
    427   virtual void anchor();
    428 public:
    429   Generic_ELF(const Driver &D, const llvm::Triple& Triple, const 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::x86 ||
    435             getTriple().getArch() == llvm::Triple::x86_64);
    436   }
    437 };
    438 
    439 class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC {
    440 public:
    441   AuroraUX(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    442 
    443   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    444                            const ActionList &Inputs) const;
    445 };
    446 
    447 class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
    448 public:
    449   Solaris(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    450 
    451   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    452                            const ActionList &Inputs) const;
    453 
    454   virtual bool IsIntegratedAssemblerDefault() const { return true; }
    455 };
    456 
    457 
    458 class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
    459 public:
    460   OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    461 
    462   virtual bool IsObjCNonFragileABIDefault() const { return true; }
    463   virtual bool IsObjCLegacyDispatchDefault() const {
    464     llvm::Triple::ArchType Arch = getTriple().getArch();
    465     if (Arch == llvm::Triple::arm ||
    466         Arch == llvm::Triple::x86 ||
    467         Arch == llvm::Triple::x86_64)
    468      return false;
    469     return true;
    470   }
    471 
    472   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    473                            const ActionList &Inputs) const;
    474 };
    475 
    476 class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
    477 public:
    478   FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    479 
    480   virtual bool IsObjCNonFragileABIDefault() const { return true; }
    481   virtual bool IsObjCLegacyDispatchDefault() const {
    482     llvm::Triple::ArchType Arch = getTriple().getArch();
    483     if (Arch == llvm::Triple::arm ||
    484         Arch == llvm::Triple::x86 ||
    485         Arch == llvm::Triple::x86_64)
    486      return false;
    487     return true;
    488   }
    489 
    490   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    491                            const ActionList &Inputs) const;
    492 };
    493 
    494 class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
    495 public:
    496   NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    497 
    498   virtual bool IsObjCNonFragileABIDefault() const { return true; }
    499   virtual bool IsObjCLegacyDispatchDefault() const {
    500     llvm::Triple::ArchType Arch = getTriple().getArch();
    501     if (Arch == llvm::Triple::arm ||
    502         Arch == llvm::Triple::x86 ||
    503         Arch == llvm::Triple::x86_64)
    504      return false;
    505     return true;
    506   }
    507 
    508   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    509                            const ActionList &Inputs) const;
    510 };
    511 
    512 class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
    513 public:
    514   Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    515 
    516   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    517                            const ActionList &Inputs) const;
    518 };
    519 
    520 class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
    521 public:
    522   DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    523 
    524   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    525                            const ActionList &Inputs) const;
    526 };
    527 
    528 class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
    529 public:
    530   Linux(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
    531 
    532   virtual bool HasNativeLLVMSupport() const;
    533 
    534   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    535                            const ActionList &Inputs) const;
    536 
    537   virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
    538                                          ArgStringList &CC1Args) const;
    539   virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
    540                                             ArgStringList &CC1Args) const;
    541 
    542   std::string Linker;
    543   std::vector<std::string> ExtraOpts;
    544 
    545 private:
    546   static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
    547                                        const ArgList &DriverArgs,
    548                                        ArgStringList &CC1Args);
    549 };
    550 
    551 
    552 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
    553 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
    554 class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
    555 public:
    556   TCEToolChain(const Driver &D, const llvm::Triple& Triple);
    557   ~TCEToolChain();
    558 
    559   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    560                            const ActionList &Inputs) const;
    561   bool IsMathErrnoDefault() const;
    562   bool IsUnwindTablesDefault() const;
    563   const char* GetDefaultRelocationModel() const;
    564   const char* GetForcedPicModel() const;
    565 
    566 private:
    567   mutable llvm::DenseMap<unsigned, Tool*> Tools;
    568 
    569 };
    570 
    571 class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
    572   mutable llvm::DenseMap<unsigned, Tool*> Tools;
    573 
    574 public:
    575   Windows(const Driver &D, const llvm::Triple& Triple);
    576 
    577   virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
    578                            const ActionList &Inputs) const;
    579 
    580   virtual bool IsIntegratedAssemblerDefault() const;
    581   virtual bool IsUnwindTablesDefault() const;
    582   virtual const char *GetDefaultRelocationModel() const;
    583   virtual const char *GetForcedPicModel() const;
    584 
    585   virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
    586                                          ArgStringList &CC1Args) const;
    587   virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
    588                                             ArgStringList &CC1Args) const;
    589 
    590 };
    591 
    592 } // end namespace toolchains
    593 } // end namespace driver
    594 } // end namespace clang
    595 
    596 #endif
    597