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