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