Tools.h revision 6e0f25483b1a801cd1155ea89c2b725feab16332 
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  /// \brief Clang compiler tool.
30  class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
31    void AddPreprocessingOptions(const Driver &D,
32                                 const ArgList &Args,
33                                 ArgStringList &CmdArgs,
34                                 const InputInfo &Output,
35                                 const InputInfoList &Inputs) const;
36
37    void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
38    void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
39    void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
40
41  public:
42    Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
43
44    virtual bool acceptsPipedInput() const { return true; }
45    virtual bool canPipeOutput() const { return true; }
46    virtual bool hasGoodDiagnostics() const { return true; }
47    virtual bool hasIntegratedAssembler() const { return true; }
48    virtual bool hasIntegratedCPP() const { return true; }
49
50    virtual void ConstructJob(Compilation &C, const JobAction &JA,
51                              Job &Dest,
52                              const InputInfo &Output,
53                              const InputInfoList &Inputs,
54                              const ArgList &TCArgs,
55                              const char *LinkingOutput) const;
56  };
57
58  /// \brief Clang integrated assembler tool.
59  class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
60  public:
61    ClangAs(const ToolChain &TC) : Tool("clang::as",
62                                        "clang integrated assembler", TC) {}
63
64    virtual bool acceptsPipedInput() const { return true; }
65    virtual bool canPipeOutput() const { return true; }
66    virtual bool hasGoodDiagnostics() const { return true; }
67    virtual bool hasIntegratedAssembler() const { return false; }
68    virtual bool hasIntegratedCPP() const { return false; }
69
70    virtual void ConstructJob(Compilation &C, const JobAction &JA,
71                              Job &Dest,
72                              const InputInfo &Output,
73                              const InputInfoList &Inputs,
74                              const ArgList &TCArgs,
75                              const char *LinkingOutput) const;
76  };
77
78  /// gcc - Generic GCC tool implementations.
79namespace gcc {
80  class LLVM_LIBRARY_VISIBILITY Common : public Tool {
81  public:
82    Common(const char *Name, const char *ShortName,
83           const ToolChain &TC) : Tool(Name, ShortName, TC) {}
84
85    virtual void ConstructJob(Compilation &C, const JobAction &JA,
86                              Job &Dest,
87                              const InputInfo &Output,
88                              const InputInfoList &Inputs,
89                              const ArgList &TCArgs,
90                              const char *LinkingOutput) const;
91
92    /// RenderExtraToolArgs - Render any arguments necessary to force
93    /// the particular tool mode.
94    virtual void RenderExtraToolArgs(const JobAction &JA,
95                                     ArgStringList &CmdArgs) const = 0;
96  };
97
98
99  class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
100  public:
101    Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
102                                             "gcc preprocessor", TC) {}
103
104    virtual bool acceptsPipedInput() const { return true; }
105    virtual bool canPipeOutput() const { return true; }
106    virtual bool hasGoodDiagnostics() const { return true; }
107    virtual bool hasIntegratedCPP() const { return false; }
108
109    virtual void RenderExtraToolArgs(const JobAction &JA,
110                                     ArgStringList &CmdArgs) const;
111  };
112
113  class LLVM_LIBRARY_VISIBILITY Precompile : public Common  {
114  public:
115    Precompile(const ToolChain &TC) : Common("gcc::Precompile",
116                                             "gcc precompile", TC) {}
117
118    virtual bool acceptsPipedInput() const { return true; }
119    virtual bool canPipeOutput() const { return false; }
120    virtual bool hasGoodDiagnostics() const { return true; }
121    virtual bool hasIntegratedCPP() const { return true; }
122
123    virtual void RenderExtraToolArgs(const JobAction &JA,
124                                     ArgStringList &CmdArgs) const;
125  };
126
127  class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
128  public:
129    Compile(const ToolChain &TC) : Common("gcc::Compile",
130                                          "gcc frontend", TC) {}
131
132    virtual bool acceptsPipedInput() const { return true; }
133    virtual bool canPipeOutput() const { return true; }
134    virtual bool hasGoodDiagnostics() const { return true; }
135    virtual bool hasIntegratedCPP() const { return true; }
136
137    virtual void RenderExtraToolArgs(const JobAction &JA,
138                                     ArgStringList &CmdArgs) const;
139  };
140
141  class LLVM_LIBRARY_VISIBILITY Assemble : public Common  {
142  public:
143    Assemble(const ToolChain &TC) : Common("gcc::Assemble",
144                                           "assembler (via gcc)", TC) {}
145
146    virtual bool acceptsPipedInput() const { return true; }
147    virtual bool canPipeOutput() const { return false; }
148    virtual bool hasIntegratedCPP() const { return false; }
149
150    virtual void RenderExtraToolArgs(const JobAction &JA,
151                                     ArgStringList &CmdArgs) const;
152  };
153
154  class LLVM_LIBRARY_VISIBILITY Link : public Common  {
155  public:
156    Link(const ToolChain &TC) : Common("gcc::Link",
157                                       "linker (via gcc)", TC) {}
158
159    virtual bool acceptsPipedInput() const { return false; }
160    virtual bool canPipeOutput() const { return false; }
161    virtual bool hasIntegratedCPP() const { return false; }
162
163    virtual void RenderExtraToolArgs(const JobAction &JA,
164                                     ArgStringList &CmdArgs) const;
165  };
166} // end namespace gcc
167
168namespace darwin {
169  class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
170  protected:
171    void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
172
173    const toolchains::Darwin &getDarwinToolChain() const {
174      return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
175    }
176
177  public:
178    DarwinTool(const char *Name, const char *ShortName,
179               const ToolChain &TC) : Tool(Name, ShortName, TC) {}
180  };
181
182  class LLVM_LIBRARY_VISIBILITY CC1 : public DarwinTool  {
183  public:
184    static const char *getBaseInputName(const ArgList &Args,
185                                 const InputInfoList &Input);
186    static const char *getBaseInputStem(const ArgList &Args,
187                                 const InputInfoList &Input);
188    static const char *getDependencyFileName(const ArgList &Args,
189                                             const InputInfoList &Inputs);
190
191  protected:
192    const char *getCC1Name(types::ID Type) const;
193
194    void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
195    void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
196                           const InputInfoList &Inputs,
197                           const ArgStringList &OutputArgs) const;
198    void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
199                           const InputInfoList &Inputs,
200                           const ArgStringList &OutputArgs) const;
201    void AddCPPUniqueOptionsArgs(const ArgList &Args,
202                                 ArgStringList &CmdArgs,
203                                 const InputInfoList &Inputs) const;
204    void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
205
206  public:
207    CC1(const char *Name, const char *ShortName,
208        const ToolChain &TC) : DarwinTool(Name, ShortName, TC) {}
209
210    virtual bool acceptsPipedInput() const { return true; }
211    virtual bool canPipeOutput() const { return true; }
212    virtual bool hasGoodDiagnostics() const { return true; }
213    virtual bool hasIntegratedCPP() const { return true; }
214  };
215
216  class LLVM_LIBRARY_VISIBILITY Preprocess : public CC1  {
217  public:
218    Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess",
219                                          "gcc preprocessor", TC) {}
220
221    virtual void ConstructJob(Compilation &C, const JobAction &JA,
222                              Job &Dest,
223                              const InputInfo &Output,
224                              const InputInfoList &Inputs,
225                              const ArgList &TCArgs,
226                              const char *LinkingOutput) const;
227  };
228
229  class LLVM_LIBRARY_VISIBILITY Compile : public CC1  {
230  public:
231    Compile(const ToolChain &TC) : CC1("darwin::Compile", "gcc frontend", TC) {}
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  class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
242  public:
243    Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
244                                               "assembler", TC) {}
245
246    virtual bool acceptsPipedInput() const { return true; }
247    virtual bool canPipeOutput() const { return false; }
248    virtual bool hasIntegratedCPP() const { return false; }
249
250    virtual void ConstructJob(Compilation &C, const JobAction &JA,
251                              Job &Dest,
252                              const InputInfo &Output,
253                              const InputInfoList &Inputs,
254                              const ArgList &TCArgs,
255                              const char *LinkingOutput) const;
256  };
257
258  class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
259    void AddLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
260
261  public:
262    Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
263
264    virtual bool acceptsPipedInput() const { return false; }
265    virtual bool canPipeOutput() const { return false; }
266    virtual bool hasIntegratedCPP() const { return false; }
267
268    virtual void ConstructJob(Compilation &C, const JobAction &JA,
269                              Job &Dest,
270                              const InputInfo &Output,
271                              const InputInfoList &Inputs,
272                              const ArgList &TCArgs,
273                              const char *LinkingOutput) const;
274  };
275
276  class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
277  public:
278    Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
279
280    virtual bool acceptsPipedInput() const { return false; }
281    virtual bool canPipeOutput() const { return false; }
282    virtual bool hasIntegratedCPP() const { return false; }
283
284    virtual void ConstructJob(Compilation &C, const JobAction &JA,
285                              Job &Dest,
286                              const InputInfo &Output,
287                              const InputInfoList &Inputs,
288                              const ArgList &TCArgs,
289                              const char *LinkingOutput) const;
290  };
291
292  class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
293  public:
294    Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
295                                               "dsymutil", TC) {}
296
297    virtual bool acceptsPipedInput() const { return false; }
298    virtual bool canPipeOutput() const { return false; }
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}
309
310  /// openbsd -- Directly call GNU Binutils assembler and linker
311namespace openbsd {
312  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
313  public:
314    Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
315                                         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  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
329  public:
330    Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
331
332    virtual bool acceptsPipedInput() const { return true; }
333    virtual bool canPipeOutput() const { return true; }
334    virtual bool hasIntegratedCPP() const { return false; }
335
336    virtual void ConstructJob(Compilation &C, const JobAction &JA,
337                              Job &Dest,
338                              const InputInfo &Output,
339                              const InputInfoList &Inputs,
340                              const ArgList &TCArgs,
341                              const char *LinkingOutput) const;
342  };
343} // end namespace openbsd
344
345  /// freebsd -- Directly call GNU Binutils assembler and linker
346namespace freebsd {
347  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
348  public:
349    Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
350                                         TC) {}
351
352    virtual bool acceptsPipedInput() const { return true; }
353    virtual bool canPipeOutput() const { return true; }
354    virtual bool hasIntegratedCPP() const { return false; }
355
356    virtual void ConstructJob(Compilation &C, const JobAction &JA,
357                              Job &Dest,
358                              const InputInfo &Output,
359                              const InputInfoList &Inputs,
360                              const ArgList &TCArgs,
361                              const char *LinkingOutput) const;
362  };
363  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
364  public:
365    Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
366
367    virtual bool acceptsPipedInput() const { return true; }
368    virtual bool canPipeOutput() const { return true; }
369    virtual bool hasIntegratedCPP() const { return false; }
370
371    virtual void ConstructJob(Compilation &C, const JobAction &JA,
372                              Job &Dest,
373                              const InputInfo &Output,
374                              const InputInfoList &Inputs,
375                              const ArgList &TCArgs,
376                              const char *LinkingOutput) const;
377  };
378} // end namespace freebsd
379
380  /// auroraux -- Directly call GNU Binutils assembler and linker
381namespace auroraux {
382  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
383  public:
384    Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
385                                         TC) {}
386
387    virtual bool acceptsPipedInput() const { return true; }
388    virtual bool canPipeOutput() const { return true; }
389    virtual bool hasIntegratedCPP() const { return false; }
390
391    virtual void ConstructJob(Compilation &C, const JobAction &JA,
392                              Job &Dest,
393                              const InputInfo &Output,
394                              const InputInfoList &Inputs,
395                              const ArgList &TCArgs,
396                              const char *LinkingOutput) const;
397  };
398  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
399  public:
400    Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
401
402    virtual bool acceptsPipedInput() const { return true; }
403    virtual bool canPipeOutput() const { return true; }
404    virtual bool hasIntegratedCPP() const { return false; }
405
406    virtual void ConstructJob(Compilation &C, const JobAction &JA,
407                              Job &Dest,
408                              const InputInfo &Output,
409                              const InputInfoList &Inputs,
410                              const ArgList &TCArgs,
411                              const char *LinkingOutput) const;
412  };
413} // end namespace auroraux
414
415  /// dragonfly -- Directly call GNU Binutils assembler and linker
416namespace dragonfly {
417  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
418  public:
419    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
420                                         TC) {}
421
422    virtual bool acceptsPipedInput() const { return true; }
423    virtual bool canPipeOutput() const { return true; }
424    virtual bool hasIntegratedCPP() const { return false; }
425
426    virtual void ConstructJob(Compilation &C, const JobAction &JA,
427                              Job &Dest,
428                              const InputInfo &Output,
429                              const InputInfoList &Inputs,
430                              const ArgList &TCArgs,
431                              const char *LinkingOutput) const;
432  };
433  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
434  public:
435    Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
436
437    virtual bool acceptsPipedInput() const { return true; }
438    virtual bool canPipeOutput() const { return true; }
439    virtual bool hasIntegratedCPP() const { return false; }
440
441    virtual void ConstructJob(Compilation &C, const JobAction &JA,
442                              Job &Dest,
443                              const InputInfo &Output,
444                              const InputInfoList &Inputs,
445                              const ArgList &TCArgs,
446                              const char *LinkingOutput) const;
447  };
448} // end namespace dragonfly
449
450} // end namespace toolchains
451} // end namespace driver
452} // end namespace clang
453
454#endif // CLANG_LIB_DRIVER_TOOLS_H_
455