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