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