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/Driver/Tool.h"
  14 #include "clang/Driver/Types.h"
  15 #include "clang/Driver/Util.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/Option/Option.h"
  18 #include "llvm/Support/Compiler.h"
  19
  20 namespace clang {
  21   class ObjCRuntime;
  22
  23 namespace driver {
  24   class Command;
  25   class Driver;
  26
  27 namespace toolchains {
  28   class MachO;
  29 }
  30
  31 namespace tools {
  32
  33 namespace visualstudio {
  34   class Compile;
  35 }
  36
  37 using llvm::opt::ArgStringList;
  38
  39   /// \brief Clang compiler tool.
  40   class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
  41   public:
  42     static const char *getBaseInputName(const llvm::opt::ArgList &Args,
  43                                         const InputInfoList &Inputs);
  44     static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
  45                                         const InputInfoList &Inputs);
  46     static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
  47                                              const InputInfoList &Inputs);
  48
  49   private:
  50     void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
  51                                  const Driver &D,
  52                                  const llvm::opt::ArgList &Args,
  53                                  llvm::opt::ArgStringList &CmdArgs,
  54                                  const InputInfo &Output,
  55                                  const InputInfoList &Inputs) const;
  56
  57     void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
  58                               llvm::opt::ArgStringList &CmdArgs) const;
  59     void AddARMTargetArgs(const llvm::opt::ArgList &Args,
  60                           llvm::opt::ArgStringList &CmdArgs,
  61                           bool KernelOrKext) const;
  62     void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
  63                             llvm::opt::ArgStringList &CmdArgs) const;
  64     void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
  65                            llvm::opt::ArgStringList &CmdArgs) const;
  66     void AddPPCTargetArgs(const llvm::opt::ArgList &Args,
  67                           llvm::opt::ArgStringList &CmdArgs) const;
  68     void AddR600TargetArgs(const llvm::opt::ArgList &Args,
  69                            llvm::opt::ArgStringList &CmdArgs) const;
  70     void AddSparcTargetArgs(const llvm::opt::ArgList &Args,
  71                             llvm::opt::ArgStringList &CmdArgs) const;
  72     void AddSystemZTargetArgs(const llvm::opt::ArgList &Args,
  73                               llvm::opt::ArgStringList &CmdArgs) const;
  74     void AddX86TargetArgs(const llvm::opt::ArgList &Args,
  75                           llvm::opt::ArgStringList &CmdArgs) const;
  76     void AddHexagonTargetArgs(const llvm::opt::ArgList &Args,
  77                               llvm::opt::ArgStringList &CmdArgs) const;
  78
  79     enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
  80
  81     ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
  82                                    llvm::opt::ArgStringList &cmdArgs,
  83                                    RewriteKind rewrite) const;
  84
  85     void AddClangCLArgs(const llvm::opt::ArgList &Args,
  86                         llvm::opt::ArgStringList &CmdArgs) const;
  87
  88     visualstudio::Compile *getCLFallback() const;
  89
  90     mutable std::unique_ptr<visualstudio::Compile> CLFallback;
  91
  92   public:
  93     Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {}
  94
  95     bool hasGoodDiagnostics() const override { return true; }
  96     bool hasIntegratedAssembler() const override { return true; }
  97     bool hasIntegratedCPP() const override { return true; }
  98     bool canEmitIR() const override { return true; }
  99
 100     void ConstructJob(Compilation &C, const JobAction &JA,
 101                       const InputInfo &Output, const InputInfoList &Inputs,
 102                       const llvm::opt::ArgList &TCArgs,
 103                       const char *LinkingOutput) const override;
 104   };
 105
 106   /// \brief Clang integrated assembler tool.
 107   class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
 108   public:
 109     ClangAs(const ToolChain &TC) : Tool("clang::as",
 110                                         "clang integrated assembler", TC,
 111                                         RF_Full) {}
 112
 113     bool hasGoodDiagnostics() const override { return true; }
 114     bool hasIntegratedAssembler() const override { return false; }
 115     bool hasIntegratedCPP() const override { return false; }
 116
 117     void ConstructJob(Compilation &C, const JobAction &JA,
 118                       const InputInfo &Output, const InputInfoList &Inputs,
 119                       const llvm::opt::ArgList &TCArgs,
 120                       const char *LinkingOutput) const override;
 121   };
 122
 123   /// \brief Base class for all GNU tools that provide the same behavior when
 124   /// it comes to response files support
 125   class GnuTool : public Tool {
 126     virtual void anchor();
 127
 128   public:
 129     GnuTool(const char *Name, const char *ShortName, const ToolChain &TC)
 130         : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {}
 131   };
 132
 133   /// gcc - Generic GCC tool implementations.
 134 namespace gcc {
 135   class LLVM_LIBRARY_VISIBILITY Common : public GnuTool {
 136   public:
 137     Common(const char *Name, const char *ShortName,
 138            const ToolChain &TC) : GnuTool(Name, ShortName, TC) {}
 139
 140     void ConstructJob(Compilation &C, const JobAction &JA,
 141                       const InputInfo &Output,
 142                       const InputInfoList &Inputs,
 143                       const llvm::opt::ArgList &TCArgs,
 144                       const char *LinkingOutput) const override;
 145
 146     /// RenderExtraToolArgs - Render any arguments necessary to force
 147     /// the particular tool mode.
 148     virtual void
 149         RenderExtraToolArgs(const JobAction &JA,
 150                             llvm::opt::ArgStringList &CmdArgs) const = 0;
 151   };
 152
 153   class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
 154   public:
 155     Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
 156                                              "gcc preprocessor", TC) {}
 157
 158     bool hasGoodDiagnostics() const override { return true; }
 159     bool hasIntegratedCPP() const override { return false; }
 160
 161     void RenderExtraToolArgs(const JobAction &JA,
 162                              llvm::opt::ArgStringList &CmdArgs) const override;
 163   };
 164
 165   class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
 166   public:
 167     Compile(const ToolChain &TC) : Common("gcc::Compile",
 168                                           "gcc frontend", TC) {}
 169
 170     bool hasGoodDiagnostics() const override { return true; }
 171     bool hasIntegratedCPP() const override { return true; }
 172
 173     void RenderExtraToolArgs(const JobAction &JA,
 174                              llvm::opt::ArgStringList &CmdArgs) const override;
 175   };
 176
 177   class LLVM_LIBRARY_VISIBILITY Link : public Common  {
 178   public:
 179     Link(const ToolChain &TC) : Common("gcc::Link",
 180                                        "linker (via gcc)", TC) {}
 181
 182     bool hasIntegratedCPP() const override { return false; }
 183     bool isLinkJob() const override { return true; }
 184
 185     void RenderExtraToolArgs(const JobAction &JA,
 186                              llvm::opt::ArgStringList &CmdArgs) const override;
 187   };
 188 } // end namespace gcc
 189
 190 namespace hexagon {
 191   // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 192   // We simply use "clang -cc1" for those actions.
 193   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool {
 194   public:
 195     Assemble(const ToolChain &TC) : GnuTool("hexagon::Assemble",
 196       "hexagon-as", TC) {}
 197
 198     bool hasIntegratedCPP() const override { return false; }
 199
 200     void RenderExtraToolArgs(const JobAction &JA,
 201                              llvm::opt::ArgStringList &CmdArgs) const;
 202     void ConstructJob(Compilation &C, const JobAction &JA,
 203                       const InputInfo &Output, const InputInfoList &Inputs,
 204                       const llvm::opt::ArgList &TCArgs,
 205                       const char *LinkingOutput) const override;
 206   };
 207
 208   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool {
 209   public:
 210     Link(const ToolChain &TC) : GnuTool("hexagon::Link",
 211       "hexagon-ld", TC) {}
 212
 213     bool hasIntegratedCPP() const override { return false; }
 214     bool isLinkJob() const override { return true; }
 215
 216     virtual void RenderExtraToolArgs(const JobAction &JA,
 217                                      llvm::opt::ArgStringList &CmdArgs) const;
 218     void ConstructJob(Compilation &C, const JobAction &JA,
 219                       const InputInfo &Output, const InputInfoList &Inputs,
 220                       const llvm::opt::ArgList &TCArgs,
 221                       const char *LinkingOutput) const override;
 222   };
 223 } // end namespace hexagon.
 224
 225 namespace arm {
 226   StringRef getARMTargetCPU(const llvm::opt::ArgList &Args,
 227                             const llvm::Triple &Triple);
 228   const char* getARMCPUForMArch(const llvm::opt::ArgList &Args,
 229                                 const llvm::Triple &Triple);
 230   const char* getLLVMArchSuffixForARM(StringRef CPU);
 231 }
 232
 233 namespace mips {
 234   void getMipsCPUAndABI(const llvm::opt::ArgList &Args,
 235                         const llvm::Triple &Triple, StringRef &CPUName,
 236                         StringRef &ABIName);
 237   bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
 238   bool isUCLibc(const llvm::opt::ArgList &Args);
 239   bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
 240   bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
 241                      StringRef ABIName);
 242 }
 243
 244 namespace ppc {
 245   bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value);
 246 }
 247
 248 namespace darwin {
 249   llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
 250   void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
 251
 252   class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
 253     virtual void anchor();
 254   protected:
 255     void AddMachOArch(const llvm::opt::ArgList &Args,
 256                        llvm::opt::ArgStringList &CmdArgs) const;
 257
 258     const toolchains::MachO &getMachOToolChain() const {
 259       return reinterpret_cast<const toolchains::MachO&>(getToolChain());
 260     }
 261
 262   public:
 263   MachOTool(
 264       const char *Name, const char *ShortName, const ToolChain &TC,
 265       ResponseFileSupport ResponseSupport = RF_None,
 266       llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
 267       const char *ResponseFlag = "@")
 268       : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
 269              ResponseFlag) {}
 270   };
 271
 272   class LLVM_LIBRARY_VISIBILITY Assemble : public MachOTool  {
 273   public:
 274     Assemble(const ToolChain &TC) : MachOTool("darwin::Assemble",
 275                                               "assembler", TC) {}
 276
 277     bool hasIntegratedCPP() const override { return false; }
 278
 279     void ConstructJob(Compilation &C, const JobAction &JA,
 280                       const InputInfo &Output, const InputInfoList &Inputs,
 281                       const llvm::opt::ArgList &TCArgs,
 282                       const char *LinkingOutput) const override;
 283   };
 284
 285   class LLVM_LIBRARY_VISIBILITY Link : public MachOTool  {
 286     bool NeedsTempPath(const InputInfoList &Inputs) const;
 287     void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
 288                      llvm::opt::ArgStringList &CmdArgs,
 289                      const InputInfoList &Inputs) const;
 290
 291   public:
 292     Link(const ToolChain &TC) : MachOTool("darwin::Link", "linker", TC,
 293                                           RF_FileList, llvm::sys::WEM_UTF8,
 294                                           "-filelist") {}
 295
 296     bool hasIntegratedCPP() const override { return false; }
 297     bool isLinkJob() const override { return true; }
 298
 299     void ConstructJob(Compilation &C, const JobAction &JA,
 300                       const InputInfo &Output, const InputInfoList &Inputs,
 301                       const llvm::opt::ArgList &TCArgs,
 302                       const char *LinkingOutput) const override;
 303   };
 304
 305   class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool  {
 306   public:
 307     Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
 308
 309     bool hasIntegratedCPP() const override { return false; }
 310
 311     void ConstructJob(Compilation &C, const JobAction &JA,
 312                       const InputInfo &Output, const InputInfoList &Inputs,
 313                       const llvm::opt::ArgList &TCArgs,
 314                       const char *LinkingOutput) const override;
 315   };
 316
 317   class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool  {
 318   public:
 319     Dsymutil(const ToolChain &TC) : MachOTool("darwin::Dsymutil",
 320                                               "dsymutil", TC) {}
 321
 322     bool hasIntegratedCPP() const override { return false; }
 323     bool isDsymutilJob() const override { return true; }
 324
 325     void ConstructJob(Compilation &C, const JobAction &JA,
 326                       const InputInfo &Output,
 327                       const InputInfoList &Inputs,
 328                       const llvm::opt::ArgList &TCArgs,
 329                       const char *LinkingOutput) const override;
 330   };
 331
 332   class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool  {
 333   public:
 334     VerifyDebug(const ToolChain &TC) : MachOTool("darwin::VerifyDebug",
 335                                                  "dwarfdump", TC) {}
 336
 337     bool hasIntegratedCPP() const override { return false; }
 338
 339     void ConstructJob(Compilation &C, const JobAction &JA,
 340                       const InputInfo &Output, const InputInfoList &Inputs,
 341                       const llvm::opt::ArgList &TCArgs,
 342                       const char *LinkingOutput) const override;
 343   };
 344
 345 }
 346
 347   /// openbsd -- Directly call GNU Binutils assembler and linker
 348 namespace openbsd {
 349   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 350   public:
 351     Assemble(const ToolChain &TC) : GnuTool("openbsd::Assemble", "assembler",
 352                                          TC) {}
 353
 354     bool hasIntegratedCPP() const override { return false; }
 355
 356     void ConstructJob(Compilation &C, const JobAction &JA,
 357                       const InputInfo &Output,
 358                       const InputInfoList &Inputs,
 359                       const llvm::opt::ArgList &TCArgs,
 360                       const char *LinkingOutput) const override;
 361   };
 362   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 363   public:
 364     Link(const ToolChain &TC) : GnuTool("openbsd::Link", "linker", TC) {}
 365
 366     bool hasIntegratedCPP() const override { return false; }
 367     bool isLinkJob() const override { return true; }
 368
 369     void ConstructJob(Compilation &C, const JobAction &JA,
 370                       const InputInfo &Output, const InputInfoList &Inputs,
 371                       const llvm::opt::ArgList &TCArgs,
 372                       const char *LinkingOutput) const override;
 373   };
 374 } // end namespace openbsd
 375
 376   /// bitrig -- Directly call GNU Binutils assembler and linker
 377 namespace bitrig {
 378   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 379   public:
 380     Assemble(const ToolChain &TC) : GnuTool("bitrig::Assemble", "assembler",
 381                                          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   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 391   public:
 392     Link(const ToolChain &TC) : GnuTool("bitrig::Link", "linker", TC) {}
 393
 394     bool hasIntegratedCPP() const override { return false; }
 395     bool isLinkJob() const override { return true; }
 396
 397     void ConstructJob(Compilation &C, const JobAction &JA,
 398                       const InputInfo &Output, const InputInfoList &Inputs,
 399                       const llvm::opt::ArgList &TCArgs,
 400                       const char *LinkingOutput) const override;
 401   };
 402 } // end namespace bitrig
 403
 404   /// freebsd -- Directly call GNU Binutils assembler and linker
 405 namespace freebsd {
 406   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 407   public:
 408     Assemble(const ToolChain &TC) : GnuTool("freebsd::Assemble", "assembler",
 409                                          TC) {}
 410
 411     bool hasIntegratedCPP() const override { return false; }
 412
 413     void ConstructJob(Compilation &C, const JobAction &JA,
 414                       const InputInfo &Output, const InputInfoList &Inputs,
 415                       const llvm::opt::ArgList &TCArgs,
 416                       const char *LinkingOutput) const override;
 417   };
 418   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 419   public:
 420     Link(const ToolChain &TC) : GnuTool("freebsd::Link", "linker", TC) {}
 421
 422     bool hasIntegratedCPP() const override { return false; }
 423     bool isLinkJob() const override { return true; }
 424
 425     void ConstructJob(Compilation &C, const JobAction &JA,
 426                       const InputInfo &Output, const InputInfoList &Inputs,
 427                       const llvm::opt::ArgList &TCArgs,
 428                       const char *LinkingOutput) const override;
 429   };
 430 } // end namespace freebsd
 431
 432   /// netbsd -- Directly call GNU Binutils assembler and linker
 433 namespace netbsd {
 434   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 435
 436   public:
 437     Assemble(const ToolChain &TC)
 438       : GnuTool("netbsd::Assemble", "assembler", TC) {}
 439
 440     bool hasIntegratedCPP() const override { return false; }
 441
 442     void ConstructJob(Compilation &C, const JobAction &JA,
 443                       const InputInfo &Output, const InputInfoList &Inputs,
 444                       const llvm::opt::ArgList &TCArgs,
 445                       const char *LinkingOutput) const override;
 446   };
 447   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 448
 449   public:
 450     Link(const ToolChain &TC)
 451       : GnuTool("netbsd::Link", "linker", TC) {}
 452
 453     bool hasIntegratedCPP() const override { return false; }
 454     bool isLinkJob() const override { return true; }
 455
 456     void ConstructJob(Compilation &C, const JobAction &JA,
 457                       const InputInfo &Output, const InputInfoList &Inputs,
 458                       const llvm::opt::ArgList &TCArgs,
 459                       const char *LinkingOutput) const override;
 460   };
 461 } // end namespace netbsd
 462
 463   /// Directly call GNU Binutils' assembler and linker.
 464 namespace gnutools {
 465   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 466   public:
 467     Assemble(const ToolChain &TC) : GnuTool("GNU::Assemble", "assembler", TC) {}
 468
 469     bool hasIntegratedCPP() const override { return false; }
 470
 471     void ConstructJob(Compilation &C, const JobAction &JA,
 472                       const InputInfo &Output,
 473                       const InputInfoList &Inputs,
 474                       const llvm::opt::ArgList &TCArgs,
 475                       const char *LinkingOutput) const override;
 476   };
 477   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 478   public:
 479     Link(const ToolChain &TC) : GnuTool("GNU::Link", "linker", TC) {}
 480
 481     bool hasIntegratedCPP() const override { return false; }
 482     bool isLinkJob() const override { return true; }
 483
 484     void ConstructJob(Compilation &C, const JobAction &JA,
 485                       const InputInfo &Output,
 486                       const InputInfoList &Inputs,
 487                       const llvm::opt::ArgList &TCArgs,
 488                       const char *LinkingOutput) const override;
 489   };
 490 }
 491   /// minix -- Directly call GNU Binutils assembler and linker
 492 namespace minix {
 493   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 494   public:
 495     Assemble(const ToolChain &TC) : GnuTool("minix::Assemble", "assembler",
 496                                          TC) {}
 497
 498     bool hasIntegratedCPP() const override { return false; }
 499
 500     void ConstructJob(Compilation &C, const JobAction &JA,
 501                       const InputInfo &Output,
 502                       const InputInfoList &Inputs,
 503                       const llvm::opt::ArgList &TCArgs,
 504                       const char *LinkingOutput) const override;
 505   };
 506   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 507   public:
 508     Link(const ToolChain &TC) : GnuTool("minix::Link", "linker", TC) {}
 509
 510     bool hasIntegratedCPP() const override { return false; }
 511     bool isLinkJob() const override { return true; }
 512
 513     void ConstructJob(Compilation &C, const JobAction &JA,
 514                       const InputInfo &Output,
 515                       const InputInfoList &Inputs,
 516                       const llvm::opt::ArgList &TCArgs,
 517                       const char *LinkingOutput) const override;
 518   };
 519 } // end namespace minix
 520
 521   /// solaris -- Directly call Solaris assembler and linker
 522 namespace solaris {
 523   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 524   public:
 525     Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
 526                                          TC) {}
 527
 528     bool hasIntegratedCPP() const override { return false; }
 529
 530     void ConstructJob(Compilation &C, const JobAction &JA,
 531                       const InputInfo &Output, const InputInfoList &Inputs,
 532                       const llvm::opt::ArgList &TCArgs,
 533                       const char *LinkingOutput) const override;
 534   };
 535   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 536   public:
 537     Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
 538
 539     bool hasIntegratedCPP() const override { return false; }
 540     bool isLinkJob() const override { return true; }
 541
 542     void ConstructJob(Compilation &C, const JobAction &JA,
 543                       const InputInfo &Output, const InputInfoList &Inputs,
 544                       const llvm::opt::ArgList &TCArgs,
 545                       const char *LinkingOutput) const override;
 546   };
 547 } // end namespace solaris
 548
 549   /// dragonfly -- Directly call GNU Binutils assembler and linker
 550 namespace dragonfly {
 551   class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool  {
 552   public:
 553     Assemble(const ToolChain &TC) : GnuTool("dragonfly::Assemble", "assembler",
 554                                          TC) {}
 555
 556     bool hasIntegratedCPP() const override { return false; }
 557
 558     void ConstructJob(Compilation &C, const JobAction &JA,
 559                       const InputInfo &Output, const InputInfoList &Inputs,
 560                       const llvm::opt::ArgList &TCArgs,
 561                       const char *LinkingOutput) const override;
 562   };
 563   class LLVM_LIBRARY_VISIBILITY Link : public GnuTool  {
 564   public:
 565     Link(const ToolChain &TC) : GnuTool("dragonfly::Link", "linker", TC) {}
 566
 567     bool hasIntegratedCPP() const override { return false; }
 568     bool isLinkJob() const override { return true; }
 569
 570     void ConstructJob(Compilation &C, const JobAction &JA,
 571                       const InputInfo &Output,
 572                       const InputInfoList &Inputs,
 573                       const llvm::opt::ArgList &TCArgs,
 574                       const char *LinkingOutput) const override;
 575   };
 576 } // end namespace dragonfly
 577
 578 /// Visual studio tools.
 579 namespace visualstudio {
 580   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 581   public:
 582     Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC,
 583                                      RF_Full, llvm::sys::WEM_UTF16) {}
 584
 585     bool hasIntegratedCPP() const override { return false; }
 586     bool isLinkJob() const override { return true; }
 587
 588     void ConstructJob(Compilation &C, const JobAction &JA,
 589                       const InputInfo &Output, const InputInfoList &Inputs,
 590                       const llvm::opt::ArgList &TCArgs,
 591                       const char *LinkingOutput) const override;
 592   };
 593
 594   class LLVM_LIBRARY_VISIBILITY Compile : public Tool {
 595   public:
 596     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC,
 597                                         RF_Full, llvm::sys::WEM_UTF16) {}
 598
 599     bool hasIntegratedAssembler() const override { return true; }
 600     bool hasIntegratedCPP() const override { return true; }
 601     bool isLinkJob() const override { return false; }
 602
 603     void ConstructJob(Compilation &C, const JobAction &JA,
 604                       const InputInfo &Output, const InputInfoList &Inputs,
 605                       const llvm::opt::ArgList &TCArgs,
 606                       const char *LinkingOutput) const override;
 607
 608     std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA,
 609                                         const InputInfo &Output,
 610                                         const InputInfoList &Inputs,
 611                                         const llvm::opt::ArgList &TCArgs,
 612                                         const char *LinkingOutput) const;
 613   };
 614 } // end namespace visualstudio
 615
 616 namespace arm {
 617   StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
 618                          const llvm::Triple &Triple);
 619 }
 620 namespace XCore {
 621   // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 622   // We simply use "clang -cc1" for those actions.
 623   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 624   public:
 625     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
 626       "XCore-as", TC) {}
 627
 628     bool hasIntegratedCPP() const override { return false; }
 629     void ConstructJob(Compilation &C, const JobAction &JA,
 630                       const InputInfo &Output, const InputInfoList &Inputs,
 631                       const llvm::opt::ArgList &TCArgs,
 632                       const char *LinkingOutput) const override;
 633   };
 634
 635   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 636   public:
 637     Link(const ToolChain &TC) : Tool("XCore::Link",
 638       "XCore-ld", TC) {}
 639
 640     bool hasIntegratedCPP() const override { return false; }
 641     bool isLinkJob() const override { return true; }
 642     void ConstructJob(Compilation &C, const JobAction &JA,
 643                       const InputInfo &Output, const InputInfoList &Inputs,
 644                       const llvm::opt::ArgList &TCArgs,
 645                       const char *LinkingOutput) const override;
 646   };
 647 } // end namespace XCore.
 648
 649 namespace CrossWindows {
 650 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 651 public:
 652   Assemble(const ToolChain &TC) : Tool("CrossWindows::Assemble", "as", TC) { }
 653
 654   bool hasIntegratedCPP() const override { return false; }
 655
 656   void ConstructJob(Compilation &C, const JobAction &JA,
 657                     const InputInfo &Output, const InputInfoList &Inputs,
 658                     const llvm::opt::ArgList &TCArgs,
 659                     const char *LinkingOutput) const override;
 660 };
 661
 662 class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 663 public:
 664   Link(const ToolChain &TC) : Tool("CrossWindows::Link", "ld", TC, RF_Full) {}
 665
 666   bool hasIntegratedCPP() const override { return false; }
 667   bool isLinkJob() const override { return true; }
 668
 669   void ConstructJob(Compilation &C, const JobAction &JA,
 670                     const InputInfo &Output, const InputInfoList &Inputs,
 671                     const llvm::opt::ArgList &TCArgs,
 672                     const char *LinkingOutput) const override;
 673 };
 674 }
 675
 676 } // end namespace toolchains
 677 } // end namespace driver
 678 } // end namespace clang
 679
 680 #endif