Tools.h revision 6acda16e9c194dcbd0dea64341e182bdb65d0f41 
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 AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
37
38  public:
39    Clang(const ToolChain &TC) : Tool("clang", TC) {}
40
41    virtual bool acceptsPipedInput() const { return true; }
42    virtual bool canPipeOutput() const { return true; }
43    virtual bool hasIntegratedCPP() const { return true; }
44
45    virtual void ConstructJob(Compilation &C, const JobAction &JA,
46                              Job &Dest,
47                              const InputInfo &Output,
48                              const InputInfoList &Inputs,
49                              const ArgList &TCArgs,
50                              const char *LinkingOutput) const;
51  };
52
53  /// gcc - Generic GCC tool implementations.
54namespace gcc {
55  class VISIBILITY_HIDDEN Common : public Tool {
56  public:
57    Common(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
58
59    virtual void ConstructJob(Compilation &C, const JobAction &JA,
60                              Job &Dest,
61                              const InputInfo &Output,
62                              const InputInfoList &Inputs,
63                              const ArgList &TCArgs,
64                              const char *LinkingOutput) const;
65
66    /// RenderExtraToolArgs - Render any arguments necessary to force
67    /// the particular tool mode.
68    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const = 0;
69  };
70
71
72  class VISIBILITY_HIDDEN Preprocess : public Common {
73  public:
74    Preprocess(const ToolChain &TC) : Common("gcc::Preprocess", TC) {}
75
76    virtual bool acceptsPipedInput() const { return true; }
77    virtual bool canPipeOutput() const { return true; }
78    virtual bool hasIntegratedCPP() const { return false; }
79
80    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const;
81  };
82
83  class VISIBILITY_HIDDEN Precompile : public Common  {
84  public:
85    Precompile(const ToolChain &TC) : Common("gcc::Precompile", TC) {}
86
87    virtual bool acceptsPipedInput() const { return true; }
88    virtual bool canPipeOutput() const { return false; }
89    virtual bool hasIntegratedCPP() const { return true; }
90
91    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const;
92  };
93
94  class VISIBILITY_HIDDEN Compile : public Common  {
95  public:
96    Compile(const ToolChain &TC) : Common("gcc::Compile", TC) {}
97
98    virtual bool acceptsPipedInput() const { return true; }
99    virtual bool canPipeOutput() const { return true; }
100    virtual bool hasIntegratedCPP() const { return true; }
101
102    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const;
103  };
104
105  class VISIBILITY_HIDDEN Assemble : public Common  {
106  public:
107    Assemble(const ToolChain &TC) : Common("gcc::Assemble", TC) {}
108
109    virtual bool acceptsPipedInput() const { return true; }
110    virtual bool canPipeOutput() const { return false; }
111    virtual bool hasIntegratedCPP() const { return false; }
112
113    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const;
114  };
115
116  class VISIBILITY_HIDDEN Link : public Common  {
117  public:
118    Link(const ToolChain &TC) : Common("gcc::Link", TC) {}
119
120    virtual bool acceptsPipedInput() const { return false; }
121    virtual bool canPipeOutput() const { return false; }
122    virtual bool hasIntegratedCPP() const { return false; }
123
124    virtual void RenderExtraToolArgs(ArgStringList &CmdArgs) const;
125  };
126} // end namespace gcc
127
128namespace darwin {
129  class VISIBILITY_HIDDEN DarwinTool : public Tool {
130  protected:
131    void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
132    void AddDarwinSubArch(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