• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/DebugInfoOptions.h"
14 #include "clang/Basic/VersionTuple.h"
15 #include "clang/Driver/Tool.h"
16 #include "clang/Driver/Types.h"
17 #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 
41 SmallString<128> getCompilerRT(const ToolChain &TC,
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 AddLanaiTargetArgs(const llvm::opt::ArgList &Args,
86                           llvm::opt::ArgStringList &CmdArgs) const;
87   void AddWebAssemblyTargetArgs(const llvm::opt::ArgList &Args,
88                                 llvm::opt::ArgStringList &CmdArgs) const;
89 
90   enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
91 
92   ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
93                                  llvm::opt::ArgStringList &cmdArgs,
94                                  RewriteKind rewrite) const;
95 
96   void AddClangCLArgs(const llvm::opt::ArgList &Args, types::ID InputType,
97                       llvm::opt::ArgStringList &CmdArgs,
98                       codegenoptions::DebugInfoKind *DebugInfoKind,
99                       bool *EmitCodeView) const;
100 
101   visualstudio::Compiler *getCLFallback() const;
102 
103   mutable std::unique_ptr<visualstudio::Compiler> CLFallback;
104 
105 public:
106   // CAUTION! The first constructor argument ("clang") is not arbitrary,
107   // as it is for other tools. Some operations on a Tool actually test
108   // whether that tool is Clang based on the Tool's Name as a string.
Clang(const ToolChain & TC)109   Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {}
110 
hasGoodDiagnostics()111   bool hasGoodDiagnostics() const override { return true; }
hasIntegratedAssembler()112   bool hasIntegratedAssembler() const override { return true; }
hasIntegratedCPP()113   bool hasIntegratedCPP() const override { return true; }
canEmitIR()114   bool canEmitIR() const override { return true; }
115 
116   void ConstructJob(Compilation &C, const JobAction &JA,
117                     const InputInfo &Output, const InputInfoList &Inputs,
118                     const llvm::opt::ArgList &TCArgs,
119                     const char *LinkingOutput) const override;
120 };
121 
122 /// \brief Clang integrated assembler tool.
123 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
124 public:
ClangAs(const ToolChain & TC)125   ClangAs(const ToolChain &TC)
126       : Tool("clang::as", "clang integrated assembler", TC, RF_Full) {}
127   void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
128                          llvm::opt::ArgStringList &CmdArgs) const;
hasGoodDiagnostics()129   bool hasGoodDiagnostics() const override { return true; }
hasIntegratedAssembler()130   bool hasIntegratedAssembler() const override { return false; }
hasIntegratedCPP()131   bool hasIntegratedCPP() const override { return false; }
132 
133   void ConstructJob(Compilation &C, const JobAction &JA,
134                     const InputInfo &Output, const InputInfoList &Inputs,
135                     const llvm::opt::ArgList &TCArgs,
136                     const char *LinkingOutput) const override;
137 };
138 
139 /// \brief Base class for all GNU tools that provide the same behavior when
140 /// it comes to response files support
141 class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool {
142   virtual void anchor();
143 
144 public:
GnuTool(const char * Name,const char * ShortName,const ToolChain & TC)145   GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
146       : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {}
147 };
148 
149 /// gcc - Generic GCC tool implementations.
150 namespace gcc {
151 class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
152 public:
Common(const char * Name,const char * ShortName,const ToolChain & TC)153   Common(const char *Name, const char *ShortName, const ToolChain &TC)
154       : GnuTool(Name, ShortName, TC) {}
155 
156   // A gcc tool has an "integrated" assembler that it will call to produce an
157   // object. Let it use that assembler so that we don't have to deal with
158   // assembly syntax incompatibilities.
hasIntegratedAssembler()159   bool hasIntegratedAssembler() const override { return true; }
160   void ConstructJob(Compilation &C, const JobAction &JA,
161                     const InputInfo &Output, const InputInfoList &Inputs,
162                     const llvm::opt::ArgList &TCArgs,
163                     const char *LinkingOutput) const override;
164 
165   /// RenderExtraToolArgs - Render any arguments necessary to force
166   /// the particular tool mode.
167   virtual void RenderExtraToolArgs(const JobAction &JA,
168                                    llvm::opt::ArgStringList &CmdArgs) const = 0;
169 };
170 
171 class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
172 public:
Preprocessor(const ToolChain & TC)173   Preprocessor(const ToolChain &TC)
174       : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
175 
hasGoodDiagnostics()176   bool hasGoodDiagnostics() const override { return true; }
hasIntegratedCPP()177   bool hasIntegratedCPP() const override { return false; }
178 
179   void RenderExtraToolArgs(const JobAction &JA,
180                            llvm::opt::ArgStringList &CmdArgs) const override;
181 };
182 
183 class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
184 public:
Compiler(const ToolChain & TC)185   Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
186 
hasGoodDiagnostics()187   bool hasGoodDiagnostics() const override { return true; }
hasIntegratedCPP()188   bool hasIntegratedCPP() const override { return true; }
189 
190   void RenderExtraToolArgs(const JobAction &JA,
191                            llvm::opt::ArgStringList &CmdArgs) const override;
192 };
193 
194 class LLVM_LIBRARY_VISIBILITY Linker : public Common {
195 public:
Linker(const ToolChain & TC)196   Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
197 
hasIntegratedCPP()198   bool hasIntegratedCPP() const override { return false; }
isLinkJob()199   bool isLinkJob() const override { return true; }
200 
201   void RenderExtraToolArgs(const JobAction &JA,
202                            llvm::opt::ArgStringList &CmdArgs) const override;
203 };
204 } // end namespace gcc
205 
206 namespace hexagon {
207 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile
208 // and Compile.
209 // We simply use "clang -cc1" for those actions.
210 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
211 public:
Assembler(const ToolChain & TC)212   Assembler(const ToolChain &TC)
213       : GnuTool("hexagon::Assembler", "hexagon-as", TC) {}
214 
hasIntegratedCPP()215   bool hasIntegratedCPP() const override { return false; }
216 
217   void RenderExtraToolArgs(const JobAction &JA,
218                            llvm::opt::ArgStringList &CmdArgs) const;
219   void ConstructJob(Compilation &C, const JobAction &JA,
220                     const InputInfo &Output, const InputInfoList &Inputs,
221                     const llvm::opt::ArgList &TCArgs,
222                     const char *LinkingOutput) const override;
223 };
224 
225 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
226 public:
Linker(const ToolChain & TC)227   Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {}
228 
hasIntegratedCPP()229   bool hasIntegratedCPP() const override { return false; }
isLinkJob()230   bool isLinkJob() const override { return true; }
231 
232   virtual void RenderExtraToolArgs(const JobAction &JA,
233                                    llvm::opt::ArgStringList &CmdArgs) const;
234   void ConstructJob(Compilation &C, const JobAction &JA,
235                     const InputInfo &Output, const InputInfoList &Inputs,
236                     const llvm::opt::ArgList &TCArgs,
237                     const char *LinkingOutput) const override;
238 };
239 } // end namespace hexagon.
240 
241 namespace amdgpu {
242 
243 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
244 public:
Linker(const ToolChain & TC)245   Linker(const ToolChain &TC) : GnuTool("amdgpu::Linker", "ld.lld", TC) {}
isLinkJob()246   bool isLinkJob() const override { return true; }
hasIntegratedCPP()247   bool hasIntegratedCPP() const override { return false; }
248   void ConstructJob(Compilation &C, const JobAction &JA,
249                     const InputInfo &Output, const InputInfoList &Inputs,
250                     const llvm::opt::ArgList &TCArgs,
251                     const char *LinkingOutput) const override;
252 };
253 
254 } // end namespace amdgpu
255 
256 namespace wasm {
257 
258 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
259 public:
260   explicit Linker(const ToolChain &TC);
261   bool isLinkJob() const override;
262   bool hasIntegratedCPP() const override;
263   void ConstructJob(Compilation &C, const JobAction &JA,
264                     const InputInfo &Output, const InputInfoList &Inputs,
265                     const llvm::opt::ArgList &TCArgs,
266                     const char *LinkingOutput) const override;
267 };
268 
269 } // end namespace wasm
270 
271 namespace arm {
272 std::string getARMTargetCPU(StringRef CPU, StringRef Arch,
273                             const llvm::Triple &Triple);
274 const std::string getARMArch(StringRef Arch,
275                              const llvm::Triple &Triple);
276 StringRef getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple);
277 StringRef getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
278                                   const llvm::Triple &Triple);
279 
280 void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs,
281                        const llvm::Triple &Triple);
282 } // end namespace arm
283 
284 namespace mips {
285 typedef enum { NanLegacy = 1, Nan2008 = 2 } NanEncoding;
286 
287 enum class FloatABI {
288   Invalid,
289   Soft,
290   Hard,
291 };
292 
293 NanEncoding getSupportedNanEncoding(StringRef &CPU);
294 bool hasCompactBranches(StringRef &CPU);
295 void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
296                       const llvm::Triple &Triple, StringRef &CPUName,
297                       StringRef &ABIName);
298 std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args,
299                                 const llvm::Triple &Triple);
300 bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
301 bool isUCLibc(const llvm::opt::ArgList &Args);
302 bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
303 bool isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName);
304 bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
305                    StringRef ABIName, mips::FloatABI FloatABI);
306 bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
307                    StringRef CPUName, StringRef ABIName,
308                    mips::FloatABI FloatABI);
309 } // end namespace mips
310 
311 namespace ppc {
312 bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
313 } // end namespace ppc
314 
315 /// cloudabi -- Directly call GNU Binutils linker
316 namespace cloudabi {
317 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
318 public:
Linker(const ToolChain & TC)319   Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {}
320 
hasIntegratedCPP()321   bool hasIntegratedCPP() const override { return false; }
isLinkJob()322   bool isLinkJob() const override { return true; }
323 
324   void ConstructJob(Compilation &C, const JobAction &JA,
325                     const InputInfo &Output, const InputInfoList &Inputs,
326                     const llvm::opt::ArgList &TCArgs,
327                     const char *LinkingOutput) const override;
328 };
329 } // end namespace cloudabi
330 
331 namespace darwin {
332 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
333 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
334 
335 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
336   virtual void anchor();
337 
338 protected:
339   void AddMachOArch(const llvm::opt::ArgList &Args,
340                     llvm::opt::ArgStringList &CmdArgs) const;
341 
getMachOToolChain()342   const toolchains::MachO &getMachOToolChain() const {
343     return reinterpret_cast<const toolchains::MachO &>(getToolChain());
344   }
345 
346 public:
347   MachOTool(
348       const char *Name, const char *ShortName, const ToolChain &TC,
349       ResponseFileSupport ResponseSupport = RF_None,
350       llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
351       const char *ResponseFlag = "@")
Tool(Name,ShortName,TC,ResponseSupport,ResponseEncoding,ResponseFlag)352       : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
353              ResponseFlag) {}
354 };
355 
356 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
357 public:
Assembler(const ToolChain & TC)358   Assembler(const ToolChain &TC)
359       : MachOTool("darwin::Assembler", "assembler", TC) {}
360 
hasIntegratedCPP()361   bool hasIntegratedCPP() const override { return false; }
362 
363   void ConstructJob(Compilation &C, const JobAction &JA,
364                     const InputInfo &Output, const InputInfoList &Inputs,
365                     const llvm::opt::ArgList &TCArgs,
366                     const char *LinkingOutput) const override;
367 };
368 
369 class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
370   bool NeedsTempPath(const InputInfoList &Inputs) const;
371   void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
372                    llvm::opt::ArgStringList &CmdArgs,
373                    const InputInfoList &Inputs) const;
374 
375 public:
Linker(const ToolChain & TC)376   Linker(const ToolChain &TC)
377       : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
378                   llvm::sys::WEM_UTF8, "-filelist") {}
379 
hasIntegratedCPP()380   bool hasIntegratedCPP() const override { return false; }
isLinkJob()381   bool isLinkJob() const override { return true; }
382 
383   void ConstructJob(Compilation &C, const JobAction &JA,
384                     const InputInfo &Output, const InputInfoList &Inputs,
385                     const llvm::opt::ArgList &TCArgs,
386                     const char *LinkingOutput) const override;
387 };
388 
389 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
390 public:
Lipo(const ToolChain & TC)391   Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
392 
hasIntegratedCPP()393   bool hasIntegratedCPP() const override { return false; }
394 
395   void ConstructJob(Compilation &C, const JobAction &JA,
396                     const InputInfo &Output, const InputInfoList &Inputs,
397                     const llvm::opt::ArgList &TCArgs,
398                     const char *LinkingOutput) const override;
399 };
400 
401 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
402 public:
Dsymutil(const ToolChain & TC)403   Dsymutil(const ToolChain &TC)
404       : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
405 
hasIntegratedCPP()406   bool hasIntegratedCPP() const override { return false; }
isDsymutilJob()407   bool isDsymutilJob() const override { return true; }
408 
409   void ConstructJob(Compilation &C, const JobAction &JA,
410                     const InputInfo &Output, const InputInfoList &Inputs,
411                     const llvm::opt::ArgList &TCArgs,
412                     const char *LinkingOutput) const override;
413 };
414 
415 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
416 public:
VerifyDebug(const ToolChain & TC)417   VerifyDebug(const ToolChain &TC)
418       : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
419 
hasIntegratedCPP()420   bool hasIntegratedCPP() const override { return false; }
421 
422   void ConstructJob(Compilation &C, const JobAction &JA,
423                     const InputInfo &Output, const InputInfoList &Inputs,
424                     const llvm::opt::ArgList &TCArgs,
425                     const char *LinkingOutput) const override;
426 };
427 } // end namespace darwin
428 
429 /// openbsd -- Directly call GNU Binutils assembler and linker
430 namespace openbsd {
431 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
432 public:
Assembler(const ToolChain & TC)433   Assembler(const ToolChain &TC)
434       : GnuTool("openbsd::Assembler", "assembler", TC) {}
435 
hasIntegratedCPP()436   bool hasIntegratedCPP() const override { return false; }
437 
438   void ConstructJob(Compilation &C, const JobAction &JA,
439                     const InputInfo &Output, const InputInfoList &Inputs,
440                     const llvm::opt::ArgList &TCArgs,
441                     const char *LinkingOutput) const override;
442 };
443 
444 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
445 public:
Linker(const ToolChain & TC)446   Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {}
447 
hasIntegratedCPP()448   bool hasIntegratedCPP() const override { return false; }
isLinkJob()449   bool isLinkJob() const override { return true; }
450 
451   void ConstructJob(Compilation &C, const JobAction &JA,
452                     const InputInfo &Output, const InputInfoList &Inputs,
453                     const llvm::opt::ArgList &TCArgs,
454                     const char *LinkingOutput) const override;
455 };
456 } // end namespace openbsd
457 
458 /// bitrig -- Directly call GNU Binutils assembler and linker
459 namespace bitrig {
460 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
461 public:
Assembler(const ToolChain & TC)462   Assembler(const ToolChain &TC)
463       : GnuTool("bitrig::Assembler", "assembler", TC) {}
464 
hasIntegratedCPP()465   bool hasIntegratedCPP() const override { return false; }
466 
467   void ConstructJob(Compilation &C, const JobAction &JA,
468                     const InputInfo &Output, const InputInfoList &Inputs,
469                     const llvm::opt::ArgList &TCArgs,
470                     const char *LinkingOutput) const override;
471 };
472 
473 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
474 public:
Linker(const ToolChain & TC)475   Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {}
476 
hasIntegratedCPP()477   bool hasIntegratedCPP() const override { return false; }
isLinkJob()478   bool isLinkJob() const override { return true; }
479 
480   void ConstructJob(Compilation &C, const JobAction &JA,
481                     const InputInfo &Output, const InputInfoList &Inputs,
482                     const llvm::opt::ArgList &TCArgs,
483                     const char *LinkingOutput) const override;
484 };
485 } // end namespace bitrig
486 
487 /// freebsd -- Directly call GNU Binutils assembler and linker
488 namespace freebsd {
489 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
490 public:
Assembler(const ToolChain & TC)491   Assembler(const ToolChain &TC)
492       : GnuTool("freebsd::Assembler", "assembler", TC) {}
493 
hasIntegratedCPP()494   bool hasIntegratedCPP() const override { return false; }
495 
496   void ConstructJob(Compilation &C, const JobAction &JA,
497                     const InputInfo &Output, const InputInfoList &Inputs,
498                     const llvm::opt::ArgList &TCArgs,
499                     const char *LinkingOutput) const override;
500 };
501 
502 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
503 public:
Linker(const ToolChain & TC)504   Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {}
505 
hasIntegratedCPP()506   bool hasIntegratedCPP() const override { return false; }
isLinkJob()507   bool isLinkJob() const override { return true; }
508 
509   void ConstructJob(Compilation &C, const JobAction &JA,
510                     const InputInfo &Output, const InputInfoList &Inputs,
511                     const llvm::opt::ArgList &TCArgs,
512                     const char *LinkingOutput) const override;
513 };
514 } // end namespace freebsd
515 
516 /// netbsd -- Directly call GNU Binutils assembler and linker
517 namespace netbsd {
518 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
519 public:
Assembler(const ToolChain & TC)520   Assembler(const ToolChain &TC)
521       : GnuTool("netbsd::Assembler", "assembler", TC) {}
522 
hasIntegratedCPP()523   bool hasIntegratedCPP() const override { return false; }
524 
525   void ConstructJob(Compilation &C, const JobAction &JA,
526                     const InputInfo &Output, const InputInfoList &Inputs,
527                     const llvm::opt::ArgList &TCArgs,
528                     const char *LinkingOutput) const override;
529 };
530 
531 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
532 public:
Linker(const ToolChain & TC)533   Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {}
534 
hasIntegratedCPP()535   bool hasIntegratedCPP() const override { return false; }
isLinkJob()536   bool isLinkJob() const override { return true; }
537 
538   void ConstructJob(Compilation &C, const JobAction &JA,
539                     const InputInfo &Output, const InputInfoList &Inputs,
540                     const llvm::opt::ArgList &TCArgs,
541                     const char *LinkingOutput) const override;
542 };
543 } // end namespace netbsd
544 
545 /// Directly call GNU Binutils' assembler and linker.
546 namespace gnutools {
547 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
548 public:
Assembler(const ToolChain & TC)549   Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {}
550 
hasIntegratedCPP()551   bool hasIntegratedCPP() const override { return false; }
552 
553   void ConstructJob(Compilation &C, const JobAction &JA,
554                     const InputInfo &Output, const InputInfoList &Inputs,
555                     const llvm::opt::ArgList &TCArgs,
556                     const char *LinkingOutput) const override;
557 };
558 
559 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
560 public:
Linker(const ToolChain & TC)561   Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {}
562 
hasIntegratedCPP()563   bool hasIntegratedCPP() const override { return false; }
isLinkJob()564   bool isLinkJob() const override { return true; }
565 
566   void ConstructJob(Compilation &C, const JobAction &JA,
567                     const InputInfo &Output, const InputInfoList &Inputs,
568                     const llvm::opt::ArgList &TCArgs,
569                     const char *LinkingOutput) const override;
570 };
571 } // end namespace gnutools
572 
573 namespace nacltools {
574 class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler {
575 public:
AssemblerARM(const ToolChain & TC)576   AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {}
577 
578   void ConstructJob(Compilation &C, const JobAction &JA,
579                     const InputInfo &Output, const InputInfoList &Inputs,
580                     const llvm::opt::ArgList &TCArgs,
581                     const char *LinkingOutput) const override;
582 };
583 
584 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
585 public:
Linker(const ToolChain & TC)586   Linker(const ToolChain &TC) : GnuTool("NaCl::Linker", "linker", TC) {}
587 
hasIntegratedCPP()588   bool hasIntegratedCPP() const override { return false; }
isLinkJob()589   bool isLinkJob() const override { return true; }
590 
591   void ConstructJob(Compilation &C, const JobAction &JA,
592                     const InputInfo &Output, const InputInfoList &Inputs,
593                     const llvm::opt::ArgList &TCArgs,
594                     const char *LinkingOutput) const override;
595 };
596 } // end namespace nacltools
597 
598 /// minix -- Directly call GNU Binutils assembler and linker
599 namespace minix {
600 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
601 public:
Assembler(const ToolChain & TC)602   Assembler(const ToolChain &TC)
603       : GnuTool("minix::Assembler", "assembler", TC) {}
604 
hasIntegratedCPP()605   bool hasIntegratedCPP() const override { return false; }
606 
607   void ConstructJob(Compilation &C, const JobAction &JA,
608                     const InputInfo &Output, const InputInfoList &Inputs,
609                     const llvm::opt::ArgList &TCArgs,
610                     const char *LinkingOutput) const override;
611 };
612 
613 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
614 public:
Linker(const ToolChain & TC)615   Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {}
616 
hasIntegratedCPP()617   bool hasIntegratedCPP() const override { return false; }
isLinkJob()618   bool isLinkJob() const override { return true; }
619 
620   void ConstructJob(Compilation &C, const JobAction &JA,
621                     const InputInfo &Output, const InputInfoList &Inputs,
622                     const llvm::opt::ArgList &TCArgs,
623                     const char *LinkingOutput) const override;
624 };
625 } // end namespace minix
626 
627 /// solaris -- Directly call Solaris assembler and linker
628 namespace solaris {
629 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
630 public:
Assembler(const ToolChain & TC)631   Assembler(const ToolChain &TC)
632       : Tool("solaris::Assembler", "assembler", TC) {}
633 
hasIntegratedCPP()634   bool hasIntegratedCPP() const override { return false; }
635 
636   void ConstructJob(Compilation &C, const JobAction &JA,
637                     const InputInfo &Output, const InputInfoList &Inputs,
638                     const llvm::opt::ArgList &TCArgs,
639                     const char *LinkingOutput) const override;
640 };
641 
642 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
643 public:
Linker(const ToolChain & TC)644   Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {}
645 
hasIntegratedCPP()646   bool hasIntegratedCPP() const override { return false; }
isLinkJob()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 } // end namespace solaris
655 
656 /// dragonfly -- Directly call GNU Binutils assembler and linker
657 namespace dragonfly {
658 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
659 public:
Assembler(const ToolChain & TC)660   Assembler(const ToolChain &TC)
661       : GnuTool("dragonfly::Assembler", "assembler", TC) {}
662 
hasIntegratedCPP()663   bool hasIntegratedCPP() 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 
671 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
672 public:
Linker(const ToolChain & TC)673   Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {}
674 
hasIntegratedCPP()675   bool hasIntegratedCPP() const override { return false; }
isLinkJob()676   bool isLinkJob() const override { return true; }
677 
678   void ConstructJob(Compilation &C, const JobAction &JA,
679                     const InputInfo &Output, const InputInfoList &Inputs,
680                     const llvm::opt::ArgList &TCArgs,
681                     const char *LinkingOutput) const override;
682 };
683 } // end namespace dragonfly
684 
685 /// Visual studio tools.
686 namespace visualstudio {
687 VersionTuple getMSVCVersion(const Driver *D, const ToolChain &TC,
688                             const llvm::Triple &Triple,
689                             const llvm::opt::ArgList &Args, bool IsWindowsMSVC);
690 
691 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
692 public:
Linker(const ToolChain & TC)693   Linker(const ToolChain &TC)
694       : Tool("visualstudio::Linker", "linker", TC, RF_Full,
695              llvm::sys::WEM_UTF16) {}
696 
hasIntegratedCPP()697   bool hasIntegratedCPP() const override { return false; }
isLinkJob()698   bool isLinkJob() const override { return true; }
699 
700   void ConstructJob(Compilation &C, const JobAction &JA,
701                     const InputInfo &Output, const InputInfoList &Inputs,
702                     const llvm::opt::ArgList &TCArgs,
703                     const char *LinkingOutput) const override;
704 };
705 
706 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
707 public:
Compiler(const ToolChain & TC)708   Compiler(const ToolChain &TC)
709       : Tool("visualstudio::Compiler", "compiler", TC, RF_Full,
710              llvm::sys::WEM_UTF16) {}
711 
hasIntegratedAssembler()712   bool hasIntegratedAssembler() const override { return true; }
hasIntegratedCPP()713   bool hasIntegratedCPP() const override { return true; }
isLinkJob()714   bool isLinkJob() const override { return false; }
715 
716   void ConstructJob(Compilation &C, const JobAction &JA,
717                     const InputInfo &Output, const InputInfoList &Inputs,
718                     const llvm::opt::ArgList &TCArgs,
719                     const char *LinkingOutput) const override;
720 
721   std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA,
722                                       const InputInfo &Output,
723                                       const InputInfoList &Inputs,
724                                       const llvm::opt::ArgList &TCArgs,
725                                       const char *LinkingOutput) const;
726 };
727 } // end namespace visualstudio
728 
729 /// MinGW -- Directly call GNU Binutils assembler and linker
730 namespace MinGW {
731 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
732 public:
Assembler(const ToolChain & TC)733   Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
734 
hasIntegratedCPP()735   bool hasIntegratedCPP() const override { return false; }
736 
737   void ConstructJob(Compilation &C, const JobAction &JA,
738                     const InputInfo &Output, const InputInfoList &Inputs,
739                     const llvm::opt::ArgList &TCArgs,
740                     const char *LinkingOutput) const override;
741 };
742 
743 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
744 public:
Linker(const ToolChain & TC)745   Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
746 
hasIntegratedCPP()747   bool hasIntegratedCPP() const override { return false; }
isLinkJob()748   bool isLinkJob() const override { return true; }
749 
750   void ConstructJob(Compilation &C, const JobAction &JA,
751                     const InputInfo &Output, const InputInfoList &Inputs,
752                     const llvm::opt::ArgList &TCArgs,
753                     const char *LinkingOutput) const override;
754 
755 private:
756   void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
757 };
758 } // end namespace MinGW
759 
760 namespace arm {
761 enum class FloatABI {
762   Invalid,
763   Soft,
764   SoftFP,
765   Hard,
766 };
767 
768 FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args);
769 } // end namespace arm
770 
771 namespace ppc {
772 enum class FloatABI {
773   Invalid,
774   Soft,
775   Hard,
776 };
777 
778 FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
779 } // end namespace ppc
780 
781 namespace sparc {
782 enum class FloatABI {
783   Invalid,
784   Soft,
785   Hard,
786 };
787 
788 FloatABI getSparcFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
789 } // end namespace sparc
790 
791 namespace XCore {
792 // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and
793 // Compile.
794 // We simply use "clang -cc1" for those actions.
795 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
796 public:
Assembler(const ToolChain & TC)797   Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {}
798 
hasIntegratedCPP()799   bool hasIntegratedCPP() const override { return false; }
800   void ConstructJob(Compilation &C, const JobAction &JA,
801                     const InputInfo &Output, const InputInfoList &Inputs,
802                     const llvm::opt::ArgList &TCArgs,
803                     const char *LinkingOutput) const override;
804 };
805 
806 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
807 public:
Linker(const ToolChain & TC)808   Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {}
809 
hasIntegratedCPP()810   bool hasIntegratedCPP() const override { return false; }
isLinkJob()811   bool isLinkJob() const override { return true; }
812   void ConstructJob(Compilation &C, const JobAction &JA,
813                     const InputInfo &Output, const InputInfoList &Inputs,
814                     const llvm::opt::ArgList &TCArgs,
815                     const char *LinkingOutput) const override;
816 };
817 } // end namespace XCore.
818 
819 namespace CrossWindows {
820 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
821 public:
Assembler(const ToolChain & TC)822   Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {}
823 
hasIntegratedCPP()824   bool hasIntegratedCPP() const override { return false; }
825 
826   void ConstructJob(Compilation &C, const JobAction &JA,
827                     const InputInfo &Output, const InputInfoList &Inputs,
828                     const llvm::opt::ArgList &TCArgs,
829                     const char *LinkingOutput) const override;
830 };
831 
832 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
833 public:
Linker(const ToolChain & TC)834   Linker(const ToolChain &TC)
835       : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {}
836 
hasIntegratedCPP()837   bool hasIntegratedCPP() const override { return false; }
isLinkJob()838   bool isLinkJob() 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 } // end namespace CrossWindows
846 
847 /// SHAVE tools -- Directly call moviCompile and moviAsm
848 namespace SHAVE {
849 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool {
850 public:
Compiler(const ToolChain & TC)851   Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {}
852 
hasIntegratedCPP()853   bool hasIntegratedCPP() const override { return true; }
854 
855   void ConstructJob(Compilation &C, const JobAction &JA,
856                     const InputInfo &Output, const InputInfoList &Inputs,
857                     const llvm::opt::ArgList &TCArgs,
858                     const char *LinkingOutput) const override;
859 };
860 
861 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
862 public:
Assembler(const ToolChain & TC)863   Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {}
864 
hasIntegratedCPP()865   bool hasIntegratedCPP() const override { return false; } // not sure.
866 
867   void ConstructJob(Compilation &C, const JobAction &JA,
868                     const InputInfo &Output, const InputInfoList &Inputs,
869                     const llvm::opt::ArgList &TCArgs,
870                     const char *LinkingOutput) const override;
871 };
872 } // end namespace SHAVE
873 
874 /// The Myriad toolchain uses tools that are in two different namespaces.
875 /// The Compiler and Assembler as defined above are in the SHAVE namespace,
876 /// whereas the linker, which accepts code for a mixture of Sparc and SHAVE,
877 /// is in the Myriad namespace.
878 namespace Myriad {
879 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
880 public:
Linker(const ToolChain & TC)881   Linker(const ToolChain &TC) : GnuTool("shave::Linker", "ld", TC) {}
hasIntegratedCPP()882   bool hasIntegratedCPP() const override { return false; }
isLinkJob()883   bool isLinkJob() const override { return true; }
884   void ConstructJob(Compilation &C, const JobAction &JA,
885                     const InputInfo &Output, const InputInfoList &Inputs,
886                     const llvm::opt::ArgList &TCArgs,
887                     const char *LinkingOutput) const override;
888 };
889 } // end namespace Myriad
890 
891 namespace PS4cpu {
892 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
893 public:
Assemble(const ToolChain & TC)894   Assemble(const ToolChain &TC)
895       : Tool("PS4cpu::Assemble", "assembler", TC, RF_Full) {}
896 
hasIntegratedCPP()897   bool hasIntegratedCPP() const override { return false; }
898 
899   void ConstructJob(Compilation &C, const JobAction &JA,
900                     const InputInfo &Output,
901                     const InputInfoList &Inputs,
902                     const llvm::opt::ArgList &TCArgs,
903                     const char *LinkingOutput) const override;
904 };
905 
906 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
907 public:
Link(const ToolChain & TC)908   Link(const ToolChain &TC) : Tool("PS4cpu::Link", "linker", TC, RF_Full) {}
909 
hasIntegratedCPP()910   bool hasIntegratedCPP() const override { return false; }
isLinkJob()911   bool isLinkJob() const override { return true; }
912 
913   void ConstructJob(Compilation &C, const JobAction &JA,
914                     const InputInfo &Output,
915                     const InputInfoList &Inputs,
916                     const llvm::opt::ArgList &TCArgs,
917                     const char *LinkingOutput) const override;
918 };
919 } // end namespace PS4cpu
920 
921 namespace NVPTX {
922 
923 // Run ptxas, the NVPTX assembler.
924 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
925  public:
Assembler(const ToolChain & TC)926    Assembler(const ToolChain &TC)
927        : Tool("NVPTX::Assembler", "ptxas", TC, RF_Full, llvm::sys::WEM_UTF8,
928               "--options-file") {}
929 
hasIntegratedCPP()930    bool hasIntegratedCPP() const override { return false; }
931 
932    void ConstructJob(Compilation &C, const JobAction &JA,
933                      const InputInfo &Output, const InputInfoList &Inputs,
934                      const llvm::opt::ArgList &TCArgs,
935                      const char *LinkingOutput) const override;
936 };
937 
938 // Runs fatbinary, which combines GPU object files ("cubin" files) and/or PTX
939 // assembly into a single output file.
940 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
941  public:
Linker(const ToolChain & TC)942    Linker(const ToolChain &TC)
943        : Tool("NVPTX::Linker", "fatbinary", TC, RF_Full, llvm::sys::WEM_UTF8,
944               "--options-file") {}
945 
hasIntegratedCPP()946    bool hasIntegratedCPP() const override { return false; }
947 
948    void ConstructJob(Compilation &C, const JobAction &JA,
949                      const InputInfo &Output, const InputInfoList &Inputs,
950                      const llvm::opt::ArgList &TCArgs,
951                      const char *LinkingOutput) const override;
952 };
953 
954 }  // end namespace NVPTX
955 
956 } // end namespace tools
957 } // end namespace driver
958 } // end namespace clang
959 
960 #endif // LLVM_CLANG_LIB_DRIVER_TOOLS_H
961