Tools.h revision f395528158379e7ea9f6ff4bbb791abadca15aab 
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 CC1 : public Tool  {
128  public:
129    static const char *getBaseInputName(const ArgList &Args,
130                                 const InputInfoList &Input);
131    static const char *getBaseInputStem(const ArgList &Args,
132                                 const InputInfoList &Input);
133    static const char *getDependencyFileName(const ArgList &Args,
134                                             const InputInfoList &Inputs);
135
136  protected:
137    const char *getCC1Name(types::ID Type) const;
138
139    void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
140    void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
141                           const InputInfoList &Inputs,
142                           const ArgStringList &OutputArgs) const;
143    void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
144                           const InputInfoList &Inputs,
145                           const ArgStringList &OutputArgs) const;
146    void AddCPPUniqueOptionsArgs(const ArgList &Args,
147                                 ArgStringList &CmdArgs,
148                                 const InputInfoList &Inputs) const;
149    void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
150
151  public:
152    CC1(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
153
154    virtual bool acceptsPipedInput() const { return true; }
155    virtual bool canPipeOutput() const { return true; }
156    virtual bool hasIntegratedCPP() const { return true; }
157  };
158
159  class VISIBILITY_HIDDEN Preprocess : public CC1  {
160  public:
161    Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess", TC) {}
162
163    virtual void ConstructJob(Compilation &C, const JobAction &JA,
164                              Job &Dest,
165                              const InputInfo &Output,
166                              const InputInfoList &Inputs,
167                              const ArgList &TCArgs,
168                              const char *LinkingOutput) const;
169  };
170
171  class VISIBILITY_HIDDEN Compile : public CC1  {
172  public:
173    Compile(const ToolChain &TC) : CC1("darwin::Compile", TC) {}
174
175    virtual void ConstructJob(Compilation &C, const JobAction &JA,
176                              Job &Dest,
177                              const InputInfo &Output,
178                              const InputInfoList &Inputs,
179                              const ArgList &TCArgs,
180                              const char *LinkingOutput) const;
181  };
182
183  class VISIBILITY_HIDDEN Assemble : public Tool  {
184  public:
185    Assemble(const ToolChain &TC) : Tool("darwin::Assemble", TC) {}
186
187    virtual bool acceptsPipedInput() const { return true; }
188    virtual bool canPipeOutput() const { return false; }
189    virtual bool hasIntegratedCPP() const { return false; }
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 Link : public Tool  {
200    void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
201    void AddDarwinSubArch(const ArgList &Args, ArgStringList &CmdArgs) const;
202    void AddLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
203
204    const toolchains::Darwin &getDarwinToolChain() const {
205      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
206    }
207
208  public:
209    Link(const ToolChain &TC)
210      : Tool("darwin::Link", TC) {
211    }
212
213    virtual bool acceptsPipedInput() const { return false; }
214    virtual bool canPipeOutput() const { return false; }
215    virtual bool hasIntegratedCPP() const { return false; }
216
217    virtual void ConstructJob(Compilation &C, const JobAction &JA,
218                              Job &Dest,
219                              const InputInfo &Output,
220                              const InputInfoList &Inputs,
221                              const ArgList &TCArgs,
222                              const char *LinkingOutput) const;
223  };
224
225  class VISIBILITY_HIDDEN Lipo : public Tool  {
226  public:
227    Lipo(const ToolChain &TC) : Tool("darwin::Lipo", TC) {}
228
229    virtual bool acceptsPipedInput() const { return false; }
230    virtual bool canPipeOutput() const { return false; }
231    virtual bool hasIntegratedCPP() const { return false; }
232
233    virtual void ConstructJob(Compilation &C, const JobAction &JA,
234                              Job &Dest,
235                              const InputInfo &Output,
236                              const InputInfoList &Inputs,
237                              const ArgList &TCArgs,
238                              const char *LinkingOutput) const;
239  };
240}
241
242  /// openbsd -- Directly call GNU Binutils assembler and linker
243namespace openbsd {
244  class VISIBILITY_HIDDEN Assemble : public Tool  {
245  public:
246    Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", TC) {}
247
248    virtual bool acceptsPipedInput() const { return true; }
249    virtual bool canPipeOutput() const { return true; }
250    virtual bool hasIntegratedCPP() const { return false; }
251
252    virtual void ConstructJob(Compilation &C, const JobAction &JA,
253                              Job &Dest,
254                              const InputInfo &Output,
255                              const InputInfoList &Inputs,
256                              const ArgList &TCArgs,
257                              const char *LinkingOutput) const;
258  };
259  class VISIBILITY_HIDDEN Link : public Tool  {
260  public:
261    Link(const ToolChain &TC) : Tool("openbsd::Link", 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} // end namespace openbsd
275
276  /// freebsd -- Directly call GNU Binutils assembler and linker
277namespace freebsd {
278  class VISIBILITY_HIDDEN Assemble : public Tool  {
279  public:
280    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", TC) {}
281
282    virtual bool acceptsPipedInput() const { return true; }
283    virtual bool canPipeOutput() const { return true; }
284    virtual bool hasIntegratedCPP() const { return false; }
285
286    virtual void ConstructJob(Compilation &C, const JobAction &JA,
287                              Job &Dest,
288                              const InputInfo &Output,
289                              const InputInfoList &Inputs,
290                              const ArgList &TCArgs,
291                              const char *LinkingOutput) const;
292  };
293  class VISIBILITY_HIDDEN Link : public Tool  {
294  public:
295    Link(const ToolChain &TC) : Tool("freebsd::Link", 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} // end namespace freebsd
309
310  /// auroraux -- Directly call GNU Binutils assembler and linker
311namespace auroraux {
312  class VISIBILITY_HIDDEN Assemble : public Tool  {
313  public:
314    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", TC) {}
315
316    virtual bool acceptsPipedInput() const { return true; }
317    virtual bool canPipeOutput() const { return true; }
318    virtual bool hasIntegratedCPP() const { return false; }
319
320    virtual void ConstructJob(Compilation &C, const JobAction &JA,
321                              Job &Dest,
322                              const InputInfo &Output,
323                              const InputInfoList &Inputs,
324                              const ArgList &TCArgs,
325                              const char *LinkingOutput) const;
326  };
327  class VISIBILITY_HIDDEN Link : public Tool  {
328  public:
329    Link(const ToolChain &TC) : Tool("auroraux::Link", 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} // end namespace auroraux
343
344  /// dragonfly -- Directly call GNU Binutils assembler and linker
345namespace dragonfly {
346  class VISIBILITY_HIDDEN Assemble : public Tool  {
347  public:
348    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", TC) {}
349
350    virtual bool acceptsPipedInput() const { return true; }
351    virtual bool canPipeOutput() const { return true; }
352    virtual bool hasIntegratedCPP() const { return false; }
353
354    virtual void ConstructJob(Compilation &C, const JobAction &JA,
355                              Job &Dest,
356                              const InputInfo &Output,
357                              const InputInfoList &Inputs,
358                              const ArgList &TCArgs,
359                              const char *LinkingOutput) const;
360  };
361  class VISIBILITY_HIDDEN Link : public Tool  {
362  public:
363    Link(const ToolChain &TC) : Tool("dragonfly::Link", 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} // end namespace dragonfly
377
378} // end namespace toolchains
379} // end namespace driver
380} // end namespace clang
381
382#endif // CLANG_LIB_DRIVER_TOOLS_H_
383