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 LLVM_CLANG_LIB_DRIVER_TOOLS_H
11 #define LLVM_CLANG_LIB_DRIVER_TOOLS_H
13 #include "clang/Basic/VersionTuple.h"
14 #include "clang/Driver/Tool.h"
15 #include "clang/Driver/Types.h"
16 #include "clang/Driver/Util.h"
17 #include "clang/Frontend/CodeGenOptions.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Option/Option.h"
20 #include "llvm/Support/Compiler.h"
29 namespace toolchains {
35 namespace visualstudio {
39 using llvm::opt::ArgStringList;
41 SmallString<128> getCompilerRT(const ToolChain &TC,
42 const llvm::opt::ArgList &Args,
43 StringRef Component, bool Shared = false);
45 /// \brief Clang compiler tool.
46 class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
48 static const char *getBaseInputName(const llvm::opt::ArgList &Args,
49 const InputInfo &Input);
50 static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
51 const InputInfoList &Inputs);
52 static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
53 const InputInfoList &Inputs);
56 void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
57 const Driver &D, const llvm::opt::ArgList &Args,
58 llvm::opt::ArgStringList &CmdArgs,
59 const InputInfo &Output,
60 const InputInfoList &Inputs,
61 const ToolChain *AuxToolChain) const;
63 void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
64 llvm::opt::ArgStringList &CmdArgs) const;
65 void AddARMTargetArgs(const llvm::Triple &Triple,
66 const llvm::opt::ArgList &Args,
67 llvm::opt::ArgStringList &CmdArgs,
68 bool KernelOrKext) const;
69 void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
70 llvm::opt::ArgStringList &CmdArgs) const;
71 void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
72 llvm::opt::ArgStringList &CmdArgs) const;
73 void AddPPCTargetArgs(const llvm::opt::ArgList &Args,
74 llvm::opt::ArgStringList &CmdArgs) const;
75 void AddR600TargetArgs(const llvm::opt::ArgList &Args,
76 llvm::opt::ArgStringList &CmdArgs) const;
77 void AddSparcTargetArgs(const llvm::opt::ArgList &Args,
78 llvm::opt::ArgStringList &CmdArgs) const;
79 void AddSystemZTargetArgs(const llvm::opt::ArgList &Args,
80 llvm::opt::ArgStringList &CmdArgs) const;
81 void AddX86TargetArgs(const llvm::opt::ArgList &Args,
82 llvm::opt::ArgStringList &CmdArgs) const;
83 void AddHexagonTargetArgs(const llvm::opt::ArgList &Args,
84 llvm::opt::ArgStringList &CmdArgs) const;
85 void AddWebAssemblyTargetArgs(const llvm::opt::ArgList &Args,
86 llvm::opt::ArgStringList &CmdArgs) const;
88 enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
90 ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
91 llvm::opt::ArgStringList &cmdArgs,
92 RewriteKind rewrite) const;
94 void AddClangCLArgs(const llvm::opt::ArgList &Args,
95 llvm::opt::ArgStringList &CmdArgs,
96 enum CodeGenOptions::DebugInfoKind *DebugInfoKind,
97 bool *EmitCodeView) const;
99 visualstudio::Compiler *getCLFallback() const;
101 mutable std::unique_ptr<visualstudio::Compiler> CLFallback;
104 // CAUTION! The first constructor argument ("clang") is not arbitrary,
105 // as it is for other tools. Some operations on a Tool actually test
106 // whether that tool is Clang based on the Tool's Name as a string.
107 Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {}
109 bool hasGoodDiagnostics() const override { return true; }
110 bool hasIntegratedAssembler() const override { return true; }
111 bool hasIntegratedCPP() const override { return true; }
112 bool canEmitIR() const override { return true; }
114 void ConstructJob(Compilation &C, const JobAction &JA,
115 const InputInfo &Output, const InputInfoList &Inputs,
116 const llvm::opt::ArgList &TCArgs,
117 const char *LinkingOutput) const override;
120 /// \brief Clang integrated assembler tool.
121 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
123 ClangAs(const ToolChain &TC)
124 : Tool("clang::as", "clang integrated assembler", TC, RF_Full) {}
125 void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
126 llvm::opt::ArgStringList &CmdArgs) const;
127 bool hasGoodDiagnostics() const override { return true; }
128 bool hasIntegratedAssembler() const override { return false; }
129 bool hasIntegratedCPP() const override { return false; }
131 void ConstructJob(Compilation &C, const JobAction &JA,
132 const InputInfo &Output, const InputInfoList &Inputs,
133 const llvm::opt::ArgList &TCArgs,
134 const char *LinkingOutput) const override;
137 /// \brief Base class for all GNU tools that provide the same behavior when
138 /// it comes to response files support
139 class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool {
140 virtual void anchor();
143 GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
144 : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {}
147 /// gcc - Generic GCC tool implementations.
149 class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
151 Common(const char *Name, const char *ShortName, const ToolChain &TC)
152 : GnuTool(Name, ShortName, TC) {}
154 // A gcc tool has an "integrated" assembler that it will call to produce an
155 // object. Let it use that assembler so that we don't have to deal with
156 // assembly syntax incompatibilities.
157 bool hasIntegratedAssembler() const override { return true; }
158 void ConstructJob(Compilation &C, const JobAction &JA,
159 const InputInfo &Output, const InputInfoList &Inputs,
160 const llvm::opt::ArgList &TCArgs,
161 const char *LinkingOutput) const override;
163 /// RenderExtraToolArgs - Render any arguments necessary to force
164 /// the particular tool mode.
165 virtual void RenderExtraToolArgs(const JobAction &JA,
166 llvm::opt::ArgStringList &CmdArgs) const = 0;
169 class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
171 Preprocessor(const ToolChain &TC)
172 : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
174 bool hasGoodDiagnostics() const override { return true; }
175 bool hasIntegratedCPP() const override { return false; }
177 void RenderExtraToolArgs(const JobAction &JA,
178 llvm::opt::ArgStringList &CmdArgs) const override;
181 class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
183 Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
185 bool hasGoodDiagnostics() const override { return true; }
186 bool hasIntegratedCPP() const override { return true; }
188 void RenderExtraToolArgs(const JobAction &JA,
189 llvm::opt::ArgStringList &CmdArgs) const override;
192 class LLVM_LIBRARY_VISIBILITY Linker : public Common {
194 Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
196 bool hasIntegratedCPP() const override { return false; }
197 bool isLinkJob() const override { return true; }
199 void RenderExtraToolArgs(const JobAction &JA,
200 llvm::opt::ArgStringList &CmdArgs) const override;
202 } // end namespace gcc
205 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile
207 // We simply use "clang -cc1" for those actions.
208 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
210 Assembler(const ToolChain &TC)
211 : GnuTool("hexagon::Assembler", "hexagon-as", TC) {}
213 bool hasIntegratedCPP() const override { return false; }
215 void RenderExtraToolArgs(const JobAction &JA,
216 llvm::opt::ArgStringList &CmdArgs) const;
217 void ConstructJob(Compilation &C, const JobAction &JA,
218 const InputInfo &Output, const InputInfoList &Inputs,
219 const llvm::opt::ArgList &TCArgs,
220 const char *LinkingOutput) const override;
223 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
225 Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {}
227 bool hasIntegratedCPP() const override { return false; }
228 bool isLinkJob() const override { return true; }
230 virtual void RenderExtraToolArgs(const JobAction &JA,
231 llvm::opt::ArgStringList &CmdArgs) const;
232 void ConstructJob(Compilation &C, const JobAction &JA,
233 const InputInfo &Output, const InputInfoList &Inputs,
234 const llvm::opt::ArgList &TCArgs,
235 const char *LinkingOutput) const override;
237 } // end namespace hexagon.
241 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
243 Linker(const ToolChain &TC) : GnuTool("amdgpu::Linker", "ld.lld", TC) {}
244 bool isLinkJob() const override { return true; }
245 bool hasIntegratedCPP() const override { return false; }
246 void ConstructJob(Compilation &C, const JobAction &JA,
247 const InputInfo &Output, const InputInfoList &Inputs,
248 const llvm::opt::ArgList &TCArgs,
249 const char *LinkingOutput) const override;
252 } // end namespace amdgpu
256 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
258 explicit Linker(const ToolChain &TC);
259 bool isLinkJob() const override;
260 bool hasIntegratedCPP() const override;
261 void ConstructJob(Compilation &C, const JobAction &JA,
262 const InputInfo &Output, const InputInfoList &Inputs,
263 const llvm::opt::ArgList &TCArgs,
264 const char *LinkingOutput) const override;
267 } // end namespace wasm
270 std::string getARMTargetCPU(StringRef CPU, StringRef Arch,
271 const llvm::Triple &Triple);
272 const std::string getARMArch(StringRef Arch,
273 const llvm::Triple &Triple);
274 StringRef getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple);
275 StringRef getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
276 const llvm::Triple &Triple);
278 void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs,
279 const llvm::Triple &Triple);
280 } // end namespace arm
283 typedef enum { NanLegacy = 1, Nan2008 = 2 } NanEncoding;
285 enum class FloatABI {
291 NanEncoding getSupportedNanEncoding(StringRef &CPU);
292 void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
293 const llvm::Triple &Triple, StringRef &CPUName,
295 std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args,
296 const llvm::Triple &Triple);
297 bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
298 bool isUCLibc(const llvm::opt::ArgList &Args);
299 bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
300 bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
301 StringRef ABIName, mips::FloatABI FloatABI);
302 bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
303 StringRef CPUName, StringRef ABIName,
304 mips::FloatABI FloatABI);
305 } // end namespace mips
308 bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
309 } // end namespace ppc
311 /// cloudabi -- Directly call GNU Binutils linker
313 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
315 Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {}
317 bool hasIntegratedCPP() const override { return false; }
318 bool isLinkJob() const override { return true; }
320 void ConstructJob(Compilation &C, const JobAction &JA,
321 const InputInfo &Output, const InputInfoList &Inputs,
322 const llvm::opt::ArgList &TCArgs,
323 const char *LinkingOutput) const override;
325 } // end namespace cloudabi
328 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
329 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
331 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
332 virtual void anchor();
335 void AddMachOArch(const llvm::opt::ArgList &Args,
336 llvm::opt::ArgStringList &CmdArgs) const;
338 const toolchains::MachO &getMachOToolChain() const {
339 return reinterpret_cast<const toolchains::MachO &>(getToolChain());
344 const char *Name, const char *ShortName, const ToolChain &TC,
345 ResponseFileSupport ResponseSupport = RF_None,
346 llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
347 const char *ResponseFlag = "@")
348 : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
352 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
354 Assembler(const ToolChain &TC)
355 : MachOTool("darwin::Assembler", "assembler", TC) {}
357 bool hasIntegratedCPP() const override { return false; }
359 void ConstructJob(Compilation &C, const JobAction &JA,
360 const InputInfo &Output, const InputInfoList &Inputs,
361 const llvm::opt::ArgList &TCArgs,
362 const char *LinkingOutput) const override;
365 class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
366 bool NeedsTempPath(const InputInfoList &Inputs) const;
367 void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
368 llvm::opt::ArgStringList &CmdArgs,
369 const InputInfoList &Inputs) const;
372 Linker(const ToolChain &TC)
373 : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
374 llvm::sys::WEM_UTF8, "-filelist") {}
376 bool hasIntegratedCPP() const override { return false; }
377 bool isLinkJob() const override { return true; }
379 void ConstructJob(Compilation &C, const JobAction &JA,
380 const InputInfo &Output, const InputInfoList &Inputs,
381 const llvm::opt::ArgList &TCArgs,
382 const char *LinkingOutput) const override;
385 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
387 Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
389 bool hasIntegratedCPP() const override { return false; }
391 void ConstructJob(Compilation &C, const JobAction &JA,
392 const InputInfo &Output, const InputInfoList &Inputs,
393 const llvm::opt::ArgList &TCArgs,
394 const char *LinkingOutput) const override;
397 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
399 Dsymutil(const ToolChain &TC)
400 : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
402 bool hasIntegratedCPP() const override { return false; }
403 bool isDsymutilJob() const override { return true; }
405 void ConstructJob(Compilation &C, const JobAction &JA,
406 const InputInfo &Output, const InputInfoList &Inputs,
407 const llvm::opt::ArgList &TCArgs,
408 const char *LinkingOutput) const override;
411 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
413 VerifyDebug(const ToolChain &TC)
414 : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
416 bool hasIntegratedCPP() const override { return false; }
418 void ConstructJob(Compilation &C, const JobAction &JA,
419 const InputInfo &Output, const InputInfoList &Inputs,
420 const llvm::opt::ArgList &TCArgs,
421 const char *LinkingOutput) const override;
423 } // end namespace darwin
425 /// openbsd -- Directly call GNU Binutils assembler and linker
427 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
429 Assembler(const ToolChain &TC)
430 : GnuTool("openbsd::Assembler", "assembler", TC) {}
432 bool hasIntegratedCPP() const override { return false; }
434 void ConstructJob(Compilation &C, const JobAction &JA,
435 const InputInfo &Output, const InputInfoList &Inputs,
436 const llvm::opt::ArgList &TCArgs,
437 const char *LinkingOutput) const override;
440 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
442 Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {}
444 bool hasIntegratedCPP() const override { return false; }
445 bool isLinkJob() const override { return true; }
447 void ConstructJob(Compilation &C, const JobAction &JA,
448 const InputInfo &Output, const InputInfoList &Inputs,
449 const llvm::opt::ArgList &TCArgs,
450 const char *LinkingOutput) const override;
452 } // end namespace openbsd
454 /// bitrig -- Directly call GNU Binutils assembler and linker
456 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
458 Assembler(const ToolChain &TC)
459 : GnuTool("bitrig::Assembler", "assembler", TC) {}
461 bool hasIntegratedCPP() const override { return false; }
463 void ConstructJob(Compilation &C, const JobAction &JA,
464 const InputInfo &Output, const InputInfoList &Inputs,
465 const llvm::opt::ArgList &TCArgs,
466 const char *LinkingOutput) const override;
469 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
471 Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {}
473 bool hasIntegratedCPP() const override { return false; }
474 bool isLinkJob() const override { return true; }
476 void ConstructJob(Compilation &C, const JobAction &JA,
477 const InputInfo &Output, const InputInfoList &Inputs,
478 const llvm::opt::ArgList &TCArgs,
479 const char *LinkingOutput) const override;
481 } // end namespace bitrig
483 /// freebsd -- Directly call GNU Binutils assembler and linker
485 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
487 Assembler(const ToolChain &TC)
488 : GnuTool("freebsd::Assembler", "assembler", TC) {}
490 bool hasIntegratedCPP() const override { return false; }
492 void ConstructJob(Compilation &C, const JobAction &JA,
493 const InputInfo &Output, const InputInfoList &Inputs,
494 const llvm::opt::ArgList &TCArgs,
495 const char *LinkingOutput) const override;
498 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
500 Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {}
502 bool hasIntegratedCPP() const override { return false; }
503 bool isLinkJob() const override { return true; }
505 void ConstructJob(Compilation &C, const JobAction &JA,
506 const InputInfo &Output, const InputInfoList &Inputs,
507 const llvm::opt::ArgList &TCArgs,
508 const char *LinkingOutput) const override;
510 } // end namespace freebsd
512 /// netbsd -- Directly call GNU Binutils assembler and linker
514 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
516 Assembler(const ToolChain &TC)
517 : GnuTool("netbsd::Assembler", "assembler", TC) {}
519 bool hasIntegratedCPP() const override { return false; }
521 void ConstructJob(Compilation &C, const JobAction &JA,
522 const InputInfo &Output, const InputInfoList &Inputs,
523 const llvm::opt::ArgList &TCArgs,
524 const char *LinkingOutput) const override;
527 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
529 Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {}
531 bool hasIntegratedCPP() const override { return false; }
532 bool isLinkJob() const override { return true; }
534 void ConstructJob(Compilation &C, const JobAction &JA,
535 const InputInfo &Output, const InputInfoList &Inputs,
536 const llvm::opt::ArgList &TCArgs,
537 const char *LinkingOutput) const override;
539 } // end namespace netbsd
541 /// Directly call GNU Binutils' assembler and linker.
543 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
545 Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {}
547 bool hasIntegratedCPP() const override { return false; }
549 void ConstructJob(Compilation &C, const JobAction &JA,
550 const InputInfo &Output, const InputInfoList &Inputs,
551 const llvm::opt::ArgList &TCArgs,
552 const char *LinkingOutput) const override;
555 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
557 Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {}
559 bool hasIntegratedCPP() const override { return false; }
560 bool isLinkJob() const override { return true; }
562 void ConstructJob(Compilation &C, const JobAction &JA,
563 const InputInfo &Output, const InputInfoList &Inputs,
564 const llvm::opt::ArgList &TCArgs,
565 const char *LinkingOutput) const override;
567 } // end namespace gnutools
569 namespace nacltools {
570 class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
572 AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {}
574 void ConstructJob(Compilation &C, const JobAction &JA,
575 const InputInfo &Output, const InputInfoList &Inputs,
576 const llvm::opt::ArgList &TCArgs,
577 const char *LinkingOutput) const override;
580 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
582 Linker(const ToolChain &TC) : GnuTool("NaCl::Linker", "linker", TC) {}
584 bool hasIntegratedCPP() const override { return false; }
585 bool isLinkJob() const override { return true; }
587 void ConstructJob(Compilation &C, const JobAction &JA,
588 const InputInfo &Output, const InputInfoList &Inputs,
589 const llvm::opt::ArgList &TCArgs,
590 const char *LinkingOutput) const override;
592 } // end namespace nacltools
594 /// minix -- Directly call GNU Binutils assembler and linker
596 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
598 Assembler(const ToolChain &TC)
599 : GnuTool("minix::Assembler", "assembler", TC) {}
601 bool hasIntegratedCPP() const override { return false; }
603 void ConstructJob(Compilation &C, const JobAction &JA,
604 const InputInfo &Output, const InputInfoList &Inputs,
605 const llvm::opt::ArgList &TCArgs,
606 const char *LinkingOutput) const override;
609 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
611 Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {}
613 bool hasIntegratedCPP() const override { return false; }
614 bool isLinkJob() const override { return true; }
616 void ConstructJob(Compilation &C, const JobAction &JA,
617 const InputInfo &Output, const InputInfoList &Inputs,
618 const llvm::opt::ArgList &TCArgs,
619 const char *LinkingOutput) const override;
621 } // end namespace minix
623 /// solaris -- Directly call Solaris assembler and linker
625 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
627 Assembler(const ToolChain &TC)
628 : Tool("solaris::Assembler", "assembler", TC) {}
630 bool hasIntegratedCPP() const override { return false; }
632 void ConstructJob(Compilation &C, const JobAction &JA,
633 const InputInfo &Output, const InputInfoList &Inputs,
634 const llvm::opt::ArgList &TCArgs,
635 const char *LinkingOutput) const override;
638 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
640 Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {}
642 bool hasIntegratedCPP() const override { return false; }
643 bool isLinkJob() const override { return true; }
645 void ConstructJob(Compilation &C, const JobAction &JA,
646 const InputInfo &Output, const InputInfoList &Inputs,
647 const llvm::opt::ArgList &TCArgs,
648 const char *LinkingOutput) const override;
650 } // end namespace solaris
652 /// dragonfly -- Directly call GNU Binutils assembler and linker
653 namespace dragonfly {
654 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
656 Assembler(const ToolChain &TC)
657 : GnuTool("dragonfly::Assembler", "assembler", TC) {}
659 bool hasIntegratedCPP() const override { return false; }
661 void ConstructJob(Compilation &C, const JobAction &JA,
662 const InputInfo &Output, const InputInfoList &Inputs,
663 const llvm::opt::ArgList &TCArgs,
664 const char *LinkingOutput) const override;
667 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
669 Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {}
671 bool hasIntegratedCPP() const override { return false; }
672 bool isLinkJob() const override { return true; }
674 void ConstructJob(Compilation &C, const JobAction &JA,
675 const InputInfo &Output, const InputInfoList &Inputs,
676 const llvm::opt::ArgList &TCArgs,
677 const char *LinkingOutput) const override;
679 } // end namespace dragonfly
681 /// Visual studio tools.
682 namespace visualstudio {
683 VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple,
684 const llvm::opt::ArgList &Args, bool IsWindowsMSVC);
686 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
688 Linker(const ToolChain &TC)
689 : Tool("visualstudio::Linker", "linker", TC, RF_Full,
690 llvm::sys::WEM_UTF16) {}
692 bool hasIntegratedCPP() const override { return false; }
693 bool isLinkJob() const override { return true; }
695 void ConstructJob(Compilation &C, const JobAction &JA,
696 const InputInfo &Output, const InputInfoList &Inputs,
697 const llvm::opt::ArgList &TCArgs,
698 const char *LinkingOutput) const override;
701 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
703 Compiler(const ToolChain &TC)
704 : Tool("visualstudio::Compiler", "compiler", TC, RF_Full,
705 llvm::sys::WEM_UTF16) {}
707 bool hasIntegratedAssembler() const override { return true; }
708 bool hasIntegratedCPP() const override { return true; }
709 bool isLinkJob() const override { return false; }
711 void ConstructJob(Compilation &C, const JobAction &JA,
712 const InputInfo &Output, const InputInfoList &Inputs,
713 const llvm::opt::ArgList &TCArgs,
714 const char *LinkingOutput) const override;
716 std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA,
717 const InputInfo &Output,
718 const InputInfoList &Inputs,
719 const llvm::opt::ArgList &TCArgs,
720 const char *LinkingOutput) const;
722 } // end namespace visualstudio
724 /// MinGW -- Directly call GNU Binutils assembler and linker
726 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
728 Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
730 bool hasIntegratedCPP() const override { return false; }
732 void ConstructJob(Compilation &C, const JobAction &JA,
733 const InputInfo &Output, const InputInfoList &Inputs,
734 const llvm::opt::ArgList &TCArgs,
735 const char *LinkingOutput) const override;
738 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
740 Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
742 bool hasIntegratedCPP() const override { return false; }
743 bool isLinkJob() const override { return true; }
745 void ConstructJob(Compilation &C, const JobAction &JA,
746 const InputInfo &Output, const InputInfoList &Inputs,
747 const llvm::opt::ArgList &TCArgs,
748 const char *LinkingOutput) const override;
751 void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
753 } // end namespace MinGW
756 enum class FloatABI {
763 FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args);
764 } // end namespace arm
767 enum class FloatABI {
773 FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
774 } // end namespace ppc
777 // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and
779 // We simply use "clang -cc1" for those actions.
780 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
782 Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {}
784 bool hasIntegratedCPP() const override { return false; }
785 void ConstructJob(Compilation &C, const JobAction &JA,
786 const InputInfo &Output, const InputInfoList &Inputs,
787 const llvm::opt::ArgList &TCArgs,
788 const char *LinkingOutput) const override;
791 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
793 Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {}
795 bool hasIntegratedCPP() const override { return false; }
796 bool isLinkJob() const override { return true; }
797 void ConstructJob(Compilation &C, const JobAction &JA,
798 const InputInfo &Output, const InputInfoList &Inputs,
799 const llvm::opt::ArgList &TCArgs,
800 const char *LinkingOutput) const override;
802 } // end namespace XCore.
804 namespace CrossWindows {
805 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
807 Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {}
809 bool hasIntegratedCPP() const override { return false; }
811 void ConstructJob(Compilation &C, const JobAction &JA,
812 const InputInfo &Output, const InputInfoList &Inputs,
813 const llvm::opt::ArgList &TCArgs,
814 const char *LinkingOutput) const override;
817 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
819 Linker(const ToolChain &TC)
820 : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {}
822 bool hasIntegratedCPP() const override { return false; }
823 bool isLinkJob() const override { return true; }
825 void ConstructJob(Compilation &C, const JobAction &JA,
826 const InputInfo &Output, const InputInfoList &Inputs,
827 const llvm::opt::ArgList &TCArgs,
828 const char *LinkingOutput) const override;
830 } // end namespace CrossWindows
832 /// SHAVE tools -- Directly call moviCompile and moviAsm
834 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
836 Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {}
838 bool hasIntegratedCPP() const override { return true; }
840 void ConstructJob(Compilation &C, const JobAction &JA,
841 const InputInfo &Output, const InputInfoList &Inputs,
842 const llvm::opt::ArgList &TCArgs,
843 const char *LinkingOutput) const override;
846 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
848 Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {}
850 bool hasIntegratedCPP() const override { return false; } // not sure.
852 void ConstructJob(Compilation &C, const JobAction &JA,
853 const InputInfo &Output, const InputInfoList &Inputs,
854 const llvm::opt::ArgList &TCArgs,
855 const char *LinkingOutput) const override;
857 } // end namespace SHAVE
859 /// The Myriad toolchain uses tools that are in two different namespaces.
860 /// The Compiler and Assembler as defined above are in the SHAVE namespace,
861 /// whereas the linker, which accepts code for a mixture of Sparc and SHAVE,
862 /// is in the Myriad namespace.
864 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
866 Linker(const ToolChain &TC) : GnuTool("shave::Linker", "ld", TC) {}
867 bool hasIntegratedCPP() const override { return false; }
868 bool isLinkJob() const override { return true; }
869 void ConstructJob(Compilation &C, const JobAction &JA,
870 const InputInfo &Output, const InputInfoList &Inputs,
871 const llvm::opt::ArgList &TCArgs,
872 const char *LinkingOutput) const override;
874 } // end namespace Myriad
877 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
879 Assemble(const ToolChain &TC)
880 : Tool("PS4cpu::Assemble", "assembler", TC, RF_Full) {}
882 bool hasIntegratedCPP() const override { return false; }
884 void ConstructJob(Compilation &C, const JobAction &JA,
885 const InputInfo &Output,
886 const InputInfoList &Inputs,
887 const llvm::opt::ArgList &TCArgs,
888 const char *LinkingOutput) const override;
891 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
893 Link(const ToolChain &TC) : Tool("PS4cpu::Link", "linker", TC, RF_Full) {}
895 bool hasIntegratedCPP() const override { return false; }
896 bool isLinkJob() const override { return true; }
898 void ConstructJob(Compilation &C, const JobAction &JA,
899 const InputInfo &Output,
900 const InputInfoList &Inputs,
901 const llvm::opt::ArgList &TCArgs,
902 const char *LinkingOutput) const override;
904 } // end namespace PS4cpu
906 } // end namespace tools
907 } // end namespace driver
908 } // end namespace clang
910 #endif // LLVM_CLANG_LIB_DRIVER_TOOLS_H