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