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