granicus.if.org Git - clang/blob - lib/Driver/Tools.h

   1 //===--- Tools.h - Tool Implementations -------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef CLANG_LIB_DRIVER_TOOLS_H_
  11 #define CLANG_LIB_DRIVER_TOOLS_H_
  12
  13 #include "clang/Driver/Tool.h"
  14 #include "clang/Driver/Types.h"
  15 #include "clang/Driver/Util.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/Option/Option.h"
  18 #include "llvm/Support/Compiler.h"
  19
  20 namespace clang {
  21   class ObjCRuntime;
  22
  23 namespace driver {
  24   class Command;
  25   class Driver;
  26
  27 namespace toolchains {
  28   class MachO;
  29 }
  30
  31 namespace tools {
  32 using llvm::opt::ArgStringList;
  33
  34   /// \brief Clang compiler tool.
  35   class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
  36   public:
  37     static const char *getBaseInputName(const llvm::opt::ArgList &Args,
  38                                         const InputInfoList &Inputs);
  39     static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
  40                                         const InputInfoList &Inputs);
  41     static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
  42                                              const InputInfoList &Inputs);
  43
  44   private:
  45     void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
  46                                  const Driver &D,
  47                                  const llvm::opt::ArgList &Args,
  48                                  llvm::opt::ArgStringList &CmdArgs,
  49                                  const InputInfo &Output,
  50                                  const InputInfoList &Inputs) const;
  51
  52     void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
  53                               llvm::opt::ArgStringList &CmdArgs) const;
  54     void AddARMTargetArgs(const llvm::opt::ArgList &Args,
  55                           llvm::opt::ArgStringList &CmdArgs,
  56                           bool KernelOrKext) const;
  57     void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
  58                            llvm::opt::ArgStringList &CmdArgs) const;
  59     void AddR600TargetArgs(const llvm::opt::ArgList &Args,
  60                            llvm::opt::ArgStringList &CmdArgs) const;
  61     void AddSparcTargetArgs(const llvm::opt::ArgList &Args,
  62                             llvm::opt::ArgStringList &CmdArgs) const;
  63     void AddSystemZTargetArgs(const llvm::opt::ArgList &Args,
  64                               llvm::opt::ArgStringList &CmdArgs) const;
  65     void AddX86TargetArgs(const llvm::opt::ArgList &Args,
  66                           llvm::opt::ArgStringList &CmdArgs) const;
  67     void AddHexagonTargetArgs(const llvm::opt::ArgList &Args,
  68                               llvm::opt::ArgStringList &CmdArgs) const;
  69
  70     enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
  71
  72     ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
  73                                    llvm::opt::ArgStringList &cmdArgs,
  74                                    RewriteKind rewrite) const;
  75
  76     void AddClangCLArgs(const llvm::opt::ArgList &Args,
  77                         llvm::opt::ArgStringList &CmdArgs) const;
  78
  79   public:
  80     Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
  81
  82     virtual bool hasGoodDiagnostics() const { return true; }
  83     virtual bool hasIntegratedAssembler() const { return true; }
  84     virtual bool hasIntegratedCPP() const { return true; }
  85
  86     virtual void ConstructJob(Compilation &C, const JobAction &JA,
  87                               const InputInfo &Output,
  88                               const InputInfoList &Inputs,
  89                               const llvm::opt::ArgList &TCArgs,
  90                               const char *LinkingOutput) const;
  91   };
  92
  93   /// \brief Clang integrated assembler tool.
  94   class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
  95   public:
  96     ClangAs(const ToolChain &TC) : Tool("clang::as",
  97                                         "clang integrated assembler", TC) {}
  98
  99     virtual bool hasGoodDiagnostics() const { return true; }
 100     virtual bool hasIntegratedAssembler() const { return false; }
 101     virtual bool hasIntegratedCPP() const { return false; }
 102
 103     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 104                               const InputInfo &Output,
 105                               const InputInfoList &Inputs,
 106                               const llvm::opt::ArgList &TCArgs,
 107                               const char *LinkingOutput) const;
 108   };
 109
 110   /// gcc - Generic GCC tool implementations.
 111 namespace gcc {
 112   class LLVM_LIBRARY_VISIBILITY Common : public Tool {
 113   public:
 114     Common(const char *Name, const char *ShortName,
 115            const ToolChain &TC) : Tool(Name, ShortName, TC) {}
 116
 117     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 118                               const InputInfo &Output,
 119                               const InputInfoList &Inputs,
 120                               const llvm::opt::ArgList &TCArgs,
 121                               const char *LinkingOutput) const;
 122
 123     /// RenderExtraToolArgs - Render any arguments necessary to force
 124     /// the particular tool mode.
 125     virtual void
 126         RenderExtraToolArgs(const JobAction &JA,
 127                             llvm::opt::ArgStringList &CmdArgs) const = 0;
 128   };
 129
 130   class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
 131   public:
 132     Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
 133                                              "gcc preprocessor", TC) {}
 134
 135     virtual bool hasGoodDiagnostics() const { return true; }
 136     virtual bool hasIntegratedCPP() const { return false; }
 137
 138     virtual void RenderExtraToolArgs(const JobAction &JA,
 139                                      llvm::opt::ArgStringList &CmdArgs) const;
 140   };
 141
 142   class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
 143   public:
 144     Compile(const ToolChain &TC) : Common("gcc::Compile",
 145                                           "gcc frontend", TC) {}
 146
 147     virtual bool hasGoodDiagnostics() const { return true; }
 148     virtual bool hasIntegratedCPP() const { return true; }
 149
 150     virtual void RenderExtraToolArgs(const JobAction &JA,
 151                                      llvm::opt::ArgStringList &CmdArgs) const;
 152   };
 153
 154   class LLVM_LIBRARY_VISIBILITY Link : public Common  {
 155   public:
 156     Link(const ToolChain &TC) : Common("gcc::Link",
 157                                        "linker (via gcc)", TC) {}
 158
 159     virtual bool hasIntegratedCPP() const { return false; }
 160     virtual bool isLinkJob() const { return true; }
 161
 162     virtual void RenderExtraToolArgs(const JobAction &JA,
 163                                      llvm::opt::ArgStringList &CmdArgs) const;
 164   };
 165 } // end namespace gcc
 166
 167 namespace hexagon {
 168   // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 169   // We simply use "clang -cc1" for those actions.
 170   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 171   public:
 172     Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
 173       "hexagon-as", TC) {}
 174
 175     virtual bool hasIntegratedCPP() const { return false; }
 176
 177     virtual void RenderExtraToolArgs(const JobAction &JA,
 178                                      llvm::opt::ArgStringList &CmdArgs) const;
 179     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 180                               const InputInfo &Output,
 181                               const InputInfoList &Inputs,
 182                               const llvm::opt::ArgList &TCArgs,
 183                               const char *LinkingOutput) const;
 184   };
 185
 186   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 187   public:
 188     Link(const ToolChain &TC) : Tool("hexagon::Link",
 189       "hexagon-ld", TC) {}
 190
 191     virtual bool hasIntegratedCPP() const { return false; }
 192     virtual bool isLinkJob() const { return true; }
 193
 194     virtual void RenderExtraToolArgs(const JobAction &JA,
 195                                      llvm::opt::ArgStringList &CmdArgs) const;
 196     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 197                               const InputInfo &Output,
 198                               const InputInfoList &Inputs,
 199                               const llvm::opt::ArgList &TCArgs,
 200                               const char *LinkingOutput) const;
 201   };
 202 } // end namespace hexagon.
 203
 204 namespace arm {
 205   StringRef getARMTargetCPU(const llvm::opt::ArgList &Args,
 206                             const llvm::Triple &Triple);
 207   const char* getARMCPUForMArch(const llvm::opt::ArgList &Args,
 208                                 const llvm::Triple &Triple);
 209   const char* getLLVMArchSuffixForARM(StringRef CPU);
 210 }
 211
 212 namespace darwin {
 213   llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
 214   void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
 215
 216   class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
 217     virtual void anchor();
 218   protected:
 219     void AddMachOArch(const llvm::opt::ArgList &Args,
 220                        llvm::opt::ArgStringList &CmdArgs) const;
 221
 222     const toolchains::MachO &getMachOToolChain() const {
 223       return reinterpret_cast<const toolchains::MachO&>(getToolChain());
 224     }
 225
 226   public:
 227     MachOTool(const char *Name, const char *ShortName,
 228                const ToolChain &TC) : Tool(Name, ShortName, TC) {}
 229   };
 230
 231   class LLVM_LIBRARY_VISIBILITY Assemble : public MachOTool  {
 232   public:
 233     Assemble(const ToolChain &TC) : MachOTool("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 llvm::opt::ArgList &TCArgs,
 242                               const char *LinkingOutput) const;
 243   };
 244
 245   class LLVM_LIBRARY_VISIBILITY Link : public MachOTool  {
 246     bool NeedsTempPath(const InputInfoList &Inputs) const;
 247     void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
 248                      llvm::opt::ArgStringList &CmdArgs,
 249                      const InputInfoList &Inputs) const;
 250
 251   public:
 252     Link(const ToolChain &TC) : MachOTool("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 llvm::opt::ArgList &TCArgs,
 261                               const char *LinkingOutput) const;
 262   };
 263
 264   class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool  {
 265   public:
 266     Lipo(const ToolChain &TC) : MachOTool("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 llvm::opt::ArgList &TCArgs,
 274                               const char *LinkingOutput) const;
 275   };
 276
 277   class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool  {
 278   public:
 279     Dsymutil(const ToolChain &TC) : MachOTool("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 llvm::opt::ArgList &TCArgs,
 289                               const char *LinkingOutput) const;
 290   };
 291
 292   class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool  {
 293   public:
 294     VerifyDebug(const ToolChain &TC) : MachOTool("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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::ArgList &TCArgs,
 592                               const char *LinkingOutput) const;
 593   };
 594
 595   class LLVM_LIBRARY_VISIBILITY Compile : public Tool {
 596   public:
 597     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC) {}
 598
 599     virtual bool hasIntegratedAssembler() const { return true; }
 600     virtual bool hasIntegratedCPP() const { return true; }
 601     virtual bool isLinkJob() const { return false; }
 602
 603     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 604                               const InputInfo &Output,
 605                               const InputInfoList &Inputs,
 606                               const llvm::opt::ArgList &TCArgs,
 607                               const char *LinkingOutput) const;
 608
 609     Command *GetCommand(Compilation &C, const JobAction &JA,
 610                         const InputInfo &Output,
 611                         const InputInfoList &Inputs,
 612                         const llvm::opt::ArgList &TCArgs,
 613                         const char *LinkingOutput) const;
 614   };
 615 } // end namespace visualstudio
 616
 617 namespace arm {
 618   StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
 619                          const llvm::Triple &Triple);
 620 }
 621 namespace XCore {
 622   // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 623   // We simply use "clang -cc1" for those actions.
 624   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 625   public:
 626     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
 627       "XCore-as", TC) {}
 628
 629     virtual bool hasIntegratedCPP() const { return false; }
 630     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 631                               const InputInfo &Output,
 632                               const InputInfoList &Inputs,
 633                               const llvm::opt::ArgList &TCArgs,
 634                               const char *LinkingOutput) const;
 635   };
 636
 637   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 638   public:
 639     Link(const ToolChain &TC) : Tool("XCore::Link",
 640       "XCore-ld", TC) {}
 641
 642     virtual bool hasIntegratedCPP() const { return false; }
 643     virtual bool isLinkJob() const { return true; }
 644     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 645                               const InputInfo &Output,
 646                               const InputInfoList &Inputs,
 647                               const llvm::opt::ArgList &TCArgs,
 648                               const char *LinkingOutput) const;
 649   };
 650 } // end namespace XCore.
 651
 652
 653 } // end namespace toolchains
 654 } // end namespace driver
 655 } // end namespace clang
 656
 657 #endif // CLANG_LIB_DRIVER_TOOLS_H_