Tools.h revision 285f9a284704c07cd50e4597408d5f93518cd7c3 
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
17#include "llvm/ADT/Triple.h"
18#include "llvm/Support/Compiler.h"
19
20namespace clang {
21namespace driver {
22  class Driver;
23
24namespace toolchains {
25  class Darwin;
26}
27
28namespace tools {
29
30  /// \brief Clang compiler tool.
31  class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
32    void AddPreprocessingOptions(const Driver &D,
33                                 const ArgList &Args,
34                                 ArgStringList &CmdArgs,
35                                 const InputInfo &Output,
36                                 const InputInfoList &Inputs) const;
37
38    void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
39                          bool KernelOrKext) const;
40    void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
41    void AddSparcTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
42    void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
43
44  public:
45    Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
46
47    virtual bool hasGoodDiagnostics() const { return true; }
48    virtual bool hasIntegratedAssembler() const { return true; }
49    virtual bool hasIntegratedCPP() const { return true; }
50
51    virtual void ConstructJob(Compilation &C, const JobAction &JA,
52                              const InputInfo &Output,
53                              const InputInfoList &Inputs,
54                              const ArgList &TCArgs,
55                              const char *LinkingOutput) const;
56  };
57
58  /// \brief Clang integrated assembler tool.
59  class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
60  public:
61    ClangAs(const ToolChain &TC) : Tool("clang::as",
62                                        "clang integrated assembler", TC) {}
63
64    virtual bool hasGoodDiagnostics() const { return true; }
65    virtual bool hasIntegratedAssembler() const { return false; }
66    virtual bool hasIntegratedCPP() const { return false; }
67
68    virtual void ConstructJob(Compilation &C, const JobAction &JA,
69                              const InputInfo &Output,
70                              const InputInfoList &Inputs,
71                              const ArgList &TCArgs,
72                              const char *LinkingOutput) const;
73  };
74
75  /// gcc - Generic GCC tool implementations.
76namespace gcc {
77  class LLVM_LIBRARY_VISIBILITY Common : public Tool {
78  public:
79    Common(const char *Name, const char *ShortName,
80           const ToolChain &TC) : Tool(Name, ShortName, TC) {}
81
82    virtual void ConstructJob(Compilation &C, const JobAction &JA,
83                              const InputInfo &Output,
84                              const InputInfoList &Inputs,
85                              const ArgList &TCArgs,
86                              const char *LinkingOutput) const;
87
88    /// RenderExtraToolArgs - Render any arguments necessary to force
89    /// the particular tool mode.
90    virtual void RenderExtraToolArgs(const JobAction &JA,
91                                     ArgStringList &CmdArgs) const = 0;
92  };
93
94
95  class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
96  public:
97    Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
98                                             "gcc preprocessor", TC) {}
99
100    virtual bool hasGoodDiagnostics() const { return true; }
101    virtual bool hasIntegratedCPP() const { return false; }
102
103    virtual void RenderExtraToolArgs(const JobAction &JA,
104                                     ArgStringList &CmdArgs) const;
105  };
106
107  class LLVM_LIBRARY_VISIBILITY Precompile : public Common  {
108  public:
109    Precompile(const ToolChain &TC) : Common("gcc::Precompile",
110                                             "gcc precompile", TC) {}
111
112    virtual bool hasGoodDiagnostics() const { return true; }
113    virtual bool hasIntegratedCPP() const { return true; }
114
115    virtual void RenderExtraToolArgs(const JobAction &JA,
116                                     ArgStringList &CmdArgs) const;
117  };
118
119  class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
120  public:
121    Compile(const ToolChain &TC) : Common("gcc::Compile",
122                                          "gcc frontend", TC) {}
123
124    virtual bool hasGoodDiagnostics() const { return true; }
125    virtual bool hasIntegratedCPP() const { return true; }
126
127    virtual void RenderExtraToolArgs(const JobAction &JA,
128                                     ArgStringList &CmdArgs) const;
129  };
130
131  class LLVM_LIBRARY_VISIBILITY Assemble : public Common  {
132  public:
133    Assemble(const ToolChain &TC) : Common("gcc::Assemble",
134                                           "assembler (via gcc)", TC) {}
135
136    virtual bool hasIntegratedCPP() const { return false; }
137
138    virtual void RenderExtraToolArgs(const JobAction &JA,
139                                     ArgStringList &CmdArgs) const;
140  };
141
142  class LLVM_LIBRARY_VISIBILITY Link : public Common  {
143  public:
144    Link(const ToolChain &TC) : Common("gcc::Link",
145                                       "linker (via gcc)", TC) {}
146
147    virtual bool hasIntegratedCPP() const { return false; }
148
149    virtual void RenderExtraToolArgs(const JobAction &JA,
150                                     ArgStringList &CmdArgs) const;
151  };
152} // end namespace gcc
153
154namespace darwin {
155  class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
156  protected:
157    void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
158
159    const toolchains::Darwin &getDarwinToolChain() const {
160      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
161    }
162
163  public:
164    DarwinTool(const char *Name, const char *ShortName,
165               const ToolChain &TC) : Tool(Name, ShortName, TC) {}
166  };
167
168  class LLVM_LIBRARY_VISIBILITY CC1 : public DarwinTool  {
169  public:
170    static const char *getBaseInputName(const ArgList &Args,
171                                 const InputInfoList &Input);
172    static const char *getBaseInputStem(const ArgList &Args,
173                                 const InputInfoList &Input);
174    static const char *getDependencyFileName(const ArgList &Args,
175                                             const InputInfoList &Inputs);
176
177  protected:
178    const char *getCC1Name(types::ID Type) const;
179
180    void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
181    void RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const;
182    void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
183                           const InputInfoList &Inputs,
184                           const ArgStringList &OutputArgs) const;
185    void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
186                           const InputInfoList &Inputs,
187                           const ArgStringList &OutputArgs) const;
188    void AddCPPUniqueOptionsArgs(const ArgList &Args,
189                                 ArgStringList &CmdArgs,
190                                 const InputInfoList &Inputs) const;
191    void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
192
193  public:
194    CC1(const char *Name, const char *ShortName,
195        const ToolChain &TC) : DarwinTool(Name, ShortName, TC) {}
196
197    virtual bool hasGoodDiagnostics() const { return true; }
198    virtual bool hasIntegratedCPP() const { return true; }
199  };
200
201  class LLVM_LIBRARY_VISIBILITY Preprocess : public CC1  {
202  public:
203    Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess",
204                                          "gcc preprocessor", TC) {}
205
206    virtual void ConstructJob(Compilation &C, const JobAction &JA,
207                              const InputInfo &Output,
208                              const InputInfoList &Inputs,
209                              const ArgList &TCArgs,
210                              const char *LinkingOutput) const;
211  };
212
213  class LLVM_LIBRARY_VISIBILITY Compile : public CC1  {
214  public:
215    Compile(const ToolChain &TC) : CC1("darwin::Compile", "gcc frontend", TC) {}
216
217    virtual void ConstructJob(Compilation &C, const JobAction &JA,
218                              const InputInfo &Output,
219                              const InputInfoList &Inputs,
220                              const ArgList &TCArgs,
221                              const char *LinkingOutput) const;
222  };
223
224  class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
225  public:
226    Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
227                                               "assembler", TC) {}
228
229    virtual bool hasIntegratedCPP() const { return false; }
230
231    virtual void ConstructJob(Compilation &C, const JobAction &JA,
232                              const InputInfo &Output,
233                              const InputInfoList &Inputs,
234                              const ArgList &TCArgs,
235                              const char *LinkingOutput) const;
236  };
237
238  class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
239    void AddLinkArgs(Compilation &C, const ArgList &Args,
240                     ArgStringList &CmdArgs) const;
241
242  public:
243    Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
244
245    virtual bool hasIntegratedCPP() const { return false; }
246
247    virtual void ConstructJob(Compilation &C, const JobAction &JA,
248                              const InputInfo &Output,
249                              const InputInfoList &Inputs,
250                              const ArgList &TCArgs,
251                              const char *LinkingOutput) const;
252  };
253
254  class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
255  public:
256    Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
257
258    virtual bool hasIntegratedCPP() const { return false; }
259
260    virtual void ConstructJob(Compilation &C, const JobAction &JA,
261                              const InputInfo &Output,
262                              const InputInfoList &Inputs,
263                              const ArgList &TCArgs,
264                              const char *LinkingOutput) const;
265  };
266
267  class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
268  public:
269    Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
270                                               "dsymutil", TC) {}
271
272    virtual bool hasIntegratedCPP() const { return false; }
273
274    virtual void ConstructJob(Compilation &C, const JobAction &JA,
275                              const InputInfo &Output,
276                              const InputInfoList &Inputs,
277                              const ArgList &TCArgs,
278                              const char *LinkingOutput) const;
279  };
280}
281
282  /// openbsd -- Directly call GNU Binutils assembler and linker
283namespace openbsd {
284  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
285  public:
286    Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
287                                         TC) {}
288
289    virtual bool hasIntegratedCPP() const { return false; }
290
291    virtual void ConstructJob(Compilation &C, const JobAction &JA,
292                              const InputInfo &Output,
293                              const InputInfoList &Inputs,
294                              const ArgList &TCArgs,
295                              const char *LinkingOutput) const;
296  };
297  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
298  public:
299    Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
300
301    virtual bool hasIntegratedCPP() const { return false; }
302
303    virtual void ConstructJob(Compilation &C, const JobAction &JA,
304                              const InputInfo &Output,
305                              const InputInfoList &Inputs,
306                              const ArgList &TCArgs,
307                              const char *LinkingOutput) const;
308  };
309} // end namespace openbsd
310
311  /// freebsd -- Directly call GNU Binutils assembler and linker
312namespace freebsd {
313  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
314  public:
315    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
316                                         TC) {}
317
318    virtual bool hasIntegratedCPP() const { return false; }
319
320    virtual void ConstructJob(Compilation &C, const JobAction &JA,
321                              const InputInfo &Output,
322                              const InputInfoList &Inputs,
323                              const ArgList &TCArgs,
324                              const char *LinkingOutput) const;
325  };
326  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
327  public:
328    Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", 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 ArgList &TCArgs,
336                              const char *LinkingOutput) const;
337  };
338} // end namespace freebsd
339
340  /// netbsd -- Directly call GNU Binutils assembler and linker
341namespace netbsd {
342  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
343  private:
344    const llvm::Triple ToolTriple;
345
346  public:
347    Assemble(const ToolChain &TC, const llvm::Triple &ToolTriple)
348      : Tool("netbsd::Assemble", "assembler", TC), ToolTriple(ToolTriple) {}
349
350    virtual bool hasIntegratedCPP() const { return false; }
351
352    virtual void ConstructJob(Compilation &C, const JobAction &JA,
353                              const InputInfo &Output,
354                              const InputInfoList &Inputs,
355                              const ArgList &TCArgs,
356                              const char *LinkingOutput) const;
357  };
358  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
359  private:
360    const llvm::Triple ToolTriple;
361
362  public:
363    Link(const ToolChain &TC, const llvm::Triple &ToolTriple)
364      : Tool("netbsd::Link", "linker", TC), ToolTriple(ToolTriple) {}
365
366    virtual bool hasIntegratedCPP() const { return false; }
367
368    virtual void ConstructJob(Compilation &C, const JobAction &JA,
369                              const InputInfo &Output,
370                              const InputInfoList &Inputs,
371                              const ArgList &TCArgs,
372                              const char *LinkingOutput) const;
373  };
374} // end namespace netbsd
375
376  /// linux -- Directly call GNU Binutils assembler and linker
377namespace linuxtools {
378  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
379  public:
380    Assemble(const ToolChain &TC) : Tool("linux::Assemble", "assembler",
381                                         TC) {}
382
383    virtual bool hasIntegratedCPP() const { return false; }
384
385    virtual void ConstructJob(Compilation &C, const JobAction &JA,
386                              const InputInfo &Output,
387                              const InputInfoList &Inputs,
388                              const ArgList &TCArgs,
389                              const char *LinkingOutput) const;
390  };
391  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
392  public:
393    Link(const ToolChain &TC) : Tool("linux::Link", "linker", TC) {}
394
395    virtual bool hasIntegratedCPP() const { return false; }
396
397    virtual void ConstructJob(Compilation &C, const JobAction &JA,
398                              const InputInfo &Output,
399                              const InputInfoList &Inputs,
400                              const ArgList &TCArgs,
401                              const char *LinkingOutput) const;
402  };
403}
404  /// minix -- Directly call GNU Binutils assembler and linker
405namespace minix {
406  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
407  public:
408    Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
409                                         TC) {}
410
411    virtual bool hasIntegratedCPP() const { return false; }
412
413    virtual void ConstructJob(Compilation &C, const JobAction &JA,
414                              const InputInfo &Output,
415                              const InputInfoList &Inputs,
416                              const ArgList &TCArgs,
417                              const char *LinkingOutput) const;
418  };
419  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
420  public:
421    Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
422
423    virtual bool hasIntegratedCPP() const { return false; }
424
425    virtual void ConstructJob(Compilation &C, const JobAction &JA,
426                              const InputInfo &Output,
427                              const InputInfoList &Inputs,
428                              const ArgList &TCArgs,
429                              const char *LinkingOutput) const;
430  };
431} // end namespace minix
432
433  /// auroraux -- Directly call GNU Binutils assembler and linker
434namespace auroraux {
435  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
436  public:
437    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
438                                         TC) {}
439
440    virtual bool hasIntegratedCPP() const { return false; }
441
442    virtual void ConstructJob(Compilation &C, const JobAction &JA,
443                              const InputInfo &Output,
444                              const InputInfoList &Inputs,
445                              const ArgList &TCArgs,
446                              const char *LinkingOutput) const;
447  };
448  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
449  public:
450    Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", 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 ArgList &TCArgs,
458                              const char *LinkingOutput) const;
459  };
460} // end namespace auroraux
461
462  /// dragonfly -- Directly call GNU Binutils assembler and linker
463namespace dragonfly {
464  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
465  public:
466    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
467                                         TC) {}
468
469    virtual bool hasIntegratedCPP() const { return false; }
470
471    virtual void ConstructJob(Compilation &C, const JobAction &JA,
472                              const InputInfo &Output,
473                              const InputInfoList &Inputs,
474                              const ArgList &TCArgs,
475                              const char *LinkingOutput) const;
476  };
477  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
478  public:
479    Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", 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 ArgList &TCArgs,
487                              const char *LinkingOutput) const;
488  };
489} // end namespace dragonfly
490
491  /// Visual studio tools.
492namespace visualstudio {
493  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
494  public:
495    Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
496
497    virtual bool hasIntegratedCPP() const { return false; }
498
499    virtual void ConstructJob(Compilation &C, const JobAction &JA,
500                              const InputInfo &Output,
501                              const InputInfoList &Inputs,
502                              const ArgList &TCArgs,
503                              const char *LinkingOutput) const;
504  };
505} // end namespace visualstudio
506
507} // end namespace toolchains
508} // end namespace driver
509} // end namespace clang
510
511#endif // CLANG_LIB_DRIVER_TOOLS_H_
512