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 
20 namespace clang {
21   class ObjCRuntime;
22 
23 namespace driver {
24   class Command;
25   class Driver;
26 
27 namespace toolchains {
28   class Darwin;
29 }
30 
31 namespace tools {
32 using 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:
Clang(const ToolChain & TC)80     Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
81 
hasGoodDiagnostics()82     virtual bool hasGoodDiagnostics() const { return true; }
hasIntegratedAssembler()83     virtual bool hasIntegratedAssembler() const { return true; }
hasIntegratedCPP()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:
ClangAs(const ToolChain & TC)96     ClangAs(const ToolChain &TC) : Tool("clang::as",
97                                         "clang integrated assembler", TC) {}
98 
hasGoodDiagnostics()99     virtual bool hasGoodDiagnostics() const { return true; }
hasIntegratedAssembler()100     virtual bool hasIntegratedAssembler() const { return false; }
hasIntegratedCPP()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.
111 namespace gcc {
112   class LLVM_LIBRARY_VISIBILITY Common : public Tool {
113   public:
Common(const char * Name,const char * ShortName,const ToolChain & TC)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:
Preprocess(const ToolChain & TC)132     Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
133                                              "gcc preprocessor", TC) {}
134 
hasGoodDiagnostics()135     virtual bool hasGoodDiagnostics() const { return true; }
hasIntegratedCPP()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:
Precompile(const ToolChain & TC)144     Precompile(const ToolChain &TC) : Common("gcc::Precompile",
145                                              "gcc precompile", TC) {}
146 
hasGoodDiagnostics()147     virtual bool hasGoodDiagnostics() const { return true; }
hasIntegratedCPP()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:
Compile(const ToolChain & TC)156     Compile(const ToolChain &TC) : Common("gcc::Compile",
157                                           "gcc frontend", TC) {}
158 
hasGoodDiagnostics()159     virtual bool hasGoodDiagnostics() const { return true; }
hasIntegratedCPP()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:
Assemble(const ToolChain & TC)168     Assemble(const ToolChain &TC) : Common("gcc::Assemble",
169                                            "assembler (via gcc)", TC) {}
170 
hasIntegratedCPP()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:
Link(const ToolChain & TC)179     Link(const ToolChain &TC) : Common("gcc::Link",
180                                        "linker (via gcc)", TC) {}
181 
hasIntegratedCPP()182     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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 
190 namespace 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:
Assemble(const ToolChain & TC)195     Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
196       "hexagon-as", TC) {}
197 
hasIntegratedCPP()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:
Link(const ToolChain & TC)211     Link(const ToolChain &TC) : Tool("hexagon::Link",
212       "hexagon-ld", TC) {}
213 
hasIntegratedCPP()214     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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 
228 namespace 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 
getDarwinToolChain()237     const toolchains::Darwin &getDarwinToolChain() const {
238       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
239     }
240 
241   public:
DarwinTool(const char * Name,const char * ShortName,const ToolChain & TC)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:
Assemble(const ToolChain & TC)248     Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
249                                                "assembler", TC) {}
250 
hasIntegratedCPP()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:
Link(const ToolChain & TC)267     Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
268 
hasIntegratedCPP()269     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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:
Lipo(const ToolChain & TC)281     Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
282 
hasIntegratedCPP()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:
Dsymutil(const ToolChain & TC)294     Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
295                                                "dsymutil", TC) {}
296 
hasIntegratedCPP()297     virtual bool hasIntegratedCPP() const { return false; }
isDsymutilJob()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:
VerifyDebug(const ToolChain & TC)309     VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
310                                                   "dwarfdump", TC) {}
311 
hasIntegratedCPP()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
324 namespace openbsd {
325   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
326   public:
Assemble(const ToolChain & TC)327     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
328                                          TC) {}
329 
hasIntegratedCPP()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:
Link(const ToolChain & TC)340     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
341 
hasIntegratedCPP()342     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
354 namespace bitrig {
355   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
356   public:
Assemble(const ToolChain & TC)357     Assemble(const ToolChain &TC) : Tool("bitrig::Assemble", "assembler",
358                                          TC) {}
359 
hasIntegratedCPP()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:
Link(const ToolChain & TC)370     Link(const ToolChain &TC) : Tool("bitrig::Link", "linker", TC) {}
371 
hasIntegratedCPP()372     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
384 namespace freebsd {
385   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
386   public:
Assemble(const ToolChain & TC)387     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
388                                          TC) {}
389 
hasIntegratedCPP()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:
Link(const ToolChain & TC)400     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
401 
hasIntegratedCPP()402     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
414 namespace netbsd {
415   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
416 
417   public:
Assemble(const ToolChain & TC)418     Assemble(const ToolChain &TC)
419       : Tool("netbsd::Assemble", "assembler", TC) {}
420 
hasIntegratedCPP()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:
Link(const ToolChain & TC)432     Link(const ToolChain &TC)
433       : Tool("netbsd::Link", "linker", TC) {}
434 
hasIntegratedCPP()435     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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.
447 namespace gnutools {
448   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
449   public:
Assemble(const ToolChain & TC)450     Assemble(const ToolChain &TC) : Tool("GNU::Assemble", "assembler", TC) {}
451 
hasIntegratedCPP()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:
Link(const ToolChain & TC)462     Link(const ToolChain &TC) : Tool("GNU::Link", "linker", TC) {}
463 
hasIntegratedCPP()464     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
475 namespace minix {
476   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
477   public:
Assemble(const ToolChain & TC)478     Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
479                                          TC) {}
480 
hasIntegratedCPP()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:
Link(const ToolChain & TC)491     Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
492 
hasIntegratedCPP()493     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
505 namespace solaris {
506   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
507   public:
Assemble(const ToolChain & TC)508     Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
509                                          TC) {}
510 
hasIntegratedCPP()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:
Link(const ToolChain & TC)521     Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
522 
hasIntegratedCPP()523     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
535 namespace auroraux {
536   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
537   public:
Assemble(const ToolChain & TC)538     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
539                                          TC) {}
540 
hasIntegratedCPP()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:
Link(const ToolChain & TC)551     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
552 
hasIntegratedCPP()553     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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
565 namespace dragonfly {
566   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
567   public:
Assemble(const ToolChain & TC)568     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
569                                          TC) {}
570 
hasIntegratedCPP()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:
Link(const ToolChain & TC)581     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
582 
hasIntegratedCPP()583     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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.
595 namespace visualstudio {
596   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
597   public:
Link(const ToolChain & TC)598     Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
599 
hasIntegratedCPP()600     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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:
Compile(const ToolChain & TC)612     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC) {}
613 
hasIntegratedAssembler()614     virtual bool hasIntegratedAssembler() const { return true; }
hasIntegratedCPP()615     virtual bool hasIntegratedCPP() const { return true; }
isLinkJob()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 
632 namespace 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:
Assemble(const ToolChain & TC)637     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
638       "XCore-as", TC) {}
639 
hasIntegratedCPP()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:
Link(const ToolChain & TC)650     Link(const ToolChain &TC) : Tool("XCore::Link",
651       "XCore-ld", TC) {}
652 
hasIntegratedCPP()653     virtual bool hasIntegratedCPP() const { return false; }
isLinkJob()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