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