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 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 Assemble : public Common  {
 167   public:
 168     Assemble(const ToolChain &TC) : Common("gcc::Assemble",
 169                                            "assembler (via gcc)", TC) {}
 170
 171     virtual bool hasIntegratedCPP() const { return false; }
 172
 173     virtual void RenderExtraToolArgs(const JobAction &JA,
 174                                      llvm::opt::ArgStringList &CmdArgs) const;
 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     virtual bool hasIntegratedCPP() const { return false; }
 183     virtual bool isLinkJob() const { return true; }
 184
 185     virtual void RenderExtraToolArgs(const JobAction &JA,
 186                                      llvm::opt::ArgStringList &CmdArgs) const;
 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 Tool {
 194   public:
 195     Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
 196       "hexagon-as", TC) {}
 197
 198     virtual bool hasIntegratedCPP() const { return false; }
 199
 200     virtual void RenderExtraToolArgs(const JobAction &JA,
 201                                      llvm::opt::ArgStringList &CmdArgs) const;
 202     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 203                               const InputInfo &Output,
 204                               const InputInfoList &Inputs,
 205                               const llvm::opt::ArgList &TCArgs,
 206                               const char *LinkingOutput) const;
 207   };
 208
 209   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 210   public:
 211     Link(const ToolChain &TC) : Tool("hexagon::Link",
 212       "hexagon-ld", TC) {}
 213
 214     virtual bool hasIntegratedCPP() const { return false; }
 215     virtual bool isLinkJob() const { return true; }
 216
 217     virtual void RenderExtraToolArgs(const JobAction &JA,
 218                                      llvm::opt::ArgStringList &CmdArgs) const;
 219     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 220                               const InputInfo &Output,
 221                               const InputInfoList &Inputs,
 222                               const llvm::opt::ArgList &TCArgs,
 223                               const char *LinkingOutput) const;
 224   };
 225 } // end namespace hexagon.
 226
 227
 228 namespace darwin {
 229   llvm::Triple::ArchType getArchTypeForDarwinArchName(StringRef Str);
 230
 231   class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
 232     virtual void anchor();
 233   protected:
 234     void AddDarwinArch(const llvm::opt::ArgList &Args,
 235                        llvm::opt::ArgStringList &CmdArgs) const;
 236
 237     const toolchains::Darwin &getDarwinToolChain() const {
 238       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
 239     }
 240
 241   public:
 242     DarwinTool(const char *Name, const char *ShortName,
 243                const ToolChain &TC) : Tool(Name, ShortName, TC) {}
 244   };
 245
 246   class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
 247   public:
 248     Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
 249                                                "assembler", TC) {}
 250
 251     virtual bool hasIntegratedCPP() const { return false; }
 252
 253     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 254                               const InputInfo &Output,
 255                               const InputInfoList &Inputs,
 256                               const llvm::opt::ArgList &TCArgs,
 257                               const char *LinkingOutput) const;
 258   };
 259
 260   class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
 261     bool NeedsTempPath(const InputInfoList &Inputs) const;
 262     void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
 263                      llvm::opt::ArgStringList &CmdArgs,
 264                      const InputInfoList &Inputs) const;
 265
 266   public:
 267     Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
 268
 269     virtual bool hasIntegratedCPP() const { return false; }
 270     virtual bool isLinkJob() const { return true; }
 271
 272     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 273                               const InputInfo &Output,
 274                               const InputInfoList &Inputs,
 275                               const llvm::opt::ArgList &TCArgs,
 276                               const char *LinkingOutput) const;
 277   };
 278
 279   class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
 280   public:
 281     Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
 282
 283     virtual bool hasIntegratedCPP() const { return false; }
 284
 285     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 286                               const InputInfo &Output,
 287                               const InputInfoList &Inputs,
 288                               const llvm::opt::ArgList &TCArgs,
 289                               const char *LinkingOutput) const;
 290   };
 291
 292   class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
 293   public:
 294     Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
 295                                                "dsymutil", TC) {}
 296
 297     virtual bool hasIntegratedCPP() const { return false; }
 298     virtual bool isDsymutilJob() const { return true; }
 299
 300     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 301                               const InputInfo &Output,
 302                               const InputInfoList &Inputs,
 303                               const llvm::opt::ArgList &TCArgs,
 304                               const char *LinkingOutput) const;
 305   };
 306
 307   class LLVM_LIBRARY_VISIBILITY VerifyDebug : public DarwinTool  {
 308   public:
 309     VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
 310                                                   "dwarfdump", TC) {}
 311
 312     virtual bool hasIntegratedCPP() const { return false; }
 313
 314     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 315                               const InputInfo &Output,
 316                               const InputInfoList &Inputs,
 317                               const llvm::opt::ArgList &TCArgs,
 318                               const char *LinkingOutput) const;
 319   };
 320
 321 }
 322
 323   /// openbsd -- Directly call GNU Binutils assembler and linker
 324 namespace openbsd {
 325   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 326   public:
 327     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
 328                                          TC) {}
 329
 330     virtual bool hasIntegratedCPP() const { return false; }
 331
 332     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 333                               const InputInfo &Output,
 334                               const InputInfoList &Inputs,
 335                               const llvm::opt::ArgList &TCArgs,
 336                               const char *LinkingOutput) const;
 337   };
 338   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 339   public:
 340     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
 341
 342     virtual bool hasIntegratedCPP() const { return false; }
 343     virtual bool isLinkJob() const { return true; }
 344
 345     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 346                               const InputInfo &Output,
 347                               const InputInfoList &Inputs,
 348                               const llvm::opt::ArgList &TCArgs,
 349                               const char *LinkingOutput) const;
 350   };
 351 } // end namespace openbsd
 352
 353   /// bitrig -- Directly call GNU Binutils assembler and linker
 354 namespace bitrig {
 355   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 356   public:
 357     Assemble(const ToolChain &TC) : Tool("bitrig::Assemble", "assembler",
 358                                          TC) {}
 359
 360     virtual bool hasIntegratedCPP() const { return false; }
 361
 362     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 363                               const InputInfo &Output,
 364                               const InputInfoList &Inputs,
 365                               const llvm::opt::ArgList &TCArgs,
 366                               const char *LinkingOutput) const;
 367   };
 368   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 369   public:
 370     Link(const ToolChain &TC) : Tool("bitrig::Link", "linker", TC) {}
 371
 372     virtual bool hasIntegratedCPP() const { return false; }
 373     virtual bool isLinkJob() const { return true; }
 374
 375     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 376                               const InputInfo &Output,
 377                               const InputInfoList &Inputs,
 378                               const llvm::opt::ArgList &TCArgs,
 379                               const char *LinkingOutput) const;
 380   };
 381 } // end namespace bitrig
 382
 383   /// freebsd -- Directly call GNU Binutils assembler and linker
 384 namespace freebsd {
 385   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 386   public:
 387     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
 388                                          TC) {}
 389
 390     virtual bool hasIntegratedCPP() const { return false; }
 391
 392     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 393                               const InputInfo &Output,
 394                               const InputInfoList &Inputs,
 395                               const llvm::opt::ArgList &TCArgs,
 396                               const char *LinkingOutput) const;
 397   };
 398   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 399   public:
 400     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
 401
 402     virtual bool hasIntegratedCPP() const { return false; }
 403     virtual bool isLinkJob() const { return true; }
 404
 405     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 406                               const InputInfo &Output,
 407                               const InputInfoList &Inputs,
 408                               const llvm::opt::ArgList &TCArgs,
 409                               const char *LinkingOutput) const;
 410   };
 411 } // end namespace freebsd
 412
 413   /// netbsd -- Directly call GNU Binutils assembler and linker
 414 namespace netbsd {
 415   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 416
 417   public:
 418     Assemble(const ToolChain &TC)
 419       : Tool("netbsd::Assemble", "assembler", TC) {}
 420
 421     virtual bool hasIntegratedCPP() const { return false; }
 422
 423     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 424                               const InputInfo &Output,
 425                               const InputInfoList &Inputs,
 426                               const llvm::opt::ArgList &TCArgs,
 427                               const char *LinkingOutput) const;
 428   };
 429   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 430
 431   public:
 432     Link(const ToolChain &TC)
 433       : Tool("netbsd::Link", "linker", TC) {}
 434
 435     virtual bool hasIntegratedCPP() const { return false; }
 436     virtual bool isLinkJob() const { return true; }
 437
 438     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 439                               const InputInfo &Output,
 440                               const InputInfoList &Inputs,
 441                               const llvm::opt::ArgList &TCArgs,
 442                               const char *LinkingOutput) const;
 443   };
 444 } // end namespace netbsd
 445
 446   /// Directly call GNU Binutils' assembler and linker.
 447 namespace gnutools {
 448   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 449   public:
 450     Assemble(const ToolChain &TC) : Tool("GNU::Assemble", "assembler", TC) {}
 451
 452     virtual bool hasIntegratedCPP() const { return false; }
 453
 454     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 455                               const InputInfo &Output,
 456                               const InputInfoList &Inputs,
 457                               const llvm::opt::ArgList &TCArgs,
 458                               const char *LinkingOutput) const;
 459   };
 460   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 461   public:
 462     Link(const ToolChain &TC) : Tool("GNU::Link", "linker", TC) {}
 463
 464     virtual bool hasIntegratedCPP() const { return false; }
 465     virtual bool isLinkJob() const { return true; }
 466
 467     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 468                               const InputInfo &Output,
 469                               const InputInfoList &Inputs,
 470                               const llvm::opt::ArgList &TCArgs,
 471                               const char *LinkingOutput) const;
 472   };
 473 }
 474   /// minix -- Directly call GNU Binutils assembler and linker
 475 namespace minix {
 476   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 477   public:
 478     Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
 479                                          TC) {}
 480
 481     virtual bool hasIntegratedCPP() const { return false; }
 482
 483     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 484                               const InputInfo &Output,
 485                               const InputInfoList &Inputs,
 486                               const llvm::opt::ArgList &TCArgs,
 487                               const char *LinkingOutput) const;
 488   };
 489   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 490   public:
 491     Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
 492
 493     virtual bool hasIntegratedCPP() const { return false; }
 494     virtual bool isLinkJob() const { return true; }
 495
 496     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 497                               const InputInfo &Output,
 498                               const InputInfoList &Inputs,
 499                               const llvm::opt::ArgList &TCArgs,
 500                               const char *LinkingOutput) const;
 501   };
 502 } // end namespace minix
 503
 504   /// solaris -- Directly call Solaris assembler and linker
 505 namespace solaris {
 506   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 507   public:
 508     Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
 509                                          TC) {}
 510
 511     virtual bool hasIntegratedCPP() const { return false; }
 512
 513     virtual 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;
 518   };
 519   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 520   public:
 521     Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
 522
 523     virtual bool hasIntegratedCPP() const { return false; }
 524     virtual bool isLinkJob() const { return true; }
 525
 526     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 527                               const InputInfo &Output,
 528                               const InputInfoList &Inputs,
 529                               const llvm::opt::ArgList &TCArgs,
 530                               const char *LinkingOutput) const;
 531   };
 532 } // end namespace solaris
 533
 534   /// auroraux -- Directly call GNU Binutils assembler and linker
 535 namespace auroraux {
 536   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 537   public:
 538     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
 539                                          TC) {}
 540
 541     virtual bool hasIntegratedCPP() const { return false; }
 542
 543     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 544                               const InputInfo &Output,
 545                               const InputInfoList &Inputs,
 546                               const llvm::opt::ArgList &TCArgs,
 547                               const char *LinkingOutput) const;
 548   };
 549   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 550   public:
 551     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
 552
 553     virtual bool hasIntegratedCPP() const { return false; }
 554     virtual bool isLinkJob() const { return true; }
 555
 556     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 557                               const InputInfo &Output,
 558                               const InputInfoList &Inputs,
 559                               const llvm::opt::ArgList &TCArgs,
 560                               const char *LinkingOutput) const;
 561   };
 562 } // end namespace auroraux
 563
 564   /// dragonfly -- Directly call GNU Binutils assembler and linker
 565 namespace dragonfly {
 566   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 567   public:
 568     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
 569                                          TC) {}
 570
 571     virtual bool hasIntegratedCPP() const { return false; }
 572
 573     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 574                               const InputInfo &Output,
 575                               const InputInfoList &Inputs,
 576                               const llvm::opt::ArgList &TCArgs,
 577                               const char *LinkingOutput) const;
 578   };
 579   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 580   public:
 581     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
 582
 583     virtual bool hasIntegratedCPP() const { return false; }
 584     virtual bool isLinkJob() const { return true; }
 585
 586     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 587                               const InputInfo &Output,
 588                               const InputInfoList &Inputs,
 589                               const llvm::opt::ArgList &TCArgs,
 590                               const char *LinkingOutput) const;
 591   };
 592 } // end namespace dragonfly
 593
 594   /// Visual studio tools.
 595 namespace visualstudio {
 596   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 597   public:
 598     Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
 599
 600     virtual bool hasIntegratedCPP() const { return false; }
 601     virtual bool isLinkJob() const { return true; }
 602
 603     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 604                               const InputInfo &Output,
 605                               const InputInfoList &Inputs,
 606                               const llvm::opt::ArgList &TCArgs,
 607                               const char *LinkingOutput) const;
 608   };
 609
 610   class LLVM_LIBRARY_VISIBILITY Compile : public Tool {
 611   public:
 612     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC) {}
 613
 614     virtual bool hasIntegratedAssembler() const { return true; }
 615     virtual bool hasIntegratedCPP() const { return true; }
 616     virtual bool isLinkJob() const { return false; }
 617
 618     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 619                               const InputInfo &Output,
 620                               const InputInfoList &Inputs,
 621                               const llvm::opt::ArgList &TCArgs,
 622                               const char *LinkingOutput) const;
 623
 624     Command *GetCommand(Compilation &C, const JobAction &JA,
 625                         const InputInfo &Output,
 626                         const InputInfoList &Inputs,
 627                         const llvm::opt::ArgList &TCArgs,
 628                         const char *LinkingOutput) const;
 629   };
 630 } // end namespace visualstudio
 631
 632 namespace XCore {
 633   // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 634   // We simply use "clang -cc1" for those actions.
 635   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 636   public:
 637     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
 638       "XCore-as", TC) {}
 639
 640     virtual bool hasIntegratedCPP() const { return false; }
 641     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 642                               const InputInfo &Output,
 643                               const InputInfoList &Inputs,
 644                               const llvm::opt::ArgList &TCArgs,
 645                               const char *LinkingOutput) const;
 646   };
 647
 648   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 649   public:
 650     Link(const ToolChain &TC) : Tool("XCore::Link",
 651       "XCore-ld", TC) {}
 652
 653     virtual bool hasIntegratedCPP() const { return false; }
 654     virtual bool isLinkJob() const { return true; }
 655     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 656                               const InputInfo &Output,
 657                               const InputInfoList &Inputs,
 658                               const llvm::opt::ArgList &TCArgs,
 659                               const char *LinkingOutput) const;
 660   };
 661 } // end namespace XCore.
 662
 663
 664 } // end namespace toolchains
 665 } // end namespace driver
 666 } // end namespace clang
 667
 668 #endif // CLANG_LIB_DRIVER_TOOLS_H_