Tools.h revision dd0b3c4c72464af92e2c27dd5a67e29f91ba7b28 
1//===--- Tools.h - Tool 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_TOOLS_H_
11#define CLANG_LIB_DRIVER_TOOLS_H_
12
13#include "clang/Driver/Tool.h"
14#include "clang/Driver/Types.h"
15#include "clang/Driver/Util.h"
16#include "llvm/ADT/Triple.h"
17#include "llvm/Option/Option.h"
18#include "llvm/Support/Compiler.h"
19
20namespace clang {
21  class ObjCRuntime;
22
23namespace driver {
24  class Driver;
25
26namespace toolchains {
27  class Darwin;
28}
29
30namespace tools {
31using llvm::opt::ArgStringList;
32
33  /// \brief Clang compiler tool.
34  class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
35  public:
36    static const char *getBaseInputName(const llvm::opt::ArgList &Args,
37                                        const InputInfoList &Inputs);
38    static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
39                                        const InputInfoList &Inputs);
40    static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
41                                             const InputInfoList &Inputs);
42
43  private:
44    void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
45                                 const Driver &D,
46                                 const llvm::opt::ArgList &Args,
47                                 llvm::opt::ArgStringList &CmdArgs,
48                                 const InputInfo &Output,
49                                 const InputInfoList &Inputs) const;
50
51    void AddARMTargetArgs(const llvm::opt::ArgList &Args,
52                          llvm::opt::ArgStringList &CmdArgs,
53                          bool KernelOrKext) const;
54    void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
55                           llvm::opt::ArgStringList &CmdArgs) const;
56    void AddPPCTargetArgs(const llvm::opt::ArgList &Args,
57                          llvm::opt::ArgStringList &CmdArgs) const;
58    void AddR600TargetArgs(const llvm::opt::ArgList &Args,
59                           llvm::opt::ArgStringList &CmdArgs) const;
60    void AddSparcTargetArgs(const llvm::opt::ArgList &Args,
61                            llvm::opt::ArgStringList &CmdArgs) const;
62    void AddX86TargetArgs(const llvm::opt::ArgList &Args,
63                          llvm::opt::ArgStringList &CmdArgs) const;
64    void AddHexagonTargetArgs(const llvm::opt::ArgList &Args,
65                              llvm::opt::ArgStringList &CmdArgs) const;
66
67    enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
68
69    ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
70                                   llvm::opt::ArgStringList &cmdArgs,
71                                   RewriteKind rewrite) const;
72
73  public:
74    Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
75
76    virtual bool hasGoodDiagnostics() const { return true; }
77    virtual bool hasIntegratedAssembler() const { return true; }
78    virtual bool hasIntegratedCPP() const { return true; }
79
80    virtual void ConstructJob(Compilation &C, const JobAction &JA,
81                              const InputInfo &Output,
82                              const InputInfoList &Inputs,
83                              const llvm::opt::ArgList &TCArgs,
84                              const char *LinkingOutput) const;
85  };
86
87  /// \brief Clang integrated assembler tool.
88  class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
89    void AddARMTargetArgs(const llvm::opt::ArgList &Args,
90                          llvm::opt::ArgStringList &CmdArgs) const;
91    void AddX86TargetArgs(const llvm::opt::ArgList &Args,
92                          llvm::opt::ArgStringList &CmdArgs) const;
93
94  public:
95    ClangAs(const ToolChain &TC) : Tool("clang::as",
96                                        "clang integrated assembler", TC) {}
97
98    virtual bool hasGoodDiagnostics() const { return true; }
99    virtual bool hasIntegratedAssembler() const { return false; }
100    virtual bool hasIntegratedCPP() const { return false; }
101
102    virtual void ConstructJob(Compilation &C, const JobAction &JA,
103                              const InputInfo &Output,
104                              const InputInfoList &Inputs,
105                              const llvm::opt::ArgList &TCArgs,
106                              const char *LinkingOutput) const;
107  };
108
109  /// gcc - Generic GCC tool implementations.
110namespace gcc {
111  class LLVM_LIBRARY_VISIBILITY Common : public Tool {
112  public:
113    Common(const char *Name, const char *ShortName,
114           const ToolChain &TC) : Tool(Name, ShortName, TC) {}
115
116    virtual void ConstructJob(Compilation &C, const JobAction &JA,
117                              const InputInfo &Output,
118                              const InputInfoList &Inputs,
119                              const llvm::opt::ArgList &TCArgs,
120                              const char *LinkingOutput) const;
121
122    /// RenderExtraToolArgs - Render any arguments necessary to force
123    /// the particular tool mode.
124    virtual void
125        RenderExtraToolArgs(const JobAction &JA,
126                            llvm::opt::ArgStringList &CmdArgs) const = 0;
127  };
128
129  class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
130  public:
131    Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
132                                             "gcc preprocessor", TC) {}
133
134    virtual bool hasGoodDiagnostics() const { return true; }
135    virtual bool hasIntegratedCPP() const { return false; }
136
137    virtual void RenderExtraToolArgs(const JobAction &JA,
138                                     llvm::opt::ArgStringList &CmdArgs) const;
139  };
140
141  class LLVM_LIBRARY_VISIBILITY Precompile : public Common  {
142  public:
143    Precompile(const ToolChain &TC) : Common("gcc::Precompile",
144                                             "gcc precompile", TC) {}
145
146    virtual bool hasGoodDiagnostics() const { return true; }
147    virtual bool hasIntegratedCPP() const { return true; }
148
149    virtual void RenderExtraToolArgs(const JobAction &JA,
150                                     llvm::opt::ArgStringList &CmdArgs) const;
151  };
152
153  class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
154  public:
155    Compile(const ToolChain &TC) : Common("gcc::Compile",
156                                          "gcc frontend", TC) {}
157
158    virtual bool hasGoodDiagnostics() const { return true; }
159    virtual bool hasIntegratedCPP() const { return true; }
160
161    virtual void RenderExtraToolArgs(const JobAction &JA,
162                                     llvm::opt::ArgStringList &CmdArgs) const;
163  };
164
165  class LLVM_LIBRARY_VISIBILITY Assemble : public Common  {
166  public:
167    Assemble(const ToolChain &TC) : Common("gcc::Assemble",
168                                           "assembler (via gcc)", TC) {}
169
170    virtual bool hasIntegratedCPP() const { return false; }
171
172    virtual void RenderExtraToolArgs(const JobAction &JA,
173                                     llvm::opt::ArgStringList &CmdArgs) const;
174  };
175
176  class LLVM_LIBRARY_VISIBILITY Link : public Common  {
177  public:
178    Link(const ToolChain &TC) : Common("gcc::Link",
179                                       "linker (via gcc)", TC) {}
180
181    virtual bool hasIntegratedCPP() const { return false; }
182    virtual bool isLinkJob() const { return true; }
183
184    virtual void RenderExtraToolArgs(const JobAction &JA,
185                                     llvm::opt::ArgStringList &CmdArgs) const;
186  };
187} // end namespace gcc
188
189namespace hexagon {
190  // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
191  // We simply use "clang -cc1" for those actions.
192  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
193  public:
194    Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
195      "hexagon-as", TC) {}
196
197    virtual bool hasIntegratedCPP() const { return false; }
198
199    virtual void RenderExtraToolArgs(const JobAction &JA,
200                                     llvm::opt::ArgStringList &CmdArgs) const;
201    virtual void ConstructJob(Compilation &C, const JobAction &JA,
202                              const InputInfo &Output,
203                              const InputInfoList &Inputs,
204                              const llvm::opt::ArgList &TCArgs,
205                              const char *LinkingOutput) const;
206  };
207
208  class LLVM_LIBRARY_VISIBILITY Link : public Tool {
209  public:
210    Link(const ToolChain &TC) : Tool("hexagon::Link",
211      "hexagon-ld", TC) {}
212
213    virtual bool hasIntegratedCPP() const { return false; }
214    virtual bool isLinkJob() const { return true; }
215
216    virtual void RenderExtraToolArgs(const JobAction &JA,
217                                     llvm::opt::ArgStringList &CmdArgs) const;
218    virtual void ConstructJob(Compilation &C, const JobAction &JA,
219                              const InputInfo &Output,
220                              const InputInfoList &Inputs,
221                              const llvm::opt::ArgList &TCArgs,
222                              const char *LinkingOutput) const;
223  };
224} // end namespace hexagon.
225
226
227namespace darwin {
228  llvm::Triple::ArchType getArchTypeForDarwinArchName(StringRef Str);
229
230  class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
231    virtual void anchor();
232  protected:
233    void AddDarwinArch(const llvm::opt::ArgList &Args,
234                       llvm::opt::ArgStringList &CmdArgs) const;
235
236    const toolchains::Darwin &getDarwinToolChain() const {
237      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
238    }
239
240  public:
241    DarwinTool(const char *Name, const char *ShortName,
242               const ToolChain &TC) : Tool(Name, ShortName, TC) {}
243  };
244
245  class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
246  public:
247    Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
248                                               "assembler", TC) {}
249
250    virtual bool hasIntegratedCPP() const { return false; }
251
252    virtual void ConstructJob(Compilation &C, const JobAction &JA,
253                              const InputInfo &Output,
254                              const InputInfoList &Inputs,
255                              const llvm::opt::ArgList &TCArgs,
256                              const char *LinkingOutput) const;
257  };
258
259  class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
260    bool NeedsTempPath(const InputInfoList &Inputs) const;
261    void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
262                     llvm::opt::ArgStringList &CmdArgs,
263                     const InputInfoList &Inputs) const;
264
265  public:
266    Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
267
268    virtual bool hasIntegratedCPP() const { return false; }
269    virtual bool isLinkJob() const { return true; }
270
271    virtual void ConstructJob(Compilation &C, const JobAction &JA,
272                              const InputInfo &Output,
273                              const InputInfoList &Inputs,
274                              const llvm::opt::ArgList &TCArgs,
275                              const char *LinkingOutput) const;
276  };
277
278  class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
279  public:
280    Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
281
282    virtual bool hasIntegratedCPP() const { return false; }
283
284    virtual void ConstructJob(Compilation &C, const JobAction &JA,
285                              const InputInfo &Output,
286                              const InputInfoList &Inputs,
287                              const llvm::opt::ArgList &TCArgs,
288                              const char *LinkingOutput) const;
289  };
290
291  class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
292  public:
293    Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
294                                               "dsymutil", TC) {}
295
296    virtual bool hasIntegratedCPP() const { return false; }
297    virtual bool isDsymutilJob() const { return true; }
298
299    virtual void ConstructJob(Compilation &C, const JobAction &JA,
300                              const InputInfo &Output,
301                              const InputInfoList &Inputs,
302                              const llvm::opt::ArgList &TCArgs,
303                              const char *LinkingOutput) const;
304  };
305
306  class LLVM_LIBRARY_VISIBILITY VerifyDebug : public DarwinTool  {
307  public:
308    VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
309                                                  "dwarfdump", TC) {}
310
311    virtual bool hasIntegratedCPP() const { return false; }
312
313    virtual void ConstructJob(Compilation &C, const JobAction &JA,
314                              const InputInfo &Output,
315                              const InputInfoList &Inputs,
316                              const llvm::opt::ArgList &TCArgs,
317                              const char *LinkingOutput) const;
318  };
319
320}
321
322  /// openbsd -- Directly call GNU Binutils assembler and linker
323namespace openbsd {
324  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
325  public:
326    Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
327                                         TC) {}
328
329    virtual bool hasIntegratedCPP() const { return false; }
330
331    virtual void ConstructJob(Compilation &C, const JobAction &JA,
332                              const InputInfo &Output,
333                              const InputInfoList &Inputs,
334                              const llvm::opt::ArgList &TCArgs,
335                              const char *LinkingOutput) const;
336  };
337  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
338  public:
339    Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
340
341    virtual bool hasIntegratedCPP() const { return false; }
342    virtual bool isLinkJob() const { return true; }
343
344    virtual void ConstructJob(Compilation &C, const JobAction &JA,
345                              const InputInfo &Output,
346                              const InputInfoList &Inputs,
347                              const llvm::opt::ArgList &TCArgs,
348                              const char *LinkingOutput) const;
349  };
350} // end namespace openbsd
351
352  /// bitrig -- Directly call GNU Binutils assembler and linker
353namespace bitrig {
354  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
355  public:
356    Assemble(const ToolChain &TC) : Tool("bitrig::Assemble", "assembler",
357                                         TC) {}
358
359    virtual bool hasIntegratedCPP() const { return false; }
360
361    virtual void ConstructJob(Compilation &C, const JobAction &JA,
362                              const InputInfo &Output,
363                              const InputInfoList &Inputs,
364                              const llvm::opt::ArgList &TCArgs,
365                              const char *LinkingOutput) const;
366  };
367  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
368  public:
369    Link(const ToolChain &TC) : Tool("bitrig::Link", "linker", TC) {}
370
371    virtual bool hasIntegratedCPP() const { return false; }
372    virtual bool isLinkJob() const { return true; }
373
374    virtual void ConstructJob(Compilation &C, const JobAction &JA,
375                              const InputInfo &Output,
376                              const InputInfoList &Inputs,
377                              const llvm::opt::ArgList &TCArgs,
378                              const char *LinkingOutput) const;
379  };
380} // end namespace bitrig
381
382  /// freebsd -- Directly call GNU Binutils assembler and linker
383namespace freebsd {
384  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
385  public:
386    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
387                                         TC) {}
388
389    virtual bool hasIntegratedCPP() const { return false; }
390
391    virtual void ConstructJob(Compilation &C, const JobAction &JA,
392                              const InputInfo &Output,
393                              const InputInfoList &Inputs,
394                              const llvm::opt::ArgList &TCArgs,
395                              const char *LinkingOutput) const;
396  };
397  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
398  public:
399    Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
400
401    virtual bool hasIntegratedCPP() const { return false; }
402    virtual bool isLinkJob() const { return true; }
403
404    virtual void ConstructJob(Compilation &C, const JobAction &JA,
405                              const InputInfo &Output,
406                              const InputInfoList &Inputs,
407                              const llvm::opt::ArgList &TCArgs,
408                              const char *LinkingOutput) const;
409  };
410} // end namespace freebsd
411
412  /// netbsd -- Directly call GNU Binutils assembler and linker
413namespace netbsd {
414  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
415
416  public:
417    Assemble(const ToolChain &TC)
418      : Tool("netbsd::Assemble", "assembler", TC) {}
419
420    virtual bool hasIntegratedCPP() const { return false; }
421
422    virtual void ConstructJob(Compilation &C, const JobAction &JA,
423                              const InputInfo &Output,
424                              const InputInfoList &Inputs,
425                              const llvm::opt::ArgList &TCArgs,
426                              const char *LinkingOutput) const;
427  };
428  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
429
430  public:
431    Link(const ToolChain &TC)
432      : Tool("netbsd::Link", "linker", TC) {}
433
434    virtual bool hasIntegratedCPP() const { return false; }
435    virtual bool isLinkJob() const { return true; }
436
437    virtual void ConstructJob(Compilation &C, const JobAction &JA,
438                              const InputInfo &Output,
439                              const InputInfoList &Inputs,
440                              const llvm::opt::ArgList &TCArgs,
441                              const char *LinkingOutput) const;
442  };
443} // end namespace netbsd
444
445  /// Directly call GNU Binutils' assembler and linker.
446namespace gnutools {
447  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
448  public:
449    Assemble(const ToolChain &TC) : Tool("GNU::Assemble", "assembler", TC) {}
450
451    virtual bool hasIntegratedCPP() const { return false; }
452
453    virtual void ConstructJob(Compilation &C, const JobAction &JA,
454                              const InputInfo &Output,
455                              const InputInfoList &Inputs,
456                              const llvm::opt::ArgList &TCArgs,
457                              const char *LinkingOutput) const;
458  };
459  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
460  public:
461    Link(const ToolChain &TC) : Tool("GNU::Link", "linker", TC) {}
462
463    virtual bool hasIntegratedCPP() const { return false; }
464    virtual bool isLinkJob() const { return true; }
465
466    virtual void ConstructJob(Compilation &C, const JobAction &JA,
467                              const InputInfo &Output,
468                              const InputInfoList &Inputs,
469                              const llvm::opt::ArgList &TCArgs,
470                              const char *LinkingOutput) const;
471  };
472}
473  /// minix -- Directly call GNU Binutils assembler and linker
474namespace minix {
475  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
476  public:
477    Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
478                                         TC) {}
479
480    virtual bool hasIntegratedCPP() const { return false; }
481
482    virtual void ConstructJob(Compilation &C, const JobAction &JA,
483                              const InputInfo &Output,
484                              const InputInfoList &Inputs,
485                              const llvm::opt::ArgList &TCArgs,
486                              const char *LinkingOutput) const;
487  };
488  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
489  public:
490    Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
491
492    virtual bool hasIntegratedCPP() const { return false; }
493    virtual bool isLinkJob() const { return true; }
494
495    virtual void ConstructJob(Compilation &C, const JobAction &JA,
496                              const InputInfo &Output,
497                              const InputInfoList &Inputs,
498                              const llvm::opt::ArgList &TCArgs,
499                              const char *LinkingOutput) const;
500  };
501} // end namespace minix
502
503  /// solaris -- Directly call Solaris assembler and linker
504namespace solaris {
505  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
506  public:
507    Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
508                                         TC) {}
509
510    virtual bool hasIntegratedCPP() const { return false; }
511
512    virtual void ConstructJob(Compilation &C, const JobAction &JA,
513                              const InputInfo &Output,
514                              const InputInfoList &Inputs,
515                              const llvm::opt::ArgList &TCArgs,
516                              const char *LinkingOutput) const;
517  };
518  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
519  public:
520    Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
521
522    virtual bool hasIntegratedCPP() const { return false; }
523    virtual bool isLinkJob() const { return true; }
524
525    virtual void ConstructJob(Compilation &C, const JobAction &JA,
526                              const InputInfo &Output,
527                              const InputInfoList &Inputs,
528                              const llvm::opt::ArgList &TCArgs,
529                              const char *LinkingOutput) const;
530  };
531} // end namespace solaris
532
533  /// auroraux -- Directly call GNU Binutils assembler and linker
534namespace auroraux {
535  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
536  public:
537    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
538                                         TC) {}
539
540    virtual bool hasIntegratedCPP() const { return false; }
541
542    virtual void ConstructJob(Compilation &C, const JobAction &JA,
543                              const InputInfo &Output,
544                              const InputInfoList &Inputs,
545                              const llvm::opt::ArgList &TCArgs,
546                              const char *LinkingOutput) const;
547  };
548  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
549  public:
550    Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
551
552    virtual bool hasIntegratedCPP() const { return false; }
553    virtual bool isLinkJob() const { return true; }
554
555    virtual void ConstructJob(Compilation &C, const JobAction &JA,
556                              const InputInfo &Output,
557                              const InputInfoList &Inputs,
558                              const llvm::opt::ArgList &TCArgs,
559                              const char *LinkingOutput) const;
560  };
561} // end namespace auroraux
562
563  /// dragonfly -- Directly call GNU Binutils assembler and linker
564namespace dragonfly {
565  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
566  public:
567    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
568                                         TC) {}
569
570    virtual bool hasIntegratedCPP() const { return false; }
571
572    virtual void ConstructJob(Compilation &C, const JobAction &JA,
573                              const InputInfo &Output,
574                              const InputInfoList &Inputs,
575                              const llvm::opt::ArgList &TCArgs,
576                              const char *LinkingOutput) const;
577  };
578  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
579  public:
580    Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
581
582    virtual bool hasIntegratedCPP() const { return false; }
583    virtual bool isLinkJob() const { return true; }
584
585    virtual void ConstructJob(Compilation &C, const JobAction &JA,
586                              const InputInfo &Output,
587                              const InputInfoList &Inputs,
588                              const llvm::opt::ArgList &TCArgs,
589                              const char *LinkingOutput) const;
590  };
591} // end namespace dragonfly
592
593  /// Visual studio tools.
594namespace visualstudio {
595  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
596  public:
597    Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
598
599    virtual bool hasIntegratedCPP() const { return false; }
600    virtual bool isLinkJob() const { return true; }
601
602    virtual void ConstructJob(Compilation &C, const JobAction &JA,
603                              const InputInfo &Output,
604                              const InputInfoList &Inputs,
605                              const llvm::opt::ArgList &TCArgs,
606                              const char *LinkingOutput) const;
607  };
608} // end namespace visualstudio
609
610} // end namespace toolchains
611} // end namespace driver
612} // end namespace clang
613
614#endif // CLANG_LIB_DRIVER_TOOLS_H_
615