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