contrib/llvm/tools/clang/lib/Driver/Tools.h

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