Tools.h revision a6d38494d18e260958e73bfe5e2b3f1dc4160459 
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
134    const toolchains::Darwin &getDarwinToolChain() const {
135      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
136    }
137
138  public:
139    DarwinTool(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
140  };
141
142  class VISIBILITY_HIDDEN CC1 : public DarwinTool  {
143  public:
144    static const char *getBaseInputName(const ArgList &Args,
145                                 const InputInfoList &Input);
146    static const char *getBaseInputStem(const ArgList &Args,
147                                 const InputInfoList &Input);
148    static const char *getDependencyFileName(const ArgList &Args,
149                                             const InputInfoList &Inputs);
150
151  protected:
152    const char *getCC1Name(types::ID Type) const;
153
154    void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
155    void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
156                           const InputInfoList &Inputs,
157                           const ArgStringList &OutputArgs) const;
158    void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
159                           const InputInfoList &Inputs,
160                           const ArgStringList &OutputArgs) const;
161    void AddCPPUniqueOptionsArgs(const ArgList &Args,
162                                 ArgStringList &CmdArgs,
163                                 const InputInfoList &Inputs) const;
164    void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
165
166  public:
167    CC1(const char *Name, const ToolChain &TC) : DarwinTool(Name, TC) {}
168
169    virtual bool acceptsPipedInput() const { return true; }
170    virtual bool canPipeOutput() const { return true; }
171    virtual bool hasIntegratedCPP() const { return true; }
172  };
173
174  class VISIBILITY_HIDDEN Preprocess : public CC1  {
175  public:
176    Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess", TC) {}
177
178    virtual void ConstructJob(Compilation &C, const JobAction &JA,
179                              Job &Dest,
180                              const InputInfo &Output,
181                              const InputInfoList &Inputs,
182                              const ArgList &TCArgs,
183                              const char *LinkingOutput) const;
184  };
185
186  class VISIBILITY_HIDDEN Compile : public CC1  {
187  public:
188    Compile(const ToolChain &TC) : CC1("darwin::Compile", TC) {}
189
190    virtual void ConstructJob(Compilation &C, const JobAction &JA,
191                              Job &Dest,
192                              const InputInfo &Output,
193                              const InputInfoList &Inputs,
194                              const ArgList &TCArgs,
195                              const char *LinkingOutput) const;
196  };
197
198  class VISIBILITY_HIDDEN Assemble : public DarwinTool  {
199  public:
200    Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble", TC) {}
201
202    virtual bool acceptsPipedInput() const { return true; }
203    virtual bool canPipeOutput() const { return false; }
204    virtual bool hasIntegratedCPP() const { return false; }
205
206    virtual void ConstructJob(Compilation &C, const JobAction &JA,
207                              Job &Dest,
208                              const InputInfo &Output,
209                              const InputInfoList &Inputs,
210                              const ArgList &TCArgs,
211                              const char *LinkingOutput) const;
212  };
213
214  class VISIBILITY_HIDDEN Link : public DarwinTool  {
215    void AddLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
216
217  public:
218    Link(const ToolChain &TC) : DarwinTool("darwin::Link", TC) {}
219
220    virtual bool acceptsPipedInput() const { return false; }
221    virtual bool canPipeOutput() const { return false; }
222    virtual bool hasIntegratedCPP() const { return false; }
223
224    virtual void ConstructJob(Compilation &C, const JobAction &JA,
225                              Job &Dest,
226                              const InputInfo &Output,
227                              const InputInfoList &Inputs,
228                              const ArgList &TCArgs,
229                              const char *LinkingOutput) const;
230  };
231
232  class VISIBILITY_HIDDEN Lipo : public DarwinTool  {
233  public:
234    Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", TC) {}
235
236    virtual bool acceptsPipedInput() const { return false; }
237    virtual bool canPipeOutput() const { return false; }
238    virtual bool hasIntegratedCPP() const { return false; }
239
240    virtual void ConstructJob(Compilation &C, const JobAction &JA,
241                              Job &Dest,
242                              const InputInfo &Output,
243                              const InputInfoList &Inputs,
244                              const ArgList &TCArgs,
245                              const char *LinkingOutput) const;
246  };
247}
248
249  /// openbsd -- Directly call GNU Binutils assembler and linker
250namespace openbsd {
251  class VISIBILITY_HIDDEN Assemble : public Tool  {
252  public:
253    Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", TC) {}
254
255    virtual bool acceptsPipedInput() const { return true; }
256    virtual bool canPipeOutput() const { return true; }
257    virtual bool hasIntegratedCPP() const { return false; }
258
259    virtual void ConstructJob(Compilation &C, const JobAction &JA,
260                              Job &Dest,
261                              const InputInfo &Output,
262                              const InputInfoList &Inputs,
263                              const ArgList &TCArgs,
264                              const char *LinkingOutput) const;
265  };
266  class VISIBILITY_HIDDEN Link : public Tool  {
267  public:
268    Link(const ToolChain &TC) : Tool("openbsd::Link", TC) {}
269
270    virtual bool acceptsPipedInput() const { return true; }
271    virtual bool canPipeOutput() const { return true; }
272    virtual bool hasIntegratedCPP() const { return false; }
273
274    virtual void ConstructJob(Compilation &C, const JobAction &JA,
275                              Job &Dest,
276                              const InputInfo &Output,
277                              const InputInfoList &Inputs,
278                              const ArgList &TCArgs,
279                              const char *LinkingOutput) const;
280  };
281} // end namespace openbsd
282
283  /// freebsd -- Directly call GNU Binutils assembler and linker
284namespace freebsd {
285  class VISIBILITY_HIDDEN Assemble : public Tool  {
286  public:
287    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", TC) {}
288
289    virtual bool acceptsPipedInput() const { return true; }
290    virtual bool canPipeOutput() const { return true; }
291    virtual bool hasIntegratedCPP() const { return false; }
292
293    virtual void ConstructJob(Compilation &C, const JobAction &JA,
294                              Job &Dest,
295                              const InputInfo &Output,
296                              const InputInfoList &Inputs,
297                              const ArgList &TCArgs,
298                              const char *LinkingOutput) const;
299  };
300  class VISIBILITY_HIDDEN Link : public Tool  {
301  public:
302    Link(const ToolChain &TC) : Tool("freebsd::Link", TC) {}
303
304    virtual bool acceptsPipedInput() const { return true; }
305    virtual bool canPipeOutput() const { return true; }
306    virtual bool hasIntegratedCPP() const { return false; }
307
308    virtual void ConstructJob(Compilation &C, const JobAction &JA,
309                              Job &Dest,
310                              const InputInfo &Output,
311                              const InputInfoList &Inputs,
312                              const ArgList &TCArgs,
313                              const char *LinkingOutput) const;
314  };
315} // end namespace freebsd
316
317  /// auroraux -- Directly call GNU Binutils assembler and linker
318namespace auroraux {
319  class VISIBILITY_HIDDEN Assemble : public Tool  {
320  public:
321    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", TC) {}
322
323    virtual bool acceptsPipedInput() const { return true; }
324    virtual bool canPipeOutput() const { return true; }
325    virtual bool hasIntegratedCPP() const { return false; }
326
327    virtual void ConstructJob(Compilation &C, const JobAction &JA,
328                              Job &Dest,
329                              const InputInfo &Output,
330                              const InputInfoList &Inputs,
331                              const ArgList &TCArgs,
332                              const char *LinkingOutput) const;
333  };
334  class VISIBILITY_HIDDEN Link : public Tool  {
335  public:
336    Link(const ToolChain &TC) : Tool("auroraux::Link", TC) {}
337
338    virtual bool acceptsPipedInput() const { return true; }
339    virtual bool canPipeOutput() const { return true; }
340    virtual bool hasIntegratedCPP() const { return false; }
341
342    virtual void ConstructJob(Compilation &C, const JobAction &JA,
343                              Job &Dest,
344                              const InputInfo &Output,
345                              const InputInfoList &Inputs,
346                              const ArgList &TCArgs,
347                              const char *LinkingOutput) const;
348  };
349} // end namespace auroraux
350
351  /// dragonfly -- Directly call GNU Binutils assembler and linker
352namespace dragonfly {
353  class VISIBILITY_HIDDEN Assemble : public Tool  {
354  public:
355    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", TC) {}
356
357    virtual bool acceptsPipedInput() const { return true; }
358    virtual bool canPipeOutput() const { return true; }
359    virtual bool hasIntegratedCPP() const { return false; }
360
361    virtual void ConstructJob(Compilation &C, const JobAction &JA,
362                              Job &Dest,
363                              const InputInfo &Output,
364                              const InputInfoList &Inputs,
365                              const ArgList &TCArgs,
366                              const char *LinkingOutput) const;
367  };
368  class VISIBILITY_HIDDEN Link : public Tool  {
369  public:
370    Link(const ToolChain &TC) : Tool("dragonfly::Link", TC) {}
371
372    virtual bool acceptsPipedInput() const { return true; }
373    virtual bool canPipeOutput() const { return true; }
374    virtual bool hasIntegratedCPP() const { return false; }
375
376    virtual void ConstructJob(Compilation &C, const JobAction &JA,
377                              Job &Dest,
378                              const InputInfo &Output,
379                              const InputInfoList &Inputs,
380                              const ArgList &TCArgs,
381                              const char *LinkingOutput) const;
382  };
383} // end namespace dragonfly
384
385} // end namespace toolchains
386} // end namespace driver
387} // end namespace clang
388
389#endif // CLANG_LIB_DRIVER_TOOLS_H_
390