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 LLVM_CLANG_LIB_DRIVER_TOOLS_H
11#define LLVM_CLANG_LIB_DRIVER_TOOLS_H
12
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"
21
22namespace clang {
23class ObjCRuntime;
24
25namespace driver {
26class Command;
27class Driver;
28
29namespace toolchains {
30class MachO;
31}
32
33namespace tools {
34
35namespace visualstudio {
36class Compiler;
37}
38
39using llvm::opt::ArgStringList;
40
41SmallString<128> getCompilerRT(const ToolChain &TC,
42                               const llvm::opt::ArgList &Args,
43                               StringRef Component, bool Shared = false);
44
45/// \brief Clang compiler tool.
46class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
47public:
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);
54
55private:
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;
62
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;
87
88  enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
89
90  ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
91                                 llvm::opt::ArgStringList &cmdArgs,
92                                 RewriteKind rewrite) const;
93
94  void AddClangCLArgs(const llvm::opt::ArgList &Args,
95                      llvm::opt::ArgStringList &CmdArgs,
96                      enum CodeGenOptions::DebugInfoKind *DebugInfoKind,
97                      bool *EmitCodeView) const;
98
99  visualstudio::Compiler *getCLFallback() const;
100
101  mutable std::unique_ptr<visualstudio::Compiler> CLFallback;
102
103public:
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) {}
108
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; }
113
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;
118};
119
120/// \brief Clang integrated assembler tool.
121class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
122public:
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; }
130
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;
135};
136
137/// \brief Base class for all GNU tools that provide the same behavior when
138/// it comes to response files support
139class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool {
140  virtual void anchor();
141
142public:
143  GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
144      : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {}
145};
146
147/// gcc - Generic GCC tool implementations.
148namespace gcc {
149class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
150public:
151  Common(const char *Name, const char *ShortName, const ToolChain &TC)
152      : GnuTool(Name, ShortName, TC) {}
153
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;
162
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;
167};
168
169class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
170public:
171  Preprocessor(const ToolChain &TC)
172      : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
173
174  bool hasGoodDiagnostics() const override { return true; }
175  bool hasIntegratedCPP() const override { return false; }
176
177  void RenderExtraToolArgs(const JobAction &JA,
178                           llvm::opt::ArgStringList &CmdArgs) const override;
179};
180
181class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
182public:
183  Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
184
185  bool hasGoodDiagnostics() const override { return true; }
186  bool hasIntegratedCPP() const override { return true; }
187
188  void RenderExtraToolArgs(const JobAction &JA,
189                           llvm::opt::ArgStringList &CmdArgs) const override;
190};
191
192class LLVM_LIBRARY_VISIBILITY Linker : public Common {
193public:
194  Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
195
196  bool hasIntegratedCPP() const override { return false; }
197  bool isLinkJob() const override { return true; }
198
199  void RenderExtraToolArgs(const JobAction &JA,
200                           llvm::opt::ArgStringList &CmdArgs) const override;
201};
202} // end namespace gcc
203
204namespace hexagon {
205// For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile
206// and Compile.
207// We simply use "clang -cc1" for those actions.
208class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
209public:
210  Assembler(const ToolChain &TC)
211      : GnuTool("hexagon::Assembler", "hexagon-as", TC) {}
212
213  bool hasIntegratedCPP() const override { return false; }
214
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;
221};
222
223class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
224public:
225  Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {}
226
227  bool hasIntegratedCPP() const override { return false; }
228  bool isLinkJob() const override { return true; }
229
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;
236};
237} // end namespace hexagon.
238
239namespace amdgpu {
240
241class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
242public:
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;
250};
251
252} // end namespace amdgpu
253
254namespace wasm {
255
256class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
257public:
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;
265};
266
267} // end namespace wasm
268
269namespace arm {
270std::string getARMTargetCPU(StringRef CPU, StringRef Arch,
271                            const llvm::Triple &Triple);
272const std::string getARMArch(StringRef Arch,
273                             const llvm::Triple &Triple);
274StringRef getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple);
275StringRef getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
276                                  const llvm::Triple &Triple);
277
278void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs,
279                       const llvm::Triple &Triple);
280} // end namespace arm
281
282namespace mips {
283typedef enum { NanLegacy = 1, Nan2008 = 2 } NanEncoding;
284
285enum class FloatABI {
286  Invalid,
287  Soft,
288  Hard,
289};
290
291NanEncoding getSupportedNanEncoding(StringRef &CPU);
292void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
293                      const llvm::Triple &Triple, StringRef &CPUName,
294                      StringRef &ABIName);
295std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args,
296                                const llvm::Triple &Triple);
297bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
298bool isUCLibc(const llvm::opt::ArgList &Args);
299bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
300bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
301                   StringRef ABIName, mips::FloatABI FloatABI);
302bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
303                   StringRef CPUName, StringRef ABIName,
304                   mips::FloatABI FloatABI);
305} // end namespace mips
306
307namespace ppc {
308bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
309} // end namespace ppc
310
311/// cloudabi -- Directly call GNU Binutils linker
312namespace cloudabi {
313class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
314public:
315  Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {}
316
317  bool hasIntegratedCPP() const override { return false; }
318  bool isLinkJob() const override { return true; }
319
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;
324};
325} // end namespace cloudabi
326
327namespace darwin {
328llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
329void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
330
331class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
332  virtual void anchor();
333
334protected:
335  void AddMachOArch(const llvm::opt::ArgList &Args,
336                    llvm::opt::ArgStringList &CmdArgs) const;
337
338  const toolchains::MachO &getMachOToolChain() const {
339    return reinterpret_cast<const toolchains::MachO &>(getToolChain());
340  }
341
342public:
343  MachOTool(
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,
349             ResponseFlag) {}
350};
351
352class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
353public:
354  Assembler(const ToolChain &TC)
355      : MachOTool("darwin::Assembler", "assembler", TC) {}
356
357  bool hasIntegratedCPP() const override { return false; }
358
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;
363};
364
365class 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;
370
371public:
372  Linker(const ToolChain &TC)
373      : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
374                  llvm::sys::WEM_UTF8, "-filelist") {}
375
376  bool hasIntegratedCPP() const override { return false; }
377  bool isLinkJob() const override { return true; }
378
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;
383};
384
385class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
386public:
387  Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
388
389  bool hasIntegratedCPP() const override { return false; }
390
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;
395};
396
397class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
398public:
399  Dsymutil(const ToolChain &TC)
400      : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
401
402  bool hasIntegratedCPP() const override { return false; }
403  bool isDsymutilJob() const override { return true; }
404
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;
409};
410
411class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
412public:
413  VerifyDebug(const ToolChain &TC)
414      : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
415
416  bool hasIntegratedCPP() const override { return false; }
417
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;
422};
423} // end namespace darwin
424
425/// openbsd -- Directly call GNU Binutils assembler and linker
426namespace openbsd {
427class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
428public:
429  Assembler(const ToolChain &TC)
430      : GnuTool("openbsd::Assembler", "assembler", TC) {}
431
432  bool hasIntegratedCPP() const override { return false; }
433
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;
438};
439
440class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
441public:
442  Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {}
443
444  bool hasIntegratedCPP() const override { return false; }
445  bool isLinkJob() const override { return true; }
446
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;
451};
452} // end namespace openbsd
453
454/// bitrig -- Directly call GNU Binutils assembler and linker
455namespace bitrig {
456class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
457public:
458  Assembler(const ToolChain &TC)
459      : GnuTool("bitrig::Assembler", "assembler", TC) {}
460
461  bool hasIntegratedCPP() const override { return false; }
462
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;
467};
468
469class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
470public:
471  Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {}
472
473  bool hasIntegratedCPP() const override { return false; }
474  bool isLinkJob() const override { return true; }
475
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;
480};
481} // end namespace bitrig
482
483/// freebsd -- Directly call GNU Binutils assembler and linker
484namespace freebsd {
485class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
486public:
487  Assembler(const ToolChain &TC)
488      : GnuTool("freebsd::Assembler", "assembler", TC) {}
489
490  bool hasIntegratedCPP() const override { return false; }
491
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;
496};
497
498class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
499public:
500  Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {}
501
502  bool hasIntegratedCPP() const override { return false; }
503  bool isLinkJob() const override { return true; }
504
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;
509};
510} // end namespace freebsd
511
512/// netbsd -- Directly call GNU Binutils assembler and linker
513namespace netbsd {
514class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
515public:
516  Assembler(const ToolChain &TC)
517      : GnuTool("netbsd::Assembler", "assembler", TC) {}
518
519  bool hasIntegratedCPP() const override { return false; }
520
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;
525};
526
527class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
528public:
529  Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {}
530
531  bool hasIntegratedCPP() const override { return false; }
532  bool isLinkJob() const override { return true; }
533
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;
538};
539} // end namespace netbsd
540
541/// Directly call GNU Binutils' assembler and linker.
542namespace gnutools {
543class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
544public:
545  Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {}
546
547  bool hasIntegratedCPP() const override { return false; }
548
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;
553};
554
555class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
556public:
557  Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {}
558
559  bool hasIntegratedCPP() const override { return false; }
560  bool isLinkJob() const override { return true; }
561
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;
566};
567} // end namespace gnutools
568
569namespace nacltools {
570class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
571public:
572  AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {}
573
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;
578};
579
580class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
581public:
582  Linker(const ToolChain &TC) : GnuTool("NaCl::Linker", "linker", TC) {}
583
584  bool hasIntegratedCPP() const override { return false; }
585  bool isLinkJob() const override { return true; }
586
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;
591};
592} // end namespace nacltools
593
594/// minix -- Directly call GNU Binutils assembler and linker
595namespace minix {
596class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
597public:
598  Assembler(const ToolChain &TC)
599      : GnuTool("minix::Assembler", "assembler", TC) {}
600
601  bool hasIntegratedCPP() const override { return false; }
602
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;
607};
608
609class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
610public:
611  Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {}
612
613  bool hasIntegratedCPP() const override { return false; }
614  bool isLinkJob() const override { return true; }
615
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;
620};
621} // end namespace minix
622
623/// solaris -- Directly call Solaris assembler and linker
624namespace solaris {
625class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
626public:
627  Assembler(const ToolChain &TC)
628      : Tool("solaris::Assembler", "assembler", TC) {}
629
630  bool hasIntegratedCPP() const override { return false; }
631
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;
636};
637
638class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
639public:
640  Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {}
641
642  bool hasIntegratedCPP() const override { return false; }
643  bool isLinkJob() const override { return true; }
644
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;
649};
650} // end namespace solaris
651
652/// dragonfly -- Directly call GNU Binutils assembler and linker
653namespace dragonfly {
654class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
655public:
656  Assembler(const ToolChain &TC)
657      : GnuTool("dragonfly::Assembler", "assembler", TC) {}
658
659  bool hasIntegratedCPP() const override { return false; }
660
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;
665};
666
667class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
668public:
669  Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {}
670
671  bool hasIntegratedCPP() const override { return false; }
672  bool isLinkJob() const override { return true; }
673
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;
678};
679} // end namespace dragonfly
680
681/// Visual studio tools.
682namespace visualstudio {
683VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple,
684                            const llvm::opt::ArgList &Args, bool IsWindowsMSVC);
685
686class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
687public:
688  Linker(const ToolChain &TC)
689      : Tool("visualstudio::Linker", "linker", TC, RF_Full,
690             llvm::sys::WEM_UTF16) {}
691
692  bool hasIntegratedCPP() const override { return false; }
693  bool isLinkJob() const override { return true; }
694
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;
699};
700
701class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
702public:
703  Compiler(const ToolChain &TC)
704      : Tool("visualstudio::Compiler", "compiler", TC, RF_Full,
705             llvm::sys::WEM_UTF16) {}
706
707  bool hasIntegratedAssembler() const override { return true; }
708  bool hasIntegratedCPP() const override { return true; }
709  bool isLinkJob() const override { return false; }
710
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;
715
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;
721};
722} // end namespace visualstudio
723
724/// MinGW -- Directly call GNU Binutils assembler and linker
725namespace MinGW {
726class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
727public:
728  Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
729
730  bool hasIntegratedCPP() const override { return false; }
731
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;
736};
737
738class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
739public:
740  Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
741
742  bool hasIntegratedCPP() const override { return false; }
743  bool isLinkJob() const override { return true; }
744
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;
749
750private:
751  void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
752};
753} // end namespace MinGW
754
755namespace arm {
756enum class FloatABI {
757  Invalid,
758  Soft,
759  SoftFP,
760  Hard,
761};
762
763FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args);
764} // end namespace arm
765
766namespace ppc {
767enum class FloatABI {
768  Invalid,
769  Soft,
770  Hard,
771};
772
773FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
774} // end namespace ppc
775
776namespace XCore {
777// For XCore, we do not need to instantiate tools for PreProcess, PreCompile and
778// Compile.
779// We simply use "clang -cc1" for those actions.
780class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
781public:
782  Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {}
783
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;
789};
790
791class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
792public:
793  Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {}
794
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;
801};
802} // end namespace XCore.
803
804namespace CrossWindows {
805class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
806public:
807  Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {}
808
809  bool hasIntegratedCPP() const override { return false; }
810
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;
815};
816
817class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
818public:
819  Linker(const ToolChain &TC)
820      : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {}
821
822  bool hasIntegratedCPP() const override { return false; }
823  bool isLinkJob() const override { return true; }
824
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;
829};
830} // end namespace CrossWindows
831
832/// SHAVE tools -- Directly call moviCompile and moviAsm
833namespace SHAVE {
834class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
835public:
836  Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {}
837
838  bool hasIntegratedCPP() const override { return true; }
839
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;
844};
845
846class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
847public:
848  Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {}
849
850  bool hasIntegratedCPP() const override { return false; } // not sure.
851
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;
856};
857} // end namespace SHAVE
858
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.
863namespace Myriad {
864class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
865public:
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;
873};
874} // end namespace Myriad
875
876namespace PS4cpu {
877class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
878public:
879  Assemble(const ToolChain &TC)
880      : Tool("PS4cpu::Assemble", "assembler", TC, RF_Full) {}
881
882  bool hasIntegratedCPP() const override { return false; }
883
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;
889};
890
891class LLVM_LIBRARY_VISIBILITY Link : public Tool {
892public:
893  Link(const ToolChain &TC) : Tool("PS4cpu::Link", "linker", TC, RF_Full) {}
894
895  bool hasIntegratedCPP() const override { return false; }
896  bool isLinkJob() const override { return true; }
897
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;
903};
904} // end namespace PS4cpu
905
906} // end namespace tools
907} // end namespace driver
908} // end namespace clang
909
910#endif // LLVM_CLANG_LIB_DRIVER_TOOLS_H
911