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
 282     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 283                               const InputInfo &Output,
 284                               const InputInfoList &Inputs,
 285                               const ArgList &TCArgs,
 286                               const char *LinkingOutput) const;
 287   };
 288
 289   class LLVM_LIBRARY_VISIBILITY VerifyDebug : public DarwinTool  {
 290   public:
 291     VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
 292                                                   "dwarfdump", TC) {}
 293
 294     virtual bool hasIntegratedCPP() const { return false; }
 295
 296     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 297                               const InputInfo &Output,
 298                               const InputInfoList &Inputs,
 299                               const ArgList &TCArgs,
 300                               const char *LinkingOutput) const;
 301   };
 302
 303 }
 304
 305   /// openbsd -- Directly call GNU Binutils assembler and linker
 306 namespace openbsd {
 307   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 308   public:
 309     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
 310                                          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 ArgList &TCArgs,
 318                               const char *LinkingOutput) const;
 319   };
 320   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 321   public:
 322     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
 323
 324     virtual bool hasIntegratedCPP() const { return false; }
 325     virtual bool isLinkJob() const { return true; }
 326
 327     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 328                               const InputInfo &Output,
 329                               const InputInfoList &Inputs,
 330                               const ArgList &TCArgs,
 331                               const char *LinkingOutput) const;
 332   };
 333 } // end namespace openbsd
 334
 335   /// bitrig -- Directly call GNU Binutils assembler and linker
 336 namespace bitrig {
 337   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 338   public:
 339     Assemble(const ToolChain &TC) : Tool("bitrig::Assemble", "assembler",
 340                                          TC) {}
 341
 342     virtual bool hasIntegratedCPP() const { return false; }
 343
 344     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 345                               const InputInfo &Output,
 346                               const InputInfoList &Inputs,
 347                               const ArgList &TCArgs,
 348                               const char *LinkingOutput) const;
 349   };
 350   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 351   public:
 352     Link(const ToolChain &TC) : Tool("bitrig::Link", "linker", TC) {}
 353
 354     virtual bool hasIntegratedCPP() const { return false; }
 355     virtual bool isLinkJob() const { return true; }
 356
 357     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 358                               const InputInfo &Output,
 359                               const InputInfoList &Inputs,
 360                               const ArgList &TCArgs,
 361                               const char *LinkingOutput) const;
 362   };
 363 } // end namespace bitrig
 364
 365   /// freebsd -- Directly call GNU Binutils assembler and linker
 366 namespace freebsd {
 367   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 368   public:
 369     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
 370                                          TC) {}
 371
 372     virtual bool hasIntegratedCPP() const { return false; }
 373
 374     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 375                               const InputInfo &Output,
 376                               const InputInfoList &Inputs,
 377                               const ArgList &TCArgs,
 378                               const char *LinkingOutput) const;
 379   };
 380   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 381   public:
 382     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
 383
 384     virtual bool hasIntegratedCPP() const { return false; }
 385     virtual bool isLinkJob() const { return true; }
 386
 387     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 388                               const InputInfo &Output,
 389                               const InputInfoList &Inputs,
 390                               const ArgList &TCArgs,
 391                               const char *LinkingOutput) const;
 392   };
 393 } // end namespace freebsd
 394
 395   /// netbsd -- Directly call GNU Binutils assembler and linker
 396 namespace netbsd {
 397   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 398
 399   public:
 400     Assemble(const ToolChain &TC)
 401       : Tool("netbsd::Assemble", "assembler", TC) {}
 402
 403     virtual bool hasIntegratedCPP() const { return false; }
 404
 405     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 406                               const InputInfo &Output,
 407                               const InputInfoList &Inputs,
 408                               const ArgList &TCArgs,
 409                               const char *LinkingOutput) const;
 410   };
 411   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 412
 413   public:
 414     Link(const ToolChain &TC)
 415       : Tool("netbsd::Link", "linker", TC) {}
 416
 417     virtual bool hasIntegratedCPP() const { return false; }
 418     virtual bool isLinkJob() const { return true; }
 419
 420     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 421                               const InputInfo &Output,
 422                               const InputInfoList &Inputs,
 423                               const ArgList &TCArgs,
 424                               const char *LinkingOutput) const;
 425   };
 426 } // end namespace netbsd
 427
 428   /// linux -- Directly call GNU Binutils assembler and linker
 429 namespace linuxtools {
 430   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 431   public:
 432     Assemble(const ToolChain &TC) : Tool("linux::Assemble", "assembler",
 433                                          TC) {}
 434
 435     virtual bool hasIntegratedCPP() const { return false; }
 436
 437     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 438                               const InputInfo &Output,
 439                               const InputInfoList &Inputs,
 440                               const ArgList &TCArgs,
 441                               const char *LinkingOutput) const;
 442   };
 443   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 444   public:
 445     Link(const ToolChain &TC) : Tool("linux::Link", "linker", TC) {}
 446
 447     virtual bool hasIntegratedCPP() const { return false; }
 448     virtual bool isLinkJob() const { return true; }
 449
 450     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 451                               const InputInfo &Output,
 452                               const InputInfoList &Inputs,
 453                               const ArgList &TCArgs,
 454                               const char *LinkingOutput) const;
 455   };
 456 }
 457   /// minix -- Directly call GNU Binutils assembler and linker
 458 namespace minix {
 459   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 460   public:
 461     Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
 462                                          TC) {}
 463
 464     virtual bool hasIntegratedCPP() const { return false; }
 465
 466     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 467                               const InputInfo &Output,
 468                               const InputInfoList &Inputs,
 469                               const ArgList &TCArgs,
 470                               const char *LinkingOutput) const;
 471   };
 472   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 473   public:
 474     Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
 475
 476     virtual bool hasIntegratedCPP() const { return false; }
 477     virtual bool isLinkJob() const { return true; }
 478
 479     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 480                               const InputInfo &Output,
 481                               const InputInfoList &Inputs,
 482                               const ArgList &TCArgs,
 483                               const char *LinkingOutput) const;
 484   };
 485 } // end namespace minix
 486
 487   /// solaris -- Directly call Solaris assembler and linker
 488 namespace solaris {
 489   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 490   public:
 491     Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
 492                                          TC) {}
 493
 494     virtual bool hasIntegratedCPP() const { return false; }
 495
 496     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 497                               const InputInfo &Output,
 498                               const InputInfoList &Inputs,
 499                               const ArgList &TCArgs,
 500                               const char *LinkingOutput) const;
 501   };
 502   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 503   public:
 504     Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
 505
 506     virtual bool hasIntegratedCPP() const { return false; }
 507     virtual bool isLinkJob() const { return true; }
 508
 509     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 510                               const InputInfo &Output,
 511                               const InputInfoList &Inputs,
 512                               const ArgList &TCArgs,
 513                               const char *LinkingOutput) const;
 514   };
 515 } // end namespace solaris
 516
 517   /// auroraux -- Directly call GNU Binutils assembler and linker
 518 namespace auroraux {
 519   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 520   public:
 521     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
 522                                          TC) {}
 523
 524     virtual bool hasIntegratedCPP() const { return false; }
 525
 526     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 527                               const InputInfo &Output,
 528                               const InputInfoList &Inputs,
 529                               const ArgList &TCArgs,
 530                               const char *LinkingOutput) const;
 531   };
 532   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 533   public:
 534     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
 535
 536     virtual bool hasIntegratedCPP() const { return false; }
 537     virtual bool isLinkJob() const { return true; }
 538
 539     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 540                               const InputInfo &Output,
 541                               const InputInfoList &Inputs,
 542                               const ArgList &TCArgs,
 543                               const char *LinkingOutput) const;
 544   };
 545 } // end namespace auroraux
 546
 547   /// dragonfly -- Directly call GNU Binutils assembler and linker
 548 namespace dragonfly {
 549   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 550   public:
 551     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
 552                                          TC) {}
 553
 554     virtual bool hasIntegratedCPP() const { return false; }
 555
 556     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 557                               const InputInfo &Output,
 558                               const InputInfoList &Inputs,
 559                               const ArgList &TCArgs,
 560                               const char *LinkingOutput) const;
 561   };
 562   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 563   public:
 564     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
 565
 566     virtual bool hasIntegratedCPP() const { return false; }
 567     virtual bool isLinkJob() const { return true; }
 568
 569     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 570                               const InputInfo &Output,
 571                               const InputInfoList &Inputs,
 572                               const ArgList &TCArgs,
 573                               const char *LinkingOutput) const;
 574   };
 575 } // end namespace dragonfly
 576
 577   /// Visual studio tools.
 578 namespace visualstudio {
 579   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 580   public:
 581     Link(const ToolChain &TC) : Tool("visualstudio::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 ArgList &TCArgs,
 590                               const char *LinkingOutput) const;
 591   };
 592 } // end namespace visualstudio
 593
 594 } // end namespace toolchains
 595 } // end namespace driver
 596 } // end namespace clang
 597
 598 #endif // CLANG_LIB_DRIVER_TOOLS_H_