clang  3.8.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"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Option/Option.h"
20 #include "llvm/Support/Compiler.h"
21 
22 namespace clang {
23 class ObjCRuntime;
24 
25 namespace driver {
26 class Command;
27 class Driver;
28 
29 namespace toolchains {
30 class MachO;
31 }
32 
33 namespace tools {
34 
35 namespace visualstudio {
36 class Compiler;
37 }
38 
39 using llvm::opt::ArgStringList;
40 
42  const llvm::opt::ArgList &Args,
43  StringRef Component, bool Shared = false);
44 
45 /// \brief Clang compiler tool.
46 class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
47 public:
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 
55 private:
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 
103 public:
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.
121 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
122 public:
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
139 class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool {
140  virtual void anchor();
141 
142 public:
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.
148 namespace gcc {
149 class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
150 public:
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 
169 class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
170 public:
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 
181 class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
182 public:
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 
192 class LLVM_LIBRARY_VISIBILITY Linker : public Common {
193 public:
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 
204 namespace 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.
208 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
209 public:
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 
223 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
224 public:
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 
239 namespace amdgpu {
240 
241 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
242 public:
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 
254 namespace wasm {
255 
256 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
257 public:
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 
269 namespace arm {
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);
277 
278 void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs,
279  const llvm::Triple &Triple);
280 } // end namespace arm
281 
282 namespace mips {
283 typedef enum { NanLegacy = 1, Nan2008 = 2 } NanEncoding;
284 
285 enum class FloatABI {
286  Invalid,
287  Soft,
288  Hard,
289 };
290 
291 NanEncoding getSupportedNanEncoding(StringRef &CPU);
292 void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
293  const llvm::Triple &Triple, StringRef &CPUName,
294  StringRef &ABIName);
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,
305 } // end namespace mips
306 
307 namespace ppc {
308 bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
309 } // end namespace ppc
310 
311 /// cloudabi -- Directly call GNU Binutils linker
312 namespace cloudabi {
313 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
314 public:
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 
327 namespace darwin {
328 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
329 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
330 
331 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
332  virtual void anchor();
333 
334 protected:
335  void AddMachOArch(const llvm::opt::ArgList &Args,
336  llvm::opt::ArgStringList &CmdArgs) const;
337 
339  return reinterpret_cast<const toolchains::MachO &>(getToolChain());
340  }
341 
342 public:
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 
352 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
353 public:
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 
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;
370 
371 public:
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 
385 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
386 public:
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 
397 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
398 public:
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 
411 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
412 public:
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
426 namespace openbsd {
427 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
428 public:
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 
440 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
441 public:
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
455 namespace bitrig {
456 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
457 public:
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 
469 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
470 public:
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
484 namespace freebsd {
485 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
486 public:
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 
498 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
499 public:
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
513 namespace netbsd {
514 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
515 public:
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 
527 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
528 public:
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.
542 namespace gnutools {
543 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
544 public:
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 
555 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
556 public:
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 
569 namespace nacltools {
570 class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
571 public:
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 
580 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
581 public:
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
595 namespace minix {
596 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
597 public:
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 
609 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
610 public:
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
624 namespace solaris {
625 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
626 public:
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 
638 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
639 public:
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
653 namespace dragonfly {
654 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
655 public:
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 
667 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
668 public:
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.
682 namespace visualstudio {
683 VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple,
684  const llvm::opt::ArgList &Args, bool IsWindowsMSVC);
685 
686 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
687 public:
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 
701 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
702 public:
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
725 namespace MinGW {
726 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
727 public:
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 
738 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
739 public:
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 
750 private:
751  void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
752 };
753 } // end namespace MinGW
754 
755 namespace arm {
756 enum class FloatABI {
757  Invalid,
758  Soft,
759  SoftFP,
760  Hard,
761 };
762 
763 FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args);
764 } // end namespace arm
765 
766 namespace ppc {
767 enum class FloatABI {
768  Invalid,
769  Soft,
770  Hard,
771 };
772 
773 FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
774 } // end namespace ppc
775 
776 namespace 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.
780 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
781 public:
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 
791 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
792 public:
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 
804 namespace CrossWindows {
805 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
806 public:
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 
817 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
818 public:
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
833 namespace SHAVE {
834 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
835 public:
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 
846 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
847 public:
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.
863 namespace Myriad {
864 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
865 public:
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 
876 namespace PS4cpu {
877 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
878 public:
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 
891 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
892 public:
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
bool hasIntegratedCPP() const override
Definition: Tools.h:357
Clang(const ToolChain &TC)
Definition: Tools.h:107
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
Linker(const ToolChain &TC)
Definition: Tools.h:500
bool isLinkJob() const override
Definition: Tools.h:823
bool hasIntegratedCPP() const override
Definition: Tools.h:659
NanEncoding getSupportedNanEncoding(StringRef &CPU)
Definition: Tools.cpp:6658
bool hasIntegratedCPP() const override
Definition: Tools.h:795
bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef CPUName, StringRef ABIName, mips::FloatABI FloatABI)
bool hasIntegratedAssembler() const override
Definition: Tools.h:707
bool isLinkJob() const override
Definition: Tools.h:672
bool isLinkJob() const override
Definition: Tools.h:377
SmallString< 128 > getCompilerRT(const ToolChain &TC, const llvm::opt::ArgList &Args, StringRef Component, bool Shared=false)
bool isLinkJob() const override
Definition: Tools.h:318
bool isDsymutilJob() const override
Definition: Tools.h:403
bool hasIntegratedCPP() const override
Definition: Tools.h:838
StringRef 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:6593
bool isLinkJob() const override
Definition: Tools.h:244
bool isLinkJob() const override
Definition: Tools.h:585
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:343
bool hasIntegratedCPP() const override
Definition: Tools.h:559
bool isLinkJob() const override
Definition: Tools.h:693
StringRef getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch, const llvm::Triple &Triple)
getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular CPU (or Arch, if CPU is generic).
Definition: Tools.cpp:6625
Linker(const ToolChain &TC)
Definition: Tools.h:669
FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args)
Clang integrated assembler tool.
Definition: Tools.h:121
bool hasIntegratedCPP() const override
Definition: Tools.h:584
Lipo(const ToolChain &TC)
Definition: Tools.h:387
Assembler(const ToolChain &TC)
Definition: Tools.h:848
bool hasIntegratedCPP() const override
Definition: Tools.h:867
bool hasIntegratedCPP() const override
Definition: Tools.h:317
bool hasIntegratedCPP() const override
Definition: Tools.h:671
bool hasIntegratedCPP() const override
Definition: Tools.h:432
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
Linker(const ToolChain &TC)
Definition: Tools.h:243
bool hasIntegratedCPP() const override
Definition: Tools.h:730
bool hasIntegratedCPP() const override
Definition: Tools.h:784
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:174
Compiler(const ToolChain &TC)
Definition: Tools.h:183
bool isLinkJob() const override
Definition: Tools.h:868
bool hasIntegratedCPP() const override
Definition: Tools.h:213
Assembler(const ToolChain &TC)
Definition: Tools.h:782
bool hasIntegratedCPP() const override
Definition: Tools.h:389
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:6606
bool hasIntegratedCPP() const override
Definition: Tools.h:461
bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
bool hasIntegratedCPP() const override
Definition: Tools.h:601
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
bool isLinkJob() const override
Definition: Tools.h:445
bool hasIntegratedCPP() const override
Definition: Tools.h:444
GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Tools.h:143
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:109
Assemble(const ToolChain &TC)
Definition: Tools.h:879
bool hasIntegratedCPP() const override
Definition: Tools.h:822
FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:65
bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value)
ClangAs(const ToolChain &TC)
Definition: Tools.h:123
Assembler(const ToolChain &TC)
Definition: Tools.h:728
bool hasIntegratedAssembler() const override
Definition: Tools.h:110
Assembler(const ToolChain &TC)
Definition: Tools.h:516
bool isLinkJob() const override
Definition: Tools.h:743
Assembler(const ToolChain &TC)
Definition: Tools.h:458
bool hasIntegratedAssembler() const override
Definition: Tools.h:157
bool hasIntegratedCPP() const override
Definition: Tools.h:490
Linker(const ToolChain &TC)
Definition: Tools.h:557
Compiler(const ToolChain &TC)
Definition: Tools.h:836
bool isLinkJob() const override
Definition: Tools.h:532
bool hasIntegratedCPP() const override
Definition: Tools.h:882
Assembler(const ToolChain &TC)
Definition: Tools.h:210
bool hasIntegratedAssembler() const override
Definition: Tools.h:128
bool hasIntegratedCPP() const override
Definition: Tools.h:630
VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, bool IsWindowsMSVC)
Definition: Tools.cpp:3095
Linker(const ToolChain &TC)
Definition: Tools.h:442
Preprocessor(const ToolChain &TC)
Definition: Tools.h:171
bool hasIntegratedCPP() const override
Definition: Tools.h:376
bool hasIntegratedCPP() const override
Definition: Tools.h:402
Dsymutil(const ToolChain &TC)
Definition: Tools.h:399
Linker(const ToolChain &TC)
Definition: Tools.h:611
bool hasIntegratedCPP() const override
Definition: Tools.h:227
Assembler(const ToolChain &TC)
Definition: Tools.h:545
Linker(const ToolChain &TC)
Definition: Tools.h:866
bool hasIntegratedCPP() const override
Definition: Tools.h:473
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Tools.cpp:6741
bool hasIntegratedCPP() const override
Definition: Tools.h:416
bool isLinkJob() const override
Definition: Tools.h:228
Common(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Tools.h:151
bool hasIntegratedCPP() const override
Definition: Tools.h:196
const std::string getARMArch(StringRef Arch, const llvm::Triple &Triple)
Definition: Tools.cpp:6566
Base class for all GNU tools that provide the same behavior when it comes to response files support...
Definition: Tools.h:139
bool isLinkJob() const override
Definition: Tools.h:614
bool hasIntegratedCPP() const override
Definition: Tools.h:519
bool canEmitIR() const override
Definition: Tools.h:112
bool hasIntegratedCPP() const override
Definition: Tools.h:502
bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value)
bool isUCLibc(const llvm::opt::ArgList &Args)
bool hasIntegratedCPP() const override
Definition: Tools.h:613
bool hasIntegratedCPP() const override
Definition: Tools.h:692
Linker(const ToolChain &TC)
Definition: Tools.h:529
bool hasIntegratedCPP() const override
Definition: Tools.h:111
bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, StringRef ABIName, mips::FloatABI FloatABI)
Definition: Tools.cpp:6706
Assembler(const ToolChain &TC)
Definition: Tools.h:627
Assembler(const ToolChain &TC)
Definition: Tools.h:598
Linker(const ToolChain &TC)
Definition: Tools.h:471
bool hasIntegratedCPP() const override
Definition: Tools.h:531
bool hasIntegratedCPP() const override
Definition: Tools.h:175
Linker(const ToolChain &TC)
Definition: Tools.h:582
Clang compiler tool.
Definition: Tools.h:46
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
bool hasIntegratedCPP() const override
Definition: Tools.h:850
bool hasIntegratedCPP() const override
Definition: Tools.h:186
Assembler(const ToolChain &TC)
Definition: Tools.h:354
bool isLinkJob() const override
Definition: Tools.h:560
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str)
Definition: Tools.cpp:6776
Linker(const ToolChain &TC)
Definition: Tools.h:372
Linker(const ToolChain &TC)
Definition: Tools.h:640
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:34
bool isLinkJob() const override
Definition: Tools.h:503
bool isLinkJob() const override
Definition: Tools.h:643
bool hasIntegratedCPP() const override
Definition: Tools.h:547
Linker(const ToolChain &TC)
Definition: Tools.h:793
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:127
Linker(const ToolChain &TC)
Definition: Tools.h:315
Linker(const ToolChain &TC)
Definition: Tools.h:740
const StringRef Input
Linker(const ToolChain &TC)
Definition: Tools.h:225
Defines the clang::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
Assembler(const ToolChain &TC)
Definition: Tools.h:429
Linker(const ToolChain &TC)
Definition: Tools.h:194
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
bool hasIntegratedCPP() const override
Definition: Tools.h:642
VerifyDebug(const ToolChain &TC)
Definition: Tools.h:413
bool hasIntegratedCPP() const override
Definition: Tools.h:809
bool isLinkJob() const override
Definition: Tools.h:474
bool isLinkJob() const override
Definition: Tools.h:197
std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Tools.h:185
bool hasIntegratedCPP() const override
Definition: Tools.h:129
Assembler(const ToolChain &TC)
Definition: Tools.h:487
bool hasIntegratedCPP() const override
Definition: Tools.h:245
bool hasIntegratedCPP() const override
Definition: Tools.h:742
bool isLinkJob() const override
Definition: Tools.h:796
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:47
bool hasIntegratedCPP() const override
Definition: Tools.h:708
const toolchains::MachO & getMachOToolChain() const
Definition: Tools.h:338