granicus.if.org Git - clang/blob - lib/Driver/Tools.h

   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.
 109   Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {}
 110
 111   bool hasGoodDiagnostics() const override { return true; }
 112   bool hasIntegratedAssembler() const override { return true; }
 113   bool hasIntegratedCPP() const override { return true; }
 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:
 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;
 129   bool hasGoodDiagnostics() const override { return true; }
 130   bool hasIntegratedAssembler() const override { return false; }
 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:
 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:
 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.
 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:
 173   Preprocessor(const ToolChain &TC)
 174       : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
 175
 176   bool hasGoodDiagnostics() const override { return true; }
 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:
 185   Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
 186
 187   bool hasGoodDiagnostics() const override { return true; }
 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:
 196   Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
 197
 198   bool hasIntegratedCPP() const override { return false; }
 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:
 212   Assembler(const ToolChain &TC)
 213       : GnuTool("hexagon::Assembler", "hexagon-as", TC) {}
 214
 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:
 227   Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {}
 228
 229   bool hasIntegratedCPP() const override { return false; }
 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:
 245   Linker(const ToolChain &TC) : GnuTool("amdgpu::Linker", "ld.lld", TC) {}
 246   bool isLinkJob() const override { return true; }
 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:
 319   Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {}
 320
 321   bool hasIntegratedCPP() const override { return false; }
 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
 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 = "@")
 352       : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
 353              ResponseFlag) {}
 354 };
 355
 356 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
 357 public:
 358   Assembler(const ToolChain &TC)
 359       : MachOTool("darwin::Assembler", "assembler", TC) {}
 360
 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:
 376   Linker(const ToolChain &TC)
 377       : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
 378                   llvm::sys::WEM_UTF8, "-filelist") {}
 379
 380   bool hasIntegratedCPP() const override { return false; }
 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:
 391   Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
 392
 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:
 403   Dsymutil(const ToolChain &TC)
 404       : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
 405
 406   bool hasIntegratedCPP() const override { return false; }
 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:
 417   VerifyDebug(const ToolChain &TC)
 418       : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
 419
 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:
 433   Assembler(const ToolChain &TC)
 434       : GnuTool("openbsd::Assembler", "assembler", TC) {}
 435
 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:
 446   Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {}
 447
 448   bool hasIntegratedCPP() const override { return false; }
 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:
 462   Assembler(const ToolChain &TC)
 463       : GnuTool("bitrig::Assembler", "assembler", TC) {}
 464
 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:
 475   Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {}
 476
 477   bool hasIntegratedCPP() const override { return false; }
 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:
 491   Assembler(const ToolChain &TC)
 492       : GnuTool("freebsd::Assembler", "assembler", TC) {}
 493
 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:
 504   Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {}
 505
 506   bool hasIntegratedCPP() const override { return false; }
 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:
 520   Assembler(const ToolChain &TC)
 521       : GnuTool("netbsd::Assembler", "assembler", TC) {}
 522
 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:
 533   Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {}
 534
 535   bool hasIntegratedCPP() const override { return false; }
 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:
 549   Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {}
 550
 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:
 561   Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {}
 562
 563   bool hasIntegratedCPP() const override { return false; }
 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:
 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:
 586   Linker(const ToolChain &TC) : GnuTool("NaCl::Linker", "linker", TC) {}
 587
 588   bool hasIntegratedCPP() const override { return false; }
 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:
 602   Assembler(const ToolChain &TC)
 603       : GnuTool("minix::Assembler", "assembler", TC) {}
 604
 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:
 615   Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {}
 616
 617   bool hasIntegratedCPP() const override { return false; }
 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:
 631   Assembler(const ToolChain &TC)
 632       : Tool("solaris::Assembler", "assembler", TC) {}
 633
 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:
 644   Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {}
 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 } // 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:
 660   Assembler(const ToolChain &TC)
 661       : GnuTool("dragonfly::Assembler", "assembler", TC) {}
 662
 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:
 673   Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {}
 674
 675   bool hasIntegratedCPP() const override { return false; }
 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:
 693   Linker(const ToolChain &TC)
 694       : Tool("visualstudio::Linker", "linker", TC, RF_Full,
 695              llvm::sys::WEM_UTF16) {}
 696
 697   bool hasIntegratedCPP() const override { return false; }
 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:
 708   Compiler(const ToolChain &TC)
 709       : Tool("visualstudio::Compiler", "compiler", TC, RF_Full,
 710              llvm::sys::WEM_UTF16) {}
 711
 712   bool hasIntegratedAssembler() const override { return true; }
 713   bool hasIntegratedCPP() const override { return true; }
 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:
 733   Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
 734
 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:
 745   Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
 746
 747   bool hasIntegratedCPP() const override { return false; }
 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:
 797   Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {}
 798
 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:
 808   Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {}
 809
 810   bool hasIntegratedCPP() const override { return false; }
 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:
 822   Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {}
 823
 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:
 834   Linker(const ToolChain &TC)
 835       : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {}
 836
 837   bool hasIntegratedCPP() const override { return false; }
 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:
 851   Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {}
 852
 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:
 863   Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {}
 864
 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:
 881   Linker(const ToolChain &TC) : GnuTool("shave::Linker", "ld", TC) {}
 882   bool hasIntegratedCPP() const override { return false; }
 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:
 894   Assemble(const ToolChain &TC)
 895       : Tool("PS4cpu::Assemble", "assembler", TC, RF_Full) {}
 896
 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:
 908   Link(const ToolChain &TC) : Tool("PS4cpu::Link", "linker", TC, RF_Full) {}
 909
 910   bool hasIntegratedCPP() const override { return false; }
 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:
 926    Assembler(const ToolChain &TC)
 927        : Tool("NVPTX::Assembler", "ptxas", TC, RF_Full, llvm::sys::WEM_UTF8,
 928               "--options-file") {}
 929
 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:
 942    Linker(const ToolChain &TC)
 943        : Tool("NVPTX::Linker", "fatbinary", TC, RF_Full, llvm::sys::WEM_UTF8,
 944               "--options-file") {}
 945
 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