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 Darwin;
  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   std::string 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 getArchTypeForDarwinArchName(StringRef Str);
 214
 215   class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
 216     virtual void anchor();
 217   protected:
 218     void AddDarwinArch(const llvm::opt::ArgList &Args,
 219                        llvm::opt::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 llvm::opt::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 llvm::opt::ArgList &Args,
 247                      llvm::opt::ArgStringList &CmdArgs,
 248                      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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::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 llvm::opt::ArgList &TCArgs,
 591                               const char *LinkingOutput) const;
 592   };
 593
 594   class LLVM_LIBRARY_VISIBILITY Compile : public Tool {
 595   public:
 596     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC) {}
 597
 598     virtual bool hasIntegratedAssembler() const { return true; }
 599     virtual bool hasIntegratedCPP() const { return true; }
 600     virtual bool isLinkJob() const { return false; }
 601
 602     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 603                               const InputInfo &Output,
 604                               const InputInfoList &Inputs,
 605                               const llvm::opt::ArgList &TCArgs,
 606                               const char *LinkingOutput) const;
 607
 608     Command *GetCommand(Compilation &C, const JobAction &JA,
 609                         const InputInfo &Output,
 610                         const InputInfoList &Inputs,
 611                         const llvm::opt::ArgList &TCArgs,
 612                         const char *LinkingOutput) const;
 613   };
 614 } // end namespace visualstudio
 615
 616 namespace arm {
 617   StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
 618                          const llvm::Triple &Triple);
 619 }
 620 namespace XCore {
 621   // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 622   // We simply use "clang -cc1" for those actions.
 623   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 624   public:
 625     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
 626       "XCore-as", TC) {}
 627
 628     virtual bool hasIntegratedCPP() const { return false; }
 629     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 630                               const InputInfo &Output,
 631                               const InputInfoList &Inputs,
 632                               const llvm::opt::ArgList &TCArgs,
 633                               const char *LinkingOutput) const;
 634   };
 635
 636   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 637   public:
 638     Link(const ToolChain &TC) : Tool("XCore::Link",
 639       "XCore-ld", TC) {}
 640
 641     virtual bool hasIntegratedCPP() const { return false; }
 642     virtual bool isLinkJob() const { return true; }
 643     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 644                               const InputInfo &Output,
 645                               const InputInfoList &Inputs,
 646                               const llvm::opt::ArgList &TCArgs,
 647                               const char *LinkingOutput) const;
 648   };
 649 } // end namespace XCore.
 650
 651
 652 } // end namespace toolchains
 653 } // end namespace driver
 654 } // end namespace clang
 655
 656 #endif // CLANG_LIB_DRIVER_TOOLS_H_