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
20#include <vector>
21
22namespace clang {
23namespace driver {
24namespace 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.
29class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
30protected:
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    bool IsValid;
72    llvm::Triple GCCTriple;
73
74    // FIXME: These might be better as path objects.
75    std::string GCCInstallPath;
76    std::string GCCBiarchSuffix;
77    std::string GCCParentLibPath;
78
79    GCCVersion Version;
80
81    // We retain the list of install paths that were considered and rejected in
82    // order to print out detailed information in verbose mode.
83    SmallVector<std::string, 4> CandidateGCCInstallPaths;
84
85  public:
86    GCCInstallationDetector(const Driver &D, const llvm::Triple &TargetTriple,
87                            const llvm::opt::ArgList &Args);
88
89    /// \brief Check whether we detected a valid GCC install.
90    bool isValid() const { return IsValid; }
91
92    /// \brief Get the GCC triple for the detected install.
93    const llvm::Triple &getTriple() const { return GCCTriple; }
94
95    /// \brief Get the detected GCC installation path.
96    StringRef getInstallPath() const { return GCCInstallPath; }
97
98    /// \brief Get the detected GCC installation path suffix for the bi-arch
99    /// target variant.
100    StringRef getBiarchSuffix() const { return GCCBiarchSuffix; }
101
102    /// \brief Get the detected GCC parent lib path.
103    StringRef getParentLibPath() const { return GCCParentLibPath; }
104
105    /// \brief Get the detected GCC version string.
106    const GCCVersion &getVersion() const { return Version; }
107
108    /// \brief Print information about the detected GCC installation.
109    void print(raw_ostream &OS) const;
110
111  private:
112    static void
113    CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
114                             const llvm::Triple &BiarchTriple,
115                             SmallVectorImpl<StringRef> &LibDirs,
116                             SmallVectorImpl<StringRef> &TripleAliases,
117                             SmallVectorImpl<StringRef> &BiarchLibDirs,
118                             SmallVectorImpl<StringRef> &BiarchTripleAliases);
119
120    void ScanLibDirForGCCTriple(llvm::Triple::ArchType TargetArch,
121                                const llvm::opt::ArgList &Args,
122                                const std::string &LibDir,
123                                StringRef CandidateTriple,
124                                bool NeedsBiarchSuffix = false);
125  };
126
127  GCCInstallationDetector GCCInstallation;
128
129public:
130  Generic_GCC(const Driver &D, const llvm::Triple &Triple,
131              const llvm::opt::ArgList &Args);
132  ~Generic_GCC();
133
134  virtual void printVerboseInfo(raw_ostream &OS) const;
135
136  virtual bool IsUnwindTablesDefault() const;
137  virtual bool isPICDefault() const;
138  virtual bool isPIEDefault() const;
139  virtual bool isPICDefaultForced() const;
140
141protected:
142  virtual Tool *getTool(Action::ActionClass AC) const;
143  virtual Tool *buildAssembler() const;
144  virtual Tool *buildLinker() const;
145
146  /// \name ToolChain Implementation Helper Functions
147  /// @{
148
149  /// \brief Check whether the target triple's architecture is 64-bits.
150  bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
151
152  /// \brief Check whether the target triple's architecture is 32-bits.
153  bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
154
155  /// @}
156
157private:
158  mutable OwningPtr<tools::gcc::Preprocess> Preprocess;
159  mutable OwningPtr<tools::gcc::Precompile> Precompile;
160  mutable OwningPtr<tools::gcc::Compile> Compile;
161};
162
163  /// Darwin - The base Darwin tool chain.
164class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
165public:
166  /// The host version.
167  unsigned DarwinVersion[3];
168
169protected:
170  virtual Tool *buildAssembler() const;
171  virtual Tool *buildLinker() const;
172  virtual Tool *getTool(Action::ActionClass AC) const;
173
174private:
175  mutable OwningPtr<tools::darwin::Lipo> Lipo;
176  mutable OwningPtr<tools::darwin::Dsymutil> Dsymutil;
177  mutable OwningPtr<tools::darwin::VerifyDebug> VerifyDebug;
178
179  /// Whether the information on the target has been initialized.
180  //
181  // FIXME: This should be eliminated. What we want to do is make this part of
182  // the "default target for arguments" selection process, once we get out of
183  // the argument translation business.
184  mutable bool TargetInitialized;
185
186  /// Whether we are targeting iPhoneOS target.
187  mutable bool TargetIsIPhoneOS;
188
189  /// Whether we are targeting the iPhoneOS simulator target.
190  mutable bool TargetIsIPhoneOSSimulator;
191
192  /// The OS version we are targeting.
193  mutable VersionTuple TargetVersion;
194
195private:
196  /// The default macosx-version-min of this tool chain; empty until
197  /// initialized.
198  std::string MacosxVersionMin;
199
200  /// The default ios-version-min of this tool chain; empty until
201  /// initialized.
202  std::string iOSVersionMin;
203
204private:
205  void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
206
207public:
208  Darwin(const Driver &D, const llvm::Triple &Triple,
209         const llvm::opt::ArgList &Args);
210  ~Darwin();
211
212  std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
213                                          types::ID InputType) const;
214
215  /// @name Darwin Specific Toolchain API
216  /// {
217
218  // FIXME: Eliminate these ...Target functions and derive separate tool chains
219  // for these targets and put version in constructor.
220  void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor,
221                 unsigned Micro, bool IsIOSSim) const {
222    assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!");
223
224    // FIXME: For now, allow reinitialization as long as values don't
225    // change. This will go away when we move away from argument translation.
226    if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS &&
227        TargetIsIPhoneOSSimulator == IsIOSSim &&
228        TargetVersion == VersionTuple(Major, Minor, Micro))
229      return;
230
231    assert(!TargetInitialized && "Target already initialized!");
232    TargetInitialized = true;
233    TargetIsIPhoneOS = IsIPhoneOS;
234    TargetIsIPhoneOSSimulator = IsIOSSim;
235    TargetVersion = VersionTuple(Major, Minor, Micro);
236  }
237
238  bool isTargetIPhoneOS() const {
239    assert(TargetInitialized && "Target not initialized!");
240    return TargetIsIPhoneOS;
241  }
242
243  bool isTargetIOSSimulator() const {
244    assert(TargetInitialized && "Target not initialized!");
245    return TargetIsIPhoneOSSimulator;
246  }
247
248  bool isTargetMacOS() const {
249    return !isTargetIOSSimulator() && !isTargetIPhoneOS();
250  }
251
252  bool isTargetInitialized() const { return TargetInitialized; }
253
254  VersionTuple getTargetVersion() const {
255    assert(TargetInitialized && "Target not initialized!");
256    return TargetVersion;
257  }
258
259  /// getDarwinArchName - Get the "Darwin" arch name for a particular compiler
260  /// invocation. For example, Darwin treats different ARM variations as
261  /// distinct architectures.
262  StringRef getDarwinArchName(const llvm::opt::ArgList &Args) const;
263
264  bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
265    assert(isTargetIPhoneOS() && "Unexpected call for OS X target!");
266    return TargetVersion < VersionTuple(V0, V1, V2);
267  }
268
269  bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
270    assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!");
271    return TargetVersion < VersionTuple(V0, V1, V2);
272  }
273
274  /// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library.
275  virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
276                              llvm::opt::ArgStringList &CmdArgs) const = 0;
277
278  /// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler
279  /// runtime library.
280  virtual void
281  AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
282                        llvm::opt::ArgStringList &CmdArgs) const = 0;
283
284  /// }
285  /// @name ToolChain Implementation
286  /// {
287
288  virtual types::ID LookupTypeForExtension(const char *Ext) const;
289
290  virtual bool HasNativeLLVMSupport() const;
291
292  virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
293  virtual bool hasBlocksRuntime() const;
294
295  virtual llvm::opt::DerivedArgList *
296  TranslateArgs(const llvm::opt::DerivedArgList &Args,
297                const char *BoundArch) const;
298
299  virtual bool IsBlocksDefault() const {
300    // Always allow blocks on Darwin; users interested in versioning are
301    // expected to use /usr/include/Blocks.h.
302    return true;
303  }
304  virtual bool IsIntegratedAssemblerDefault() const {
305#ifdef DISABLE_DEFAULT_INTEGRATED_ASSEMBLER
306    return false;
307#else
308    // Default integrated assembler to on for Darwin.
309    return true;
310#endif
311  }
312  virtual bool IsStrictAliasingDefault() const {
313#ifdef DISABLE_DEFAULT_STRICT_ALIASING
314    return false;
315#else
316    return ToolChain::IsStrictAliasingDefault();
317#endif
318  }
319
320  virtual bool IsMathErrnoDefault() const {
321    return false;
322  }
323
324  virtual bool IsEncodeExtendedBlockSignatureDefault() const {
325    return true;
326  }
327
328  virtual bool IsObjCNonFragileABIDefault() const {
329    // Non-fragile ABI is default for everything but i386.
330    return getTriple().getArch() != llvm::Triple::x86;
331  }
332
333  virtual bool UseObjCMixedDispatch() const {
334    // This is only used with the non-fragile ABI and non-legacy dispatch.
335
336    // Mixed dispatch is used everywhere except OS X before 10.6.
337    return !(!isTargetIPhoneOS() && isMacosxVersionLT(10, 6));
338  }
339  virtual bool IsUnwindTablesDefault() const;
340  virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
341    // Stack protectors default to on for user code on 10.5,
342    // and for everything in 10.6 and beyond
343    return isTargetIPhoneOS() ||
344      (!isMacosxVersionLT(10, 6) ||
345         (!isMacosxVersionLT(10, 5) && !KernelOrKext));
346  }
347  virtual RuntimeLibType GetDefaultRuntimeLibType() const {
348    return ToolChain::RLT_CompilerRT;
349  }
350  virtual bool isPICDefault() const;
351  virtual bool isPIEDefault() const;
352  virtual bool isPICDefaultForced() const;
353
354  virtual bool SupportsProfiling() const;
355
356  virtual bool SupportsObjCGC() const;
357
358  virtual void CheckObjCARC() const;
359
360  virtual bool UseDwarfDebugFlags() const;
361
362  virtual bool UseSjLjExceptions() const;
363
364  /// }
365};
366
367/// DarwinClang - The Darwin toolchain used by Clang.
368class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
369public:
370  DarwinClang(const Driver &D, const llvm::Triple &Triple,
371              const llvm::opt::ArgList &Args);
372
373  /// @name Darwin ToolChain Implementation
374  /// {
375
376  virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
377                                     llvm::opt::ArgStringList &CmdArgs) const;
378  void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
379                         llvm::opt::ArgStringList &CmdArgs,
380                         const char *DarwinStaticLib,
381                         bool AlwaysLink = false) const;
382
383  virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
384                                   llvm::opt::ArgStringList &CmdArgs) const;
385
386  virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
387                                llvm::opt::ArgStringList &CmdArgs) const;
388
389  virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
390                              llvm::opt::ArgStringList &CmdArgs) const;
391  /// }
392};
393
394/// Darwin_Generic_GCC - Generic Darwin tool chain using gcc.
395class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC {
396public:
397  Darwin_Generic_GCC(const Driver &D, const llvm::Triple &Triple,
398                     const llvm::opt::ArgList &Args)
399      : Generic_GCC(D, Triple, Args) {}
400
401  std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
402                                          types::ID InputType) const;
403
404  virtual bool isPICDefault() const { return false; }
405};
406
407class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
408  virtual void anchor();
409public:
410  Generic_ELF(const Driver &D, const llvm::Triple &Triple,
411              const llvm::opt::ArgList &Args)
412      : Generic_GCC(D, Triple, Args) {}
413
414  virtual bool IsIntegratedAssemblerDefault() const {
415    // Default integrated assembler to on for x86.
416    return (getTriple().getArch() == llvm::Triple::aarch64 ||
417            getTriple().getArch() == llvm::Triple::x86 ||
418            getTriple().getArch() == llvm::Triple::x86_64);
419  }
420};
421
422class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC {
423public:
424  AuroraUX(const Driver &D, const llvm::Triple &Triple,
425           const llvm::opt::ArgList &Args);
426
427protected:
428  virtual Tool *buildAssembler() const;
429  virtual Tool *buildLinker() const;
430};
431
432class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
433public:
434  Solaris(const Driver &D, const llvm::Triple &Triple,
435          const llvm::opt::ArgList &Args);
436
437  virtual bool IsIntegratedAssemblerDefault() const { return true; }
438protected:
439  virtual Tool *buildAssembler() const;
440  virtual Tool *buildLinker() const;
441
442};
443
444
445class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
446public:
447  OpenBSD(const Driver &D, const llvm::Triple &Triple,
448          const llvm::opt::ArgList &Args);
449
450  virtual bool IsMathErrnoDefault() const { return false; }
451  virtual bool IsObjCNonFragileABIDefault() const { return true; }
452  virtual bool isPIEDefault() const { return true; }
453
454  virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
455    return 1;
456  }
457
458protected:
459  virtual Tool *buildAssembler() const;
460  virtual Tool *buildLinker() const;
461};
462
463class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
464public:
465  Bitrig(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 IsObjCLegacyDispatchDefault() const { return false; }
471
472  virtual void
473  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
474                               llvm::opt::ArgStringList &CC1Args) const;
475  virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
476                                   llvm::opt::ArgStringList &CmdArgs) const;
477  virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
478     return 1;
479  }
480
481protected:
482  virtual Tool *buildAssembler() const;
483  virtual Tool *buildLinker() const;
484};
485
486class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
487public:
488  FreeBSD(const Driver &D, const llvm::Triple &Triple,
489          const llvm::opt::ArgList &Args);
490
491  virtual bool IsMathErrnoDefault() const { return false; }
492  virtual bool IsObjCNonFragileABIDefault() const { return true; }
493
494  virtual bool UseSjLjExceptions() const;
495protected:
496  virtual Tool *buildAssembler() const;
497  virtual Tool *buildLinker() const;
498};
499
500class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
501public:
502  NetBSD(const Driver &D, const llvm::Triple &Triple,
503         const llvm::opt::ArgList &Args);
504
505  virtual bool IsMathErrnoDefault() const { return false; }
506  virtual bool IsObjCNonFragileABIDefault() const { return true; }
507
508  virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
509
510  virtual void
511  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
512                               llvm::opt::ArgStringList &CC1Args) const;
513
514protected:
515  virtual Tool *buildAssembler() const;
516  virtual Tool *buildLinker() const;
517};
518
519class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
520public:
521  Minix(const Driver &D, const llvm::Triple &Triple,
522        const llvm::opt::ArgList &Args);
523
524protected:
525  virtual Tool *buildAssembler() const;
526  virtual Tool *buildLinker() const;
527};
528
529class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
530public:
531  DragonFly(const Driver &D, const llvm::Triple &Triple,
532            const llvm::opt::ArgList &Args);
533
534  virtual bool IsMathErrnoDefault() const { return false; }
535
536protected:
537  virtual Tool *buildAssembler() const;
538  virtual Tool *buildLinker() const;
539};
540
541class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
542public:
543  Linux(const Driver &D, const llvm::Triple &Triple,
544        const llvm::opt::ArgList &Args);
545
546  virtual bool HasNativeLLVMSupport() const;
547
548  virtual void
549  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
550                            llvm::opt::ArgStringList &CC1Args) const;
551  virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
552                                     llvm::opt::ArgStringList &CC1Args) const;
553  virtual void
554  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
555                               llvm::opt::ArgStringList &CC1Args) const;
556  virtual bool isPIEDefault() const;
557
558  std::string Linker;
559  std::vector<std::string> ExtraOpts;
560  bool IsPIEDefault;
561
562protected:
563  virtual Tool *buildAssembler() const;
564  virtual Tool *buildLinker() const;
565
566private:
567  static bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
568                                       Twine TargetArchDir,
569                                       Twine MultiLibSuffix,
570                                       const llvm::opt::ArgList &DriverArgs,
571                                       llvm::opt::ArgStringList &CC1Args);
572  static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
573                                       const llvm::opt::ArgList &DriverArgs,
574                                       llvm::opt::ArgStringList &CC1Args);
575
576  std::string computeSysRoot(const llvm::opt::ArgList &Args) const;
577};
578
579class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux {
580protected:
581  GCCVersion GCCLibAndIncVersion;
582  virtual Tool *buildAssembler() const;
583  virtual Tool *buildLinker() const;
584
585public:
586  Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
587             const llvm::opt::ArgList &Args);
588  ~Hexagon_TC();
589
590  virtual void
591  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
592                            llvm::opt::ArgStringList &CC1Args) const;
593  virtual void
594  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
595                               llvm::opt::ArgStringList &CC1Args) const;
596  virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
597
598  StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; }
599
600  static std::string GetGnuDir(const std::string &InstalledDir);
601
602  static StringRef GetTargetCPU(const llvm::opt::ArgList &Args);
603};
604
605/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
606/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
607class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
608public:
609  TCEToolChain(const Driver &D, const llvm::Triple &Triple,
610               const llvm::opt::ArgList &Args);
611  ~TCEToolChain();
612
613  bool IsMathErrnoDefault() const;
614  bool isPICDefault() const;
615  bool isPIEDefault() const;
616  bool isPICDefaultForced() const;
617};
618
619class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
620public:
621  Windows(const Driver &D, const llvm::Triple &Triple,
622          const llvm::opt::ArgList &Args);
623
624  virtual bool IsIntegratedAssemblerDefault() const;
625  virtual bool IsUnwindTablesDefault() const;
626  virtual bool isPICDefault() const;
627  virtual bool isPIEDefault() const;
628  virtual bool isPICDefaultForced() const;
629
630  virtual void
631  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
632                            llvm::opt::ArgStringList &CC1Args) const;
633  virtual void
634  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
635                               llvm::opt::ArgStringList &CC1Args) const;
636
637protected:
638  virtual Tool *buildLinker() const;
639  virtual Tool *buildAssembler() const;
640};
641
642} // end namespace toolchains
643} // end namespace driver
644} // end namespace clang
645
646#endif
647