clang  3.7.0
Tools.h
Go to the documentation of this file.
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 
14 #include "clang/Driver/Tool.h"
15 #include "clang/Driver/Types.h"
16 #include "clang/Driver/Util.h"
17 #include "llvm/ADT/Triple.h"
18 #include "llvm/Option/Option.h"
19 #include "llvm/Support/Compiler.h"
20 
21 namespace clang {
22  class ObjCRuntime;
23 
24 namespace driver {
25  class Command;
26  class Driver;
27 
28 namespace toolchains {
29  class MachO;
30 }
31 
32 namespace tools {
33 
34 namespace visualstudio {
35 class Compiler;
36 }
37 
38 using llvm::opt::ArgStringList;
39 
40 SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
41  bool Shared = false);
42 
43  /// \brief Clang compiler tool.
44  class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
45  public:
46  static const char *getBaseInputName(const llvm::opt::ArgList &Args,
47  const InputInfo &Input);
48  static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
49  const InputInfoList &Inputs);
50  static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
51  const InputInfoList &Inputs);
52 
53  private:
54  void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
55  const Driver &D,
56  const llvm::opt::ArgList &Args,
57  llvm::opt::ArgStringList &CmdArgs,
58  const InputInfo &Output,
59  const InputInfoList &Inputs) const;
60 
61  void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
62  llvm::opt::ArgStringList &CmdArgs) const;
63  void AddARMTargetArgs(const llvm::opt::ArgList &Args,
64  llvm::opt::ArgStringList &CmdArgs,
65  bool KernelOrKext) const;
66  void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
67  llvm::opt::ArgStringList &CmdArgs) const;
68  void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
69  llvm::opt::ArgStringList &CmdArgs) const;
70  void AddPPCTargetArgs(const llvm::opt::ArgList &Args,
71  llvm::opt::ArgStringList &CmdArgs) const;
72  void AddR600TargetArgs(const llvm::opt::ArgList &Args,
73  llvm::opt::ArgStringList &CmdArgs) const;
74  void AddSparcTargetArgs(const llvm::opt::ArgList &Args,
75  llvm::opt::ArgStringList &CmdArgs) const;
76  void AddSystemZTargetArgs(const llvm::opt::ArgList &Args,
77  llvm::opt::ArgStringList &CmdArgs) const;
78  void AddX86TargetArgs(const llvm::opt::ArgList &Args,
79  llvm::opt::ArgStringList &CmdArgs) const;
80  void AddHexagonTargetArgs(const llvm::opt::ArgList &Args,
81  llvm::opt::ArgStringList &CmdArgs) const;
82 
83  enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
84 
85  ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
86  llvm::opt::ArgStringList &cmdArgs,
87  RewriteKind rewrite) const;
88 
89  void AddClangCLArgs(const llvm::opt::ArgList &Args,
90  llvm::opt::ArgStringList &CmdArgs) const;
91 
92  visualstudio::Compiler *getCLFallback() const;
93 
94  mutable std::unique_ptr<visualstudio::Compiler> CLFallback;
95 
96  public:
97  // CAUTION! The first constructor argument ("clang") is not arbitrary,
98  // as it is for other tools. Some operations on a Tool actually test
99  // whether that tool is Clang based on the Tool's Name as a string.
100  Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {}
101 
102  bool hasGoodDiagnostics() const override { return true; }
103  bool hasIntegratedAssembler() const override { return true; }
104  bool hasIntegratedCPP() const override { return true; }
105  bool canEmitIR() const override { return true; }
106 
107  void ConstructJob(Compilation &C, const JobAction &JA,
108  const InputInfo &Output, const InputInfoList &Inputs,
109  const llvm::opt::ArgList &TCArgs,
110  const char *LinkingOutput) const override;
111  };
112 
113  /// \brief Clang integrated assembler tool.
114  class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
115  public:
116  ClangAs(const ToolChain &TC) : Tool("clang::as",
117  "clang integrated assembler", TC,
118  RF_Full) {}
119  void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
120  llvm::opt::ArgStringList &CmdArgs) const;
121  bool hasGoodDiagnostics() const override { return true; }
122  bool hasIntegratedAssembler() const override { return false; }
123  bool hasIntegratedCPP() const override { return false; }
124 
125  void ConstructJob(Compilation &C, const JobAction &JA,
126  const InputInfo &Output, const InputInfoList &Inputs,
127  const llvm::opt::ArgList &TCArgs,
128  const char *LinkingOutput) const override;
129  };
130 
131  /// \brief Base class for all GNU tools that provide the same behavior when
132  /// it comes to response files support
133  class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool {
134  virtual void anchor();
135 
136  public:
137  GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
138  : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {}
139  };
140 
141  /// gcc - Generic GCC tool implementations.
142 namespace gcc {
143  class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
144  public:
145  Common(const char *Name, const char *ShortName,
146  const ToolChain &TC) : GnuTool(Name, ShortName, TC) {}
147 
148  void ConstructJob(Compilation &C, const JobAction &JA,
149  const InputInfo &Output,
150  const InputInfoList &Inputs,
151  const llvm::opt::ArgList &TCArgs,
152  const char *LinkingOutput) const override;
153 
154  /// RenderExtraToolArgs - Render any arguments necessary to force
155  /// the particular tool mode.
156  virtual void
157  RenderExtraToolArgs(const JobAction &JA,
158  llvm::opt::ArgStringList &CmdArgs) const = 0;
159  };
160 
161  class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
162  public:
164  : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
165 
166  bool hasGoodDiagnostics() const override { return true; }
167  bool hasIntegratedCPP() const override { return false; }
168 
169  void RenderExtraToolArgs(const JobAction &JA,
170  llvm::opt::ArgStringList &CmdArgs) const override;
171  };
172 
173  class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
174  public:
175  Compiler(const ToolChain &TC)
176  : Common("gcc::Compiler", "gcc frontend", TC) {}
177 
178  bool hasGoodDiagnostics() const override { return true; }
179  bool hasIntegratedCPP() const override { return true; }
180 
181  void RenderExtraToolArgs(const JobAction &JA,
182  llvm::opt::ArgStringList &CmdArgs) const override;
183  };
184 
185  class LLVM_LIBRARY_VISIBILITY Linker : public Common {
186  public:
187  Linker(const ToolChain &TC)
188  : Common("gcc::Linker", "linker (via gcc)", TC) {}
189 
190  bool hasIntegratedCPP() const override { return false; }
191  bool isLinkJob() const override { return true; }
192 
193  void RenderExtraToolArgs(const JobAction &JA,
194  llvm::opt::ArgStringList &CmdArgs) const override;
195  };
196 } // end namespace gcc
197 
198 namespace hexagon {
199 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile
200 // and Compile.
201 // We simply use "clang -cc1" for those actions.
202 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
203 public:
204  Assembler(const ToolChain &TC)
205  : GnuTool("hexagon::Assembler", "hexagon-as", TC) {}
206 
207  bool hasIntegratedCPP() const override { return false; }
208 
209  void RenderExtraToolArgs(const JobAction &JA,
210  llvm::opt::ArgStringList &CmdArgs) const;
211  void ConstructJob(Compilation &C, const JobAction &JA,
212  const InputInfo &Output, const InputInfoList &Inputs,
213  const llvm::opt::ArgList &TCArgs,
214  const char *LinkingOutput) const override;
215 };
216 
217 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
218 public:
219  Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {}
220 
221  bool hasIntegratedCPP() const override { return false; }
222  bool isLinkJob() const override { return true; }
223 
224  virtual void RenderExtraToolArgs(const JobAction &JA,
225  llvm::opt::ArgStringList &CmdArgs) const;
226  void ConstructJob(Compilation &C, const JobAction &JA,
227  const InputInfo &Output, const InputInfoList &Inputs,
228  const llvm::opt::ArgList &TCArgs,
229  const char *LinkingOutput) const override;
230  };
231 } // end namespace hexagon.
232 
233 namespace arm {
234  std::string getARMTargetCPU(StringRef CPU, StringRef Arch,
235  const llvm::Triple &Triple);
236  const std::string getARMArch(StringRef Arch,
237  const llvm::Triple &Triple);
238  const char* getARMCPUForMArch(StringRef Arch,
239  const llvm::Triple &Triple);
240  const char* getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch);
241 
242  void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple);
243 }
244 
245 namespace mips {
246  typedef enum {
249  } NanEncoding;
250  NanEncoding getSupportedNanEncoding(StringRef &CPU);
251  void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
252  const llvm::Triple &Triple, StringRef &CPUName,
253  StringRef &ABIName);
254  bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
255  bool isUCLibc(const llvm::opt::ArgList &Args);
256  bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
257  bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
258  StringRef ABIName, StringRef FloatABI);
259  bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
260  StringRef CPUName, StringRef ABIName, StringRef FloatABI);
261 }
262 
263 namespace ppc {
264  bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
265 }
266 
267 /// cloudabi -- Directly call GNU Binutils linker
268 namespace cloudabi {
269 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
270 public:
271  Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {}
272 
273  bool hasIntegratedCPP() const override { return false; }
274  bool isLinkJob() const override { return true; }
275 
276  void ConstructJob(Compilation &C, const JobAction &JA,
277  const InputInfo &Output, const InputInfoList &Inputs,
278  const llvm::opt::ArgList &TCArgs,
279  const char *LinkingOutput) const override;
280 };
281 } // end namespace cloudabi
282 
283 namespace darwin {
284  llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
285  void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
286 
287  class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
288  virtual void anchor();
289  protected:
290  void AddMachOArch(const llvm::opt::ArgList &Args,
291  llvm::opt::ArgStringList &CmdArgs) const;
292 
294  return reinterpret_cast<const toolchains::MachO&>(getToolChain());
295  }
296 
297  public:
299  const char *Name, const char *ShortName, const ToolChain &TC,
300  ResponseFileSupport ResponseSupport = RF_None,
301  llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
302  const char *ResponseFlag = "@")
303  : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
304  ResponseFlag) {}
305  };
306 
307  class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
308  public:
309  Assembler(const ToolChain &TC)
310  : MachOTool("darwin::Assembler", "assembler", TC) {}
311 
312  bool hasIntegratedCPP() const override { return false; }
313 
314  void ConstructJob(Compilation &C, const JobAction &JA,
315  const InputInfo &Output, const InputInfoList &Inputs,
316  const llvm::opt::ArgList &TCArgs,
317  const char *LinkingOutput) const override;
318  };
319 
320  class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
321  bool NeedsTempPath(const InputInfoList &Inputs) const;
322  void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
323  llvm::opt::ArgStringList &CmdArgs,
324  const InputInfoList &Inputs) const;
325 
326  public:
327  Linker(const ToolChain &TC)
328  : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
329  llvm::sys::WEM_UTF8, "-filelist") {}
330 
331  bool hasIntegratedCPP() const override { return false; }
332  bool isLinkJob() const override { return true; }
333 
334  void ConstructJob(Compilation &C, const JobAction &JA,
335  const InputInfo &Output, const InputInfoList &Inputs,
336  const llvm::opt::ArgList &TCArgs,
337  const char *LinkingOutput) const override;
338  };
339 
340  class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
341  public:
342  Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
343 
344  bool hasIntegratedCPP() const override { return false; }
345 
346  void ConstructJob(Compilation &C, const JobAction &JA,
347  const InputInfo &Output, const InputInfoList &Inputs,
348  const llvm::opt::ArgList &TCArgs,
349  const char *LinkingOutput) const override;
350  };
351 
352  class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
353  public:
354  Dsymutil(const ToolChain &TC) : MachOTool("darwin::Dsymutil",
355  "dsymutil", TC) {}
356 
357  bool hasIntegratedCPP() const override { return false; }
358  bool isDsymutilJob() const override { return true; }
359 
360  void ConstructJob(Compilation &C, const JobAction &JA,
361  const InputInfo &Output,
362  const InputInfoList &Inputs,
363  const llvm::opt::ArgList &TCArgs,
364  const char *LinkingOutput) const override;
365  };
366 
367  class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
368  public:
369  VerifyDebug(const ToolChain &TC) : MachOTool("darwin::VerifyDebug",
370  "dwarfdump", TC) {}
371 
372  bool hasIntegratedCPP() const override { return false; }
373 
374  void ConstructJob(Compilation &C, const JobAction &JA,
375  const InputInfo &Output, const InputInfoList &Inputs,
376  const llvm::opt::ArgList &TCArgs,
377  const char *LinkingOutput) const override;
378  };
379 
380 }
381 
382 /// openbsd -- Directly call GNU Binutils assembler and linker
383 namespace openbsd {
384 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
385 public:
386  Assembler(const ToolChain &TC)
387  : GnuTool("openbsd::Assembler", "assembler", 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 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
397 public:
398  Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {}
399 
400  bool hasIntegratedCPP() const override { return false; }
401  bool isLinkJob() const override { return true; }
402 
403  void ConstructJob(Compilation &C, const JobAction &JA,
404  const InputInfo &Output, const InputInfoList &Inputs,
405  const llvm::opt::ArgList &TCArgs,
406  const char *LinkingOutput) const override;
407  };
408 } // end namespace openbsd
409 
410 /// bitrig -- Directly call GNU Binutils assembler and linker
411 namespace bitrig {
412 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
413 public:
414  Assembler(const ToolChain &TC)
415  : GnuTool("bitrig::Assembler", "assembler", TC) {}
416 
417  bool hasIntegratedCPP() const override { return false; }
418 
419  void ConstructJob(Compilation &C, const JobAction &JA,
420  const InputInfo &Output, const InputInfoList &Inputs,
421  const llvm::opt::ArgList &TCArgs,
422  const char *LinkingOutput) const override;
423 };
424 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
425 public:
426  Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {}
427 
428  bool hasIntegratedCPP() const override { return false; }
429  bool isLinkJob() const override { return true; }
430 
431  void ConstructJob(Compilation &C, const JobAction &JA,
432  const InputInfo &Output, const InputInfoList &Inputs,
433  const llvm::opt::ArgList &TCArgs,
434  const char *LinkingOutput) const override;
435  };
436 } // end namespace bitrig
437 
438 /// freebsd -- Directly call GNU Binutils assembler and linker
439 namespace freebsd {
440 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
441 public:
442  Assembler(const ToolChain &TC)
443  : GnuTool("freebsd::Assembler", "assembler", TC) {}
444 
445  bool hasIntegratedCPP() const override { return false; }
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 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
453 public:
454  Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {}
455 
456  bool hasIntegratedCPP() const override { return false; }
457  bool isLinkJob() const override { return true; }
458 
459  void ConstructJob(Compilation &C, const JobAction &JA,
460  const InputInfo &Output, const InputInfoList &Inputs,
461  const llvm::opt::ArgList &TCArgs,
462  const char *LinkingOutput) const override;
463  };
464 } // end namespace freebsd
465 
466 /// netbsd -- Directly call GNU Binutils assembler and linker
467 namespace netbsd {
468 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
469 
470 public:
471  Assembler(const ToolChain &TC)
472  : GnuTool("netbsd::Assembler", "assembler", TC) {}
473 
474  bool hasIntegratedCPP() const override { return false; }
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 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
482 
483 public:
484  Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {}
485 
486  bool hasIntegratedCPP() const override { return false; }
487  bool isLinkJob() const override { return true; }
488 
489  void ConstructJob(Compilation &C, const JobAction &JA,
490  const InputInfo &Output, const InputInfoList &Inputs,
491  const llvm::opt::ArgList &TCArgs,
492  const char *LinkingOutput) const override;
493  };
494 } // end namespace netbsd
495 
496 /// Directly call GNU Binutils' assembler and linker.
497 namespace gnutools {
498 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
499 public:
500  Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {}
501 
502  bool hasIntegratedCPP() const override { return false; }
503 
504  void ConstructJob(Compilation &C, const JobAction &JA,
505  const InputInfo &Output, const InputInfoList &Inputs,
506  const llvm::opt::ArgList &TCArgs,
507  const char *LinkingOutput) const override;
508 };
509 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
510 public:
511  Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {}
512 
513  bool hasIntegratedCPP() const override { return false; }
514  bool isLinkJob() const override { return true; }
515 
516  void ConstructJob(Compilation &C, const JobAction &JA,
517  const InputInfo &Output,
518  const InputInfoList &Inputs,
519  const llvm::opt::ArgList &TCArgs,
520  const char *LinkingOutput) const override;
521  };
522  }
523 
524  namespace nacltools {
525  class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
526  public:
527  AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {}
528 
529  void ConstructJob(Compilation &C, const JobAction &JA,
530  const InputInfo &Output, const InputInfoList &Inputs,
531  const llvm::opt::ArgList &TCArgs,
532  const char *LinkingOutput) const override;
533  };
534  class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
535  public:
536  Linker(const ToolChain &TC) : Tool("NaCl::Linker", "linker", TC) {}
537 
538  bool hasIntegratedCPP() const override { return false; }
539  bool isLinkJob() const override { return true; }
540 
541  void ConstructJob(Compilation &C, const JobAction &JA,
542  const InputInfo &Output,
543  const InputInfoList &Inputs,
544  const llvm::opt::ArgList &TCArgs,
545  const char *LinkingOutput) const override;
546  };
547 }
548 
549 /// minix -- Directly call GNU Binutils assembler and linker
550 namespace minix {
551 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
552 public:
553  Assembler(const ToolChain &TC)
554  : GnuTool("minix::Assembler", "assembler", TC) {}
555 
556  bool hasIntegratedCPP() const override { return false; }
557 
558  void ConstructJob(Compilation &C, const JobAction &JA,
559  const InputInfo &Output, const InputInfoList &Inputs,
560  const llvm::opt::ArgList &TCArgs,
561  const char *LinkingOutput) const override;
562 };
563 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
564 public:
565  Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {}
566 
567  bool hasIntegratedCPP() const override { return false; }
568  bool isLinkJob() const override { return true; }
569 
570  void ConstructJob(Compilation &C, const JobAction &JA,
571  const InputInfo &Output,
572  const InputInfoList &Inputs,
573  const llvm::opt::ArgList &TCArgs,
574  const char *LinkingOutput) const override;
575  };
576 } // end namespace minix
577 
578 /// solaris -- Directly call Solaris assembler and linker
579 namespace solaris {
580 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
581 public:
582  Assembler(const ToolChain &TC)
583  : Tool("solaris::Assembler", "assembler", TC) {}
584 
585  bool hasIntegratedCPP() const override { return false; }
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 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
593 public:
594  Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {}
595 
596  bool hasIntegratedCPP() const override { return false; }
597  bool isLinkJob() const override { return true; }
598 
599  void ConstructJob(Compilation &C, const JobAction &JA,
600  const InputInfo &Output, const InputInfoList &Inputs,
601  const llvm::opt::ArgList &TCArgs,
602  const char *LinkingOutput) const override;
603  };
604 } // end namespace solaris
605 
606 /// dragonfly -- Directly call GNU Binutils assembler and linker
607 namespace dragonfly {
608 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
609 public:
610  Assembler(const ToolChain &TC)
611  : GnuTool("dragonfly::Assembler", "assembler", TC) {}
612 
613  bool hasIntegratedCPP() const override { return false; }
614 
615  void ConstructJob(Compilation &C, const JobAction &JA,
616  const InputInfo &Output, const InputInfoList &Inputs,
617  const llvm::opt::ArgList &TCArgs,
618  const char *LinkingOutput) const override;
619 };
620 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
621 public:
622  Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {}
623 
624  bool hasIntegratedCPP() const override { return false; }
625  bool isLinkJob() const override { return true; }
626 
627  void ConstructJob(Compilation &C, const JobAction &JA,
628  const InputInfo &Output,
629  const InputInfoList &Inputs,
630  const llvm::opt::ArgList &TCArgs,
631  const char *LinkingOutput) const override;
632  };
633 } // end namespace dragonfly
634 
635 /// Visual studio tools.
636 namespace visualstudio {
637 VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple,
638  const llvm::opt::ArgList &Args, bool IsWindowsMSVC);
639 
640 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
641 public:
642  Linker(const ToolChain &TC)
643  : Tool("visualstudio::Linker", "linker", TC, RF_Full,
644  llvm::sys::WEM_UTF16) {}
645 
646  bool hasIntegratedCPP() const override { return false; }
647  bool isLinkJob() const override { return true; }
648 
649  void ConstructJob(Compilation &C, const JobAction &JA,
650  const InputInfo &Output, const InputInfoList &Inputs,
651  const llvm::opt::ArgList &TCArgs,
652  const char *LinkingOutput) const override;
653 };
654 
655 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
656 public:
657  Compiler(const ToolChain &TC)
658  : Tool("visualstudio::Compiler", "compiler", TC, RF_Full,
659  llvm::sys::WEM_UTF16) {}
660 
661  bool hasIntegratedAssembler() const override { return true; }
662  bool hasIntegratedCPP() const override { return true; }
663  bool isLinkJob() const override { return false; }
664 
665  void ConstructJob(Compilation &C, const JobAction &JA,
666  const InputInfo &Output, const InputInfoList &Inputs,
667  const llvm::opt::ArgList &TCArgs,
668  const char *LinkingOutput) const override;
669 
670  std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA,
671  const InputInfo &Output,
672  const InputInfoList &Inputs,
673  const llvm::opt::ArgList &TCArgs,
674  const char *LinkingOutput) const;
675  };
676 } // end namespace visualstudio
677 
678 /// MinGW -- Directly call GNU Binutils assembler and linker
679 namespace MinGW {
680 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
681 public:
682  Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
683 
684  bool hasIntegratedCPP() const override { return false; }
685 
686  void ConstructJob(Compilation &C, const JobAction &JA,
687  const InputInfo &Output, const InputInfoList &Inputs,
688  const llvm::opt::ArgList &TCArgs,
689  const char *LinkingOutput) const override;
690 };
691 
692 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
693 public:
694  Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
695 
696  bool hasIntegratedCPP() const override { return false; }
697  bool isLinkJob() const override { return true; }
698 
699  void ConstructJob(Compilation &C, const JobAction &JA,
700  const InputInfo &Output, const InputInfoList &Inputs,
701  const llvm::opt::ArgList &TCArgs,
702  const char *LinkingOutput) const override;
703 
704 private:
705  void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
706 };
707 } // end namespace MinGW
708 
709 namespace arm {
710  StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
711  const llvm::Triple &Triple);
712 }
713 namespace XCore {
714 // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and
715 // Compile.
716 // We simply use "clang -cc1" for those actions.
717 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
718 public:
719  Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {}
720 
721  bool hasIntegratedCPP() const override { return false; }
722  void ConstructJob(Compilation &C, const JobAction &JA,
723  const InputInfo &Output, const InputInfoList &Inputs,
724  const llvm::opt::ArgList &TCArgs,
725  const char *LinkingOutput) const override;
726 };
727 
728 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
729 public:
730  Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {}
731 
732  bool hasIntegratedCPP() const override { return false; }
733  bool isLinkJob() const override { return true; }
734  void ConstructJob(Compilation &C, const JobAction &JA,
735  const InputInfo &Output, const InputInfoList &Inputs,
736  const llvm::opt::ArgList &TCArgs,
737  const char *LinkingOutput) const override;
738  };
739  } // end namespace XCore.
740 
741  namespace CrossWindows {
742  class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
743  public:
744  Assembler(const ToolChain &TC)
745  : Tool("CrossWindows::Assembler", "as", TC) {}
746 
747  bool hasIntegratedCPP() const override { return false; }
748 
749  void ConstructJob(Compilation &C, const JobAction &JA,
750  const InputInfo &Output, const InputInfoList &Inputs,
751  const llvm::opt::ArgList &TCArgs,
752  const char *LinkingOutput) const override;
753  };
754 
755  class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
756  public:
757  Linker(const ToolChain &TC)
758  : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {}
759 
760  bool hasIntegratedCPP() const override { return false; }
761  bool isLinkJob() const override { return true; }
762 
763  void ConstructJob(Compilation &C, const JobAction &JA,
764  const InputInfo &Output, const InputInfoList &Inputs,
765  const llvm::opt::ArgList &TCArgs,
766  const char *LinkingOutput) const override;
767 };
768 }
769 
770 /// SHAVE tools -- Directly call moviCompile and moviAsm
771 namespace SHAVE {
772 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
773 public:
774  Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {}
775 
776  bool hasIntegratedCPP() const override { return true; }
777 
778  void ConstructJob(Compilation &C, const JobAction &JA,
779  const InputInfo &Output, const InputInfoList &Inputs,
780  const llvm::opt::ArgList &TCArgs,
781  const char *LinkingOutput) const override;
782 };
783 
784 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
785 public:
786  Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {}
787 
788  bool hasIntegratedCPP() const override { return false; } // not sure.
789 
790  void ConstructJob(Compilation &C, const JobAction &JA,
791  const InputInfo &Output, const InputInfoList &Inputs,
792  const llvm::opt::ArgList &TCArgs,
793  const char *LinkingOutput) const override;
794 };
795 } // end namespace SHAVE
796 
797 } // end namespace tools
798 } // end namespace driver
799 } // end namespace clang
800 
801 #endif
bool hasIntegratedCPP() const override
Definition: Tools.h:312
Clang(const ToolChain &TC)
Definition: Tools.h:100
const char * getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple)
Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Definition: Tools.cpp:5908
bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, StringRef ABIName, StringRef FloatABI)
Definition: Tools.cpp:6011
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
Linker(const ToolChain &TC)
Definition: Tools.h:454
bool isLinkJob() const override
Definition: Tools.h:761
bool hasIntegratedCPP() const override
Definition: Tools.h:613
NanEncoding getSupportedNanEncoding(StringRef &CPU)
Definition: Tools.cpp:5966
bool hasIntegratedCPP() const override
Definition: Tools.h:732
bool hasIntegratedAssembler() const override
Definition: Tools.h:661
bool isLinkJob() const override
Definition: Tools.h:625
bool isLinkJob() const override
Definition: Tools.h:332
bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef CPUName, StringRef ABIName, StringRef FloatABI)
bool isLinkJob() const override
Definition: Tools.h:274
bool isDsymutilJob() const override
Definition: Tools.h:358
bool hasIntegratedCPP() const override
Definition: Tools.h:776
bool isLinkJob() const override
Definition: Tools.h:539
MachOTool(const char *Name, const char *ShortName, const ToolChain &TC, ResponseFileSupport ResponseSupport=RF_None, llvm::sys::WindowsEncodingMethod ResponseEncoding=llvm::sys::WEM_UTF8, const char *ResponseFlag="@")
Definition: Tools.h:298
bool hasIntegratedCPP() const override
Definition: Tools.h:513
bool isLinkJob() const override
Definition: Tools.h:647
Linker(const ToolChain &TC)
Definition: Tools.h:622
Clang integrated assembler tool.
Definition: Tools.h:114
bool hasIntegratedCPP() const override
Definition: Tools.h:538
Lipo(const ToolChain &TC)
Definition: Tools.h:342
Assembler(const ToolChain &TC)
Definition: Tools.h:786
bool hasIntegratedCPP() const override
Definition: Tools.h:273
bool hasIntegratedCPP() const override
Definition: Tools.h:624
bool hasIntegratedCPP() const override
Definition: Tools.h:389
bool hasIntegratedCPP() const override
Definition: Tools.h:684
bool hasIntegratedCPP() const override
Definition: Tools.h:721
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:166
Compiler(const ToolChain &TC)
Definition: Tools.h:175
bool hasIntegratedCPP() const override
Definition: Tools.h:207
Assembler(const ToolChain &TC)
Definition: Tools.h:719
bool hasIntegratedCPP() const override
Definition: Tools.h:344
void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple)
std::string getARMTargetCPU(StringRef CPU, StringRef Arch, const llvm::Triple &Triple)
getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Definition: Tools.cpp:5925
bool hasIntegratedCPP() const override
Definition: Tools.h:417
bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
bool hasIntegratedCPP() const override
Definition: Tools.h:556
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
bool isLinkJob() const override
Definition: Tools.h:401
bool hasIntegratedCPP() const override
Definition: Tools.h:400
GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Tools.h:137
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:102
bool hasIntegratedCPP() const override
Definition: Tools.h:760
bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value)
ClangAs(const ToolChain &TC)
Definition: Tools.h:116
Assembler(const ToolChain &TC)
Definition: Tools.h:682
bool hasIntegratedAssembler() const override
Definition: Tools.h:103
Assembler(const ToolChain &TC)
Definition: Tools.h:471
bool isLinkJob() const override
Definition: Tools.h:697
Assembler(const ToolChain &TC)
Definition: Tools.h:414
bool hasIntegratedCPP() const override
Definition: Tools.h:445
Linker(const ToolChain &TC)
Definition: Tools.h:511
Compiler(const ToolChain &TC)
Definition: Tools.h:774
bool isLinkJob() const override
Definition: Tools.h:487
Assembler(const ToolChain &TC)
Definition: Tools.h:204
bool hasIntegratedAssembler() const override
Definition: Tools.h:122
bool hasIntegratedCPP() const override
Definition: Tools.h:585
VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, bool IsWindowsMSVC)
Definition: Tools.cpp:2791
Linker(const ToolChain &TC)
Definition: Tools.h:398
Preprocessor(const ToolChain &TC)
Definition: Tools.h:163
bool hasIntegratedCPP() const override
Definition: Tools.h:331
bool hasIntegratedCPP() const override
Definition: Tools.h:357
const char * getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch)
Definition: Tools.cpp:5944
Dsymutil(const ToolChain &TC)
Definition: Tools.h:354
Linker(const ToolChain &TC)
Definition: Tools.h:565
bool hasIntegratedCPP() const override
Definition: Tools.h:221
Assembler(const ToolChain &TC)
Definition: Tools.h:500
bool hasIntegratedCPP() const override
Definition: Tools.h:428
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Tools.cpp:6046
bool hasIntegratedCPP() const override
Definition: Tools.h:372
bool isLinkJob() const override
Definition: Tools.h:222
Common(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Tools.h:145
bool hasIntegratedCPP() const override
Definition: Tools.h:190
const std::string getARMArch(StringRef Arch, const llvm::Triple &Triple)
Definition: Tools.cpp:5882
Base class for all GNU tools that provide the same behavior when it comes to response files support...
Definition: Tools.h:133
bool isLinkJob() const override
Definition: Tools.h:568
bool hasIntegratedCPP() const override
Definition: Tools.h:474
bool canEmitIR() const override
Definition: Tools.h:105
bool hasIntegratedCPP() const override
Definition: Tools.h:456
bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value)
bool isUCLibc(const llvm::opt::ArgList &Args)
StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
bool hasIntegratedCPP() const override
Definition: Tools.h:567
bool hasIntegratedCPP() const override
Definition: Tools.h:646
Linker(const ToolChain &TC)
Definition: Tools.h:484
bool hasIntegratedCPP() const override
Definition: Tools.h:104
Assembler(const ToolChain &TC)
Definition: Tools.h:582
Assembler(const ToolChain &TC)
Definition: Tools.h:553
SmallString< 128 > getCompilerRT(const ToolChain &TC, StringRef Component, bool Shared=false)
Definition: Tools.cpp:2363
Linker(const ToolChain &TC)
Definition: Tools.h:426
bool hasIntegratedCPP() const override
Definition: Tools.h:486
bool hasIntegratedCPP() const override
Definition: Tools.h:167
Linker(const ToolChain &TC)
Definition: Tools.h:536
Clang compiler tool.
Definition: Tools.h:44
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
bool hasIntegratedCPP() const override
Definition: Tools.h:788
bool hasIntegratedCPP() const override
Definition: Tools.h:179
Assembler(const ToolChain &TC)
Definition: Tools.h:309
bool isLinkJob() const override
Definition: Tools.h:514
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str)
Definition: Tools.cpp:6081
Linker(const ToolChain &TC)
Definition: Tools.h:327
Linker(const ToolChain &TC)
Definition: Tools.h:594
bool isLinkJob() const override
Definition: Tools.h:457
bool isLinkJob() const override
Definition: Tools.h:597
bool hasIntegratedCPP() const override
Definition: Tools.h:502
Linker(const ToolChain &TC)
Definition: Tools.h:730
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:121
Linker(const ToolChain &TC)
Definition: Tools.h:271
Linker(const ToolChain &TC)
Definition: Tools.h:694
const StringRef Input
Linker(const ToolChain &TC)
Definition: Tools.h:219
Defines the clang::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
Assembler(const ToolChain &TC)
Definition: Tools.h:386
Linker(const ToolChain &TC)
Definition: Tools.h:187
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
bool hasIntegratedCPP() const override
Definition: Tools.h:596
VerifyDebug(const ToolChain &TC)
Definition: Tools.h:369
bool hasIntegratedCPP() const override
Definition: Tools.h:747
bool isLinkJob() const override
Definition: Tools.h:429
bool isLinkJob() const override
Definition: Tools.h:191
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:178
bool hasIntegratedCPP() const override
Definition: Tools.h:123
Assembler(const ToolChain &TC)
Definition: Tools.h:442
bool hasIntegratedCPP() const override
Definition: Tools.h:696
bool isLinkJob() const override
Definition: Tools.h:733
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:43
bool hasIntegratedCPP() const override
Definition: Tools.h:662
const toolchains::MachO & getMachOToolChain() const
Definition: Tools.h:293