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