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