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