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