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