Tools.h revision 20a9aa50f9a7d4b03f97bc67e96da1d605c309a2 
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/Support/Compiler.h"
18
19namespace clang {
20namespace driver {
21  class Driver;
22
23namespace toolchains {
24  class Darwin;
25}
26
27namespace tools {
28
29  /// \brief Clang compiler tool.
30  class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
31    void AddPreprocessingOptions(const Driver &D,
32                                 const ArgList &Args,
33                                 ArgStringList &CmdArgs,
34                                 const InputInfo &Output,
35                                 const InputInfoList &Inputs) const;
36
37    void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
38    void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
39    void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
40
41  public:
42    Clang(const ToolChain &TC) : Tool("clang", TC) {}
43
44    virtual bool acceptsPipedInput() const { return true; }
45    virtual bool canPipeOutput() const { return true; }
46    virtual bool hasGoodDiagnostics() const { return true; }
47    virtual bool hasIntegratedAssembler() const { return true; }
48    virtual bool hasIntegratedCPP() const { return true; }
49
50    virtual void ConstructJob(Compilation &C, const JobAction &JA,
51                              Job &Dest,
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", TC) {}
62
63    virtual bool acceptsPipedInput() const { return true; }
64    virtual bool canPipeOutput() const { return true; }
65    virtual bool hasGoodDiagnostics() const { return true; }
66    virtual bool hasIntegratedAssembler() const { return false; }
67    virtual bool hasIntegratedCPP() const { return false; }
68
69    virtual void ConstructJob(Compilation &C, const JobAction &JA,
70                              Job &Dest,
71                              const InputInfo &Output,
72                              const InputInfoList &Inputs,
73                              const ArgList &TCArgs,
74                              const char *LinkingOutput) const;
75  };
76
77  /// gcc - Generic GCC tool implementations.
78namespace gcc {
79  class LLVM_LIBRARY_VISIBILITY Common : public Tool {
80  public:
81    Common(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
82
83    virtual void ConstructJob(Compilation &C, const JobAction &JA,
84                              Job &Dest,
85                              const InputInfo &Output,
86                              const InputInfoList &Inputs,
87                              const ArgList &TCArgs,
88                              const char *LinkingOutput) const;
89
90    /// RenderExtraToolArgs - Render any arguments necessary to force
91    /// the particular tool mode.
92    virtual void RenderExtraToolArgs(const JobAction &JA,
93                                     ArgStringList &CmdArgs) const = 0;
94  };
95
96
97  class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
98  public:
99    Preprocess(const ToolChain &TC) : Common("gcc::Preprocess", TC) {}
100
101    virtual bool acceptsPipedInput() const { return true; }
102    virtual bool canPipeOutput() const { return true; }
103    virtual bool hasGoodDiagnostics() const { return true; }
104    virtual bool hasIntegratedCPP() const { return false; }
105
106    virtual void RenderExtraToolArgs(const JobAction &JA,
107                                     ArgStringList &CmdArgs) const;
108  };
109
110  class LLVM_LIBRARY_VISIBILITY Precompile : public Common  {
111  public:
112    Precompile(const ToolChain &TC) : Common("gcc::Precompile", TC) {}
113
114    virtual bool acceptsPipedInput() const { return true; }
115    virtual bool canPipeOutput() const { return false; }
116    virtual bool hasGoodDiagnostics() const { return true; }
117    virtual bool hasIntegratedCPP() const { return true; }
118
119    virtual void RenderExtraToolArgs(const JobAction &JA,
120                                     ArgStringList &CmdArgs) const;
121  };
122
123  class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
124  public:
125    Compile(const ToolChain &TC) : Common("gcc::Compile", TC) {}
126
127    virtual bool acceptsPipedInput() const { return true; }
128    virtual bool canPipeOutput() const { return true; }
129    virtual bool hasGoodDiagnostics() const { return true; }
130    virtual bool hasIntegratedCPP() const { return true; }
131
132    virtual void RenderExtraToolArgs(const JobAction &JA,
133                                     ArgStringList &CmdArgs) const;
134  };
135
136  class LLVM_LIBRARY_VISIBILITY Assemble : public Common  {
137  public:
138    Assemble(const ToolChain &TC) : Common("gcc::Assemble", TC) {}
139
140    virtual bool acceptsPipedInput() const { return true; }
141    virtual bool canPipeOutput() const { return false; }
142    virtual bool hasIntegratedCPP() const { return false; }
143
144    virtual void RenderExtraToolArgs(const JobAction &JA,
145                                     ArgStringList &CmdArgs) const;
146  };
147
148  class LLVM_LIBRARY_VISIBILITY Link : public Common  {
149  public:
150    Link(const ToolChain &TC) : Common("gcc::Link", TC) {}
151
152    virtual bool acceptsPipedInput() const { return false; }
153    virtual bool canPipeOutput() const { return false; }
154    virtual bool hasIntegratedCPP() const { return false; }
155
156    virtual void RenderExtraToolArgs(const JobAction &JA,
157                                     ArgStringList &CmdArgs) const;
158  };
159} // end namespace gcc
160
161namespace darwin {
162  class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
163  protected:
164    void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
165
166    const toolchains::Darwin &getDarwinToolChain() const {
167      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
168    }
169
170  public:
171    DarwinTool(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
172  };
173
174  class LLVM_LIBRARY_VISIBILITY CC1 : public DarwinTool  {
175  public:
176    static const char *getBaseInputName(const ArgList &Args,
177                                 const InputInfoList &Input);
178    static const char *getBaseInputStem(const ArgList &Args,
179                                 const InputInfoList &Input);
180    static const char *getDependencyFileName(const ArgList &Args,
181                                             const InputInfoList &Inputs);
182
183  protected:
184    const char *getCC1Name(types::ID Type) const;
185
186    void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
187    void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
188                           const InputInfoList &Inputs,
189                           const ArgStringList &OutputArgs) const;
190    void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
191                           const InputInfoList &Inputs,
192                           const ArgStringList &OutputArgs) const;
193    void AddCPPUniqueOptionsArgs(const ArgList &Args,
194                                 ArgStringList &CmdArgs,
195                                 const InputInfoList &Inputs) const;
196    void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
197
198  public:
199    CC1(const char *Name, const ToolChain &TC) : DarwinTool(Name, TC) {}
200
201    virtual bool acceptsPipedInput() const { return true; }
202    virtual bool canPipeOutput() const { return true; }
203    virtual bool hasGoodDiagnostics() const { return true; }
204    virtual bool hasIntegratedCPP() const { return true; }
205  };
206
207  class LLVM_LIBRARY_VISIBILITY Preprocess : public CC1  {
208  public:
209    Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess", TC) {}
210
211    virtual void ConstructJob(Compilation &C, const JobAction &JA,
212                              Job &Dest,
213                              const InputInfo &Output,
214                              const InputInfoList &Inputs,
215                              const ArgList &TCArgs,
216                              const char *LinkingOutput) const;
217  };
218
219  class LLVM_LIBRARY_VISIBILITY Compile : public CC1  {
220  public:
221    Compile(const ToolChain &TC) : CC1("darwin::Compile", TC) {}
222
223    virtual void ConstructJob(Compilation &C, const JobAction &JA,
224                              Job &Dest,
225                              const InputInfo &Output,
226                              const InputInfoList &Inputs,
227                              const ArgList &TCArgs,
228                              const char *LinkingOutput) const;
229  };
230
231  class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
232  public:
233    Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble", TC) {}
234
235    virtual bool acceptsPipedInput() const { return true; }
236    virtual bool canPipeOutput() const { return false; }
237    virtual bool hasIntegratedCPP() const { return false; }
238
239    virtual void ConstructJob(Compilation &C, const JobAction &JA,
240                              Job &Dest,
241                              const InputInfo &Output,
242                              const InputInfoList &Inputs,
243                              const ArgList &TCArgs,
244                              const char *LinkingOutput) const;
245  };
246
247  class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
248    void AddLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
249
250  public:
251    Link(const ToolChain &TC) : DarwinTool("darwin::Link", TC) {}
252
253    virtual bool acceptsPipedInput() const { return false; }
254    virtual bool canPipeOutput() const { return false; }
255    virtual bool hasIntegratedCPP() const { return false; }
256
257    virtual void ConstructJob(Compilation &C, const JobAction &JA,
258                              Job &Dest,
259                              const InputInfo &Output,
260                              const InputInfoList &Inputs,
261                              const ArgList &TCArgs,
262                              const char *LinkingOutput) const;
263  };
264
265  class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
266  public:
267    Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", TC) {}
268
269    virtual bool acceptsPipedInput() const { return false; }
270    virtual bool canPipeOutput() const { return false; }
271    virtual bool hasIntegratedCPP() const { return false; }
272
273    virtual void ConstructJob(Compilation &C, const JobAction &JA,
274                              Job &Dest,
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", TC) {}
287
288    virtual bool acceptsPipedInput() const { return true; }
289    virtual bool canPipeOutput() const { return true; }
290    virtual bool hasIntegratedCPP() const { return false; }
291
292    virtual void ConstructJob(Compilation &C, const JobAction &JA,
293                              Job &Dest,
294                              const InputInfo &Output,
295                              const InputInfoList &Inputs,
296                              const ArgList &TCArgs,
297                              const char *LinkingOutput) const;
298  };
299  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
300  public:
301    Link(const ToolChain &TC) : Tool("openbsd::Link", TC) {}
302
303    virtual bool acceptsPipedInput() const { return true; }
304    virtual bool canPipeOutput() const { return true; }
305    virtual bool hasIntegratedCPP() const { return false; }
306
307    virtual void ConstructJob(Compilation &C, const JobAction &JA,
308                              Job &Dest,
309                              const InputInfo &Output,
310                              const InputInfoList &Inputs,
311                              const ArgList &TCArgs,
312                              const char *LinkingOutput) const;
313  };
314} // end namespace openbsd
315
316  /// freebsd -- Directly call GNU Binutils assembler and linker
317namespace freebsd {
318  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
319  public:
320    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", TC) {}
321
322    virtual bool acceptsPipedInput() const { return true; }
323    virtual bool canPipeOutput() const { return true; }
324    virtual bool hasIntegratedCPP() const { return false; }
325
326    virtual void ConstructJob(Compilation &C, const JobAction &JA,
327                              Job &Dest,
328                              const InputInfo &Output,
329                              const InputInfoList &Inputs,
330                              const ArgList &TCArgs,
331                              const char *LinkingOutput) const;
332  };
333  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
334  public:
335    Link(const ToolChain &TC) : Tool("freebsd::Link", TC) {}
336
337    virtual bool acceptsPipedInput() const { return true; }
338    virtual bool canPipeOutput() const { return true; }
339    virtual bool hasIntegratedCPP() const { return false; }
340
341    virtual void ConstructJob(Compilation &C, const JobAction &JA,
342                              Job &Dest,
343                              const InputInfo &Output,
344                              const InputInfoList &Inputs,
345                              const ArgList &TCArgs,
346                              const char *LinkingOutput) const;
347  };
348} // end namespace freebsd
349
350  /// auroraux -- Directly call GNU Binutils assembler and linker
351namespace auroraux {
352  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
353  public:
354    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", TC) {}
355
356    virtual bool acceptsPipedInput() const { return true; }
357    virtual bool canPipeOutput() const { return true; }
358    virtual bool hasIntegratedCPP() const { return false; }
359
360    virtual void ConstructJob(Compilation &C, const JobAction &JA,
361                              Job &Dest,
362                              const InputInfo &Output,
363                              const InputInfoList &Inputs,
364                              const ArgList &TCArgs,
365                              const char *LinkingOutput) const;
366  };
367  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
368  public:
369    Link(const ToolChain &TC) : Tool("auroraux::Link", TC) {}
370
371    virtual bool acceptsPipedInput() const { return true; }
372    virtual bool canPipeOutput() const { return true; }
373    virtual bool hasIntegratedCPP() const { return false; }
374
375    virtual void ConstructJob(Compilation &C, const JobAction &JA,
376                              Job &Dest,
377                              const InputInfo &Output,
378                              const InputInfoList &Inputs,
379                              const ArgList &TCArgs,
380                              const char *LinkingOutput) const;
381  };
382} // end namespace auroraux
383
384  /// dragonfly -- Directly call GNU Binutils assembler and linker
385namespace dragonfly {
386  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
387  public:
388    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", TC) {}
389
390    virtual bool acceptsPipedInput() const { return true; }
391    virtual bool canPipeOutput() const { return true; }
392    virtual bool hasIntegratedCPP() const { return false; }
393
394    virtual void ConstructJob(Compilation &C, const JobAction &JA,
395                              Job &Dest,
396                              const InputInfo &Output,
397                              const InputInfoList &Inputs,
398                              const ArgList &TCArgs,
399                              const char *LinkingOutput) const;
400  };
401  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
402  public:
403    Link(const ToolChain &TC) : Tool("dragonfly::Link", TC) {}
404
405    virtual bool acceptsPipedInput() const { return true; }
406    virtual bool canPipeOutput() const { return true; }
407    virtual bool hasIntegratedCPP() const { return false; }
408
409    virtual void ConstructJob(Compilation &C, const JobAction &JA,
410                              Job &Dest,
411                              const InputInfo &Output,
412                              const InputInfoList &Inputs,
413                              const ArgList &TCArgs,
414                              const char *LinkingOutput) const;
415  };
416} // end namespace dragonfly
417
418} // end namespace toolchains
419} // end namespace driver
420} // end namespace clang
421
422#endif // CLANG_LIB_DRIVER_TOOLS_H_
423