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