1 //===--- Tools.h - Tool Implementations -------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef CLANG_LIB_DRIVER_TOOLS_H_
11 #define CLANG_LIB_DRIVER_TOOLS_H_
13 #include "clang/Driver/Tool.h"
14 #include "clang/Driver/Types.h"
15 #include "clang/Driver/Util.h"
17 #include "llvm/ADT/Triple.h"
18 #include "llvm/Support/Compiler.h"
24 namespace toolchains {
30 /// \brief Clang compiler tool.
31 class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
32 void AddPreprocessingOptions(Compilation &C,
35 ArgStringList &CmdArgs,
36 const InputInfo &Output,
37 const InputInfoList &Inputs) const;
39 void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
40 bool KernelOrKext) const;
41 void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
42 void AddSparcTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
43 void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
44 void AddHexagonTargetArgs (const ArgList &Args, ArgStringList &CmdArgs) const;
47 Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
49 virtual bool hasGoodDiagnostics() const { return true; }
50 virtual bool hasIntegratedAssembler() const { return true; }
51 virtual bool hasIntegratedCPP() const { return true; }
53 virtual void ConstructJob(Compilation &C, const JobAction &JA,
54 const InputInfo &Output,
55 const InputInfoList &Inputs,
56 const ArgList &TCArgs,
57 const char *LinkingOutput) const;
60 /// \brief Clang integrated assembler tool.
61 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
62 void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
64 ClangAs(const ToolChain &TC) : Tool("clang::as",
65 "clang integrated assembler", TC) {}
67 virtual bool hasGoodDiagnostics() const { return true; }
68 virtual bool hasIntegratedAssembler() const { return false; }
69 virtual bool hasIntegratedCPP() const { return false; }
71 virtual void ConstructJob(Compilation &C, const JobAction &JA,
72 const InputInfo &Output,
73 const InputInfoList &Inputs,
74 const ArgList &TCArgs,
75 const char *LinkingOutput) const;
78 /// gcc - Generic GCC tool implementations.
80 class LLVM_LIBRARY_VISIBILITY Common : public Tool {
82 Common(const char *Name, const char *ShortName,
83 const ToolChain &TC) : Tool(Name, ShortName, TC) {}
85 virtual void ConstructJob(Compilation &C, const JobAction &JA,
86 const InputInfo &Output,
87 const InputInfoList &Inputs,
88 const ArgList &TCArgs,
89 const char *LinkingOutput) const;
91 /// RenderExtraToolArgs - Render any arguments necessary to force
92 /// the particular tool mode.
93 virtual void RenderExtraToolArgs(const JobAction &JA,
94 ArgStringList &CmdArgs) const = 0;
98 class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
100 Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
101 "gcc preprocessor", TC) {}
103 virtual bool hasGoodDiagnostics() const { return true; }
104 virtual bool hasIntegratedCPP() const { return false; }
106 virtual void RenderExtraToolArgs(const JobAction &JA,
107 ArgStringList &CmdArgs) const;
110 class LLVM_LIBRARY_VISIBILITY Precompile : public Common {
112 Precompile(const ToolChain &TC) : Common("gcc::Precompile",
113 "gcc precompile", TC) {}
115 virtual bool hasGoodDiagnostics() const { return true; }
116 virtual bool hasIntegratedCPP() const { return true; }
118 virtual void RenderExtraToolArgs(const JobAction &JA,
119 ArgStringList &CmdArgs) const;
122 class LLVM_LIBRARY_VISIBILITY Compile : public Common {
124 Compile(const ToolChain &TC) : Common("gcc::Compile",
125 "gcc frontend", TC) {}
127 virtual bool hasGoodDiagnostics() const { return true; }
128 virtual bool hasIntegratedCPP() const { return true; }
130 virtual void RenderExtraToolArgs(const JobAction &JA,
131 ArgStringList &CmdArgs) const;
134 class LLVM_LIBRARY_VISIBILITY Assemble : public Common {
136 Assemble(const ToolChain &TC) : Common("gcc::Assemble",
137 "assembler (via gcc)", TC) {}
139 virtual bool hasIntegratedCPP() const { return false; }
141 virtual void RenderExtraToolArgs(const JobAction &JA,
142 ArgStringList &CmdArgs) const;
145 class LLVM_LIBRARY_VISIBILITY Link : public Common {
147 Link(const ToolChain &TC) : Common("gcc::Link",
148 "linker (via gcc)", TC) {}
150 virtual bool hasIntegratedCPP() const { return false; }
152 virtual void RenderExtraToolArgs(const JobAction &JA,
153 ArgStringList &CmdArgs) const;
155 } // end namespace gcc
158 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
159 // We simply use "clang -cc1" for those actions.
160 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
162 Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
165 virtual bool hasIntegratedCPP() const { return false; }
167 virtual void RenderExtraToolArgs(const JobAction &JA,
168 ArgStringList &CmdArgs) const;
169 virtual void ConstructJob(Compilation &C, const JobAction &JA,
170 const InputInfo &Output,
171 const InputInfoList &Inputs,
172 const ArgList &TCArgs,
173 const char *LinkingOutput) const;
176 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
178 Link(const ToolChain &TC) : Tool("hexagon::Link",
181 virtual bool hasIntegratedCPP() const { return false; }
183 virtual void RenderExtraToolArgs(const JobAction &JA,
184 ArgStringList &CmdArgs) const;
185 virtual void ConstructJob(Compilation &C, const JobAction &JA,
186 const InputInfo &Output,
187 const InputInfoList &Inputs,
188 const ArgList &TCArgs,
189 const char *LinkingOutput) const;
191 } // end namespace hexagon.
195 class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
196 virtual void anchor();
198 void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
200 const toolchains::Darwin &getDarwinToolChain() const {
201 return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
205 DarwinTool(const char *Name, const char *ShortName,
206 const ToolChain &TC) : Tool(Name, ShortName, TC) {}
209 class LLVM_LIBRARY_VISIBILITY CC1 : public DarwinTool {
210 virtual void anchor();
212 static const char *getBaseInputName(const ArgList &Args,
213 const InputInfoList &Input);
214 static const char *getBaseInputStem(const ArgList &Args,
215 const InputInfoList &Input);
216 static const char *getDependencyFileName(const ArgList &Args,
217 const InputInfoList &Inputs);
220 const char *getCC1Name(types::ID Type) const;
222 void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
223 void RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const;
224 void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
225 const InputInfoList &Inputs,
226 const ArgStringList &OutputArgs) const;
227 void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
228 const InputInfoList &Inputs,
229 const ArgStringList &OutputArgs) const;
230 void AddCPPUniqueOptionsArgs(const ArgList &Args,
231 ArgStringList &CmdArgs,
232 const InputInfoList &Inputs) const;
233 void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
236 CC1(const char *Name, const char *ShortName,
237 const ToolChain &TC) : DarwinTool(Name, ShortName, TC) {}
239 virtual bool hasGoodDiagnostics() const { return true; }
240 virtual bool hasIntegratedCPP() const { return true; }
243 class LLVM_LIBRARY_VISIBILITY Preprocess : public CC1 {
245 Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess",
246 "gcc preprocessor", TC) {}
248 virtual void ConstructJob(Compilation &C, const JobAction &JA,
249 const InputInfo &Output,
250 const InputInfoList &Inputs,
251 const ArgList &TCArgs,
252 const char *LinkingOutput) const;
255 class LLVM_LIBRARY_VISIBILITY Compile : public CC1 {
257 Compile(const ToolChain &TC) : CC1("darwin::Compile", "gcc frontend", TC) {}
259 virtual void ConstructJob(Compilation &C, const JobAction &JA,
260 const InputInfo &Output,
261 const InputInfoList &Inputs,
262 const ArgList &TCArgs,
263 const char *LinkingOutput) const;
266 class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool {
268 Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
271 virtual bool hasIntegratedCPP() const { return false; }
273 virtual void ConstructJob(Compilation &C, const JobAction &JA,
274 const InputInfo &Output,
275 const InputInfoList &Inputs,
276 const ArgList &TCArgs,
277 const char *LinkingOutput) const;
280 class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool {
281 void AddLinkArgs(Compilation &C, const ArgList &Args,
282 ArgStringList &CmdArgs) const;
285 Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
287 virtual bool hasIntegratedCPP() const { return false; }
289 virtual void ConstructJob(Compilation &C, const JobAction &JA,
290 const InputInfo &Output,
291 const InputInfoList &Inputs,
292 const ArgList &TCArgs,
293 const char *LinkingOutput) const;
296 class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool {
298 Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
300 virtual bool hasIntegratedCPP() const { return false; }
302 virtual void ConstructJob(Compilation &C, const JobAction &JA,
303 const InputInfo &Output,
304 const InputInfoList &Inputs,
305 const ArgList &TCArgs,
306 const char *LinkingOutput) const;
309 class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool {
311 Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
314 virtual bool hasIntegratedCPP() const { return false; }
316 virtual void ConstructJob(Compilation &C, const JobAction &JA,
317 const InputInfo &Output,
318 const InputInfoList &Inputs,
319 const ArgList &TCArgs,
320 const char *LinkingOutput) const;
323 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public DarwinTool {
325 VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
328 virtual bool hasIntegratedCPP() const { return false; }
330 virtual void ConstructJob(Compilation &C, const JobAction &JA,
331 const InputInfo &Output,
332 const InputInfoList &Inputs,
333 const ArgList &TCArgs,
334 const char *LinkingOutput) const;
339 /// openbsd -- Directly call GNU Binutils assembler and linker
341 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
343 Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
346 virtual bool hasIntegratedCPP() const { return false; }
348 virtual void ConstructJob(Compilation &C, const JobAction &JA,
349 const InputInfo &Output,
350 const InputInfoList &Inputs,
351 const ArgList &TCArgs,
352 const char *LinkingOutput) const;
354 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
356 Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
358 virtual bool hasIntegratedCPP() const { return false; }
360 virtual void ConstructJob(Compilation &C, const JobAction &JA,
361 const InputInfo &Output,
362 const InputInfoList &Inputs,
363 const ArgList &TCArgs,
364 const char *LinkingOutput) const;
366 } // end namespace openbsd
368 /// freebsd -- Directly call GNU Binutils assembler and linker
370 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
372 Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
375 virtual bool hasIntegratedCPP() const { return false; }
377 virtual void ConstructJob(Compilation &C, const JobAction &JA,
378 const InputInfo &Output,
379 const InputInfoList &Inputs,
380 const ArgList &TCArgs,
381 const char *LinkingOutput) const;
383 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
385 Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
387 virtual bool hasIntegratedCPP() const { return false; }
389 virtual void ConstructJob(Compilation &C, const JobAction &JA,
390 const InputInfo &Output,
391 const InputInfoList &Inputs,
392 const ArgList &TCArgs,
393 const char *LinkingOutput) const;
395 } // end namespace freebsd
397 /// netbsd -- Directly call GNU Binutils assembler and linker
399 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
402 Assemble(const ToolChain &TC)
403 : Tool("netbsd::Assemble", "assembler", TC) {}
405 virtual bool hasIntegratedCPP() const { return false; }
407 virtual void ConstructJob(Compilation &C, const JobAction &JA,
408 const InputInfo &Output,
409 const InputInfoList &Inputs,
410 const ArgList &TCArgs,
411 const char *LinkingOutput) const;
413 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
416 Link(const ToolChain &TC)
417 : Tool("netbsd::Link", "linker", TC) {}
419 virtual bool hasIntegratedCPP() const { return false; }
421 virtual void ConstructJob(Compilation &C, const JobAction &JA,
422 const InputInfo &Output,
423 const InputInfoList &Inputs,
424 const ArgList &TCArgs,
425 const char *LinkingOutput) const;
427 } // end namespace netbsd
429 /// linux -- Directly call GNU Binutils assembler and linker
430 namespace linuxtools {
431 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
433 Assemble(const ToolChain &TC) : Tool("linux::Assemble", "assembler",
436 virtual bool hasIntegratedCPP() const { return false; }
438 virtual void ConstructJob(Compilation &C, const JobAction &JA,
439 const InputInfo &Output,
440 const InputInfoList &Inputs,
441 const ArgList &TCArgs,
442 const char *LinkingOutput) const;
444 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
446 Link(const ToolChain &TC) : Tool("linux::Link", "linker", TC) {}
448 virtual bool hasIntegratedCPP() const { return false; }
450 virtual void ConstructJob(Compilation &C, const JobAction &JA,
451 const InputInfo &Output,
452 const InputInfoList &Inputs,
453 const ArgList &TCArgs,
454 const char *LinkingOutput) const;
457 /// minix -- Directly call GNU Binutils assembler and linker
459 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
461 Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
464 virtual bool hasIntegratedCPP() const { return false; }
466 virtual void ConstructJob(Compilation &C, const JobAction &JA,
467 const InputInfo &Output,
468 const InputInfoList &Inputs,
469 const ArgList &TCArgs,
470 const char *LinkingOutput) const;
472 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
474 Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
476 virtual bool hasIntegratedCPP() const { return false; }
478 virtual void ConstructJob(Compilation &C, const JobAction &JA,
479 const InputInfo &Output,
480 const InputInfoList &Inputs,
481 const ArgList &TCArgs,
482 const char *LinkingOutput) const;
484 } // end namespace minix
486 /// solaris -- Directly call Solaris assembler and linker
488 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
490 Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
493 virtual bool hasIntegratedCPP() const { return false; }
495 virtual void ConstructJob(Compilation &C, const JobAction &JA,
496 const InputInfo &Output,
497 const InputInfoList &Inputs,
498 const ArgList &TCArgs,
499 const char *LinkingOutput) const;
501 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
503 Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
505 virtual bool hasIntegratedCPP() const { return false; }
507 virtual void ConstructJob(Compilation &C, const JobAction &JA,
508 const InputInfo &Output,
509 const InputInfoList &Inputs,
510 const ArgList &TCArgs,
511 const char *LinkingOutput) const;
513 } // end namespace auroraux
515 /// auroraux -- Directly call GNU Binutils assembler and linker
517 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
519 Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
522 virtual bool hasIntegratedCPP() const { return false; }
524 virtual void ConstructJob(Compilation &C, const JobAction &JA,
525 const InputInfo &Output,
526 const InputInfoList &Inputs,
527 const ArgList &TCArgs,
528 const char *LinkingOutput) const;
530 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
532 Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
534 virtual bool hasIntegratedCPP() const { return false; }
536 virtual void ConstructJob(Compilation &C, const JobAction &JA,
537 const InputInfo &Output,
538 const InputInfoList &Inputs,
539 const ArgList &TCArgs,
540 const char *LinkingOutput) const;
542 } // end namespace auroraux
544 /// dragonfly -- Directly call GNU Binutils assembler and linker
545 namespace dragonfly {
546 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
548 Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
551 virtual bool hasIntegratedCPP() const { return false; }
553 virtual void ConstructJob(Compilation &C, const JobAction &JA,
554 const InputInfo &Output,
555 const InputInfoList &Inputs,
556 const ArgList &TCArgs,
557 const char *LinkingOutput) const;
559 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
561 Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
563 virtual bool hasIntegratedCPP() const { return false; }
565 virtual void ConstructJob(Compilation &C, const JobAction &JA,
566 const InputInfo &Output,
567 const InputInfoList &Inputs,
568 const ArgList &TCArgs,
569 const char *LinkingOutput) const;
571 } // end namespace dragonfly
573 /// Visual studio tools.
574 namespace visualstudio {
575 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
577 Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
579 virtual bool hasIntegratedCPP() const { return false; }
581 virtual void ConstructJob(Compilation &C, const JobAction &JA,
582 const InputInfo &Output,
583 const InputInfoList &Inputs,
584 const ArgList &TCArgs,
585 const char *LinkingOutput) const;
587 } // end namespace visualstudio
589 } // end namespace toolchains
590 } // end namespace driver
591 } // end namespace clang
593 #endif // CLANG_LIB_DRIVER_TOOLS_H_