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
 205 namespace darwin {
 206   llvm::Triple::ArchType getArchTypeForDarwinArchName(StringRef Str);
 207
 208   class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
 209     virtual void anchor();
 210   protected:
 211     void AddDarwinArch(const llvm::opt::ArgList &Args,
 212                        llvm::opt::ArgStringList &CmdArgs) const;
 213
 214     const toolchains::Darwin &getDarwinToolChain() const {
 215       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
 216     }
 217
 218   public:
 219     DarwinTool(const char *Name, const char *ShortName,
 220                const ToolChain &TC) : Tool(Name, ShortName, TC) {}
 221   };
 222
 223   class LLVM_LIBRARY_VISIBILITY Assemble : public DarwinTool  {
 224   public:
 225     Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble",
 226                                                "assembler", TC) {}
 227
 228     virtual bool hasIntegratedCPP() const { return false; }
 229
 230     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 231                               const InputInfo &Output,
 232                               const InputInfoList &Inputs,
 233                               const llvm::opt::ArgList &TCArgs,
 234                               const char *LinkingOutput) const;
 235   };
 236
 237   class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
 238     bool NeedsTempPath(const InputInfoList &Inputs) const;
 239     void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
 240                      llvm::opt::ArgStringList &CmdArgs,
 241                      const InputInfoList &Inputs) const;
 242
 243   public:
 244     Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
 245
 246     virtual bool hasIntegratedCPP() const { return false; }
 247     virtual bool isLinkJob() const { return true; }
 248
 249     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 250                               const InputInfo &Output,
 251                               const InputInfoList &Inputs,
 252                               const llvm::opt::ArgList &TCArgs,
 253                               const char *LinkingOutput) const;
 254   };
 255
 256   class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
 257   public:
 258     Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
 259
 260     virtual bool hasIntegratedCPP() const { return false; }
 261
 262     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 263                               const InputInfo &Output,
 264                               const InputInfoList &Inputs,
 265                               const llvm::opt::ArgList &TCArgs,
 266                               const char *LinkingOutput) const;
 267   };
 268
 269   class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
 270   public:
 271     Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
 272                                                "dsymutil", TC) {}
 273
 274     virtual bool hasIntegratedCPP() const { return false; }
 275     virtual bool isDsymutilJob() const { return true; }
 276
 277     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 278                               const InputInfo &Output,
 279                               const InputInfoList &Inputs,
 280                               const llvm::opt::ArgList &TCArgs,
 281                               const char *LinkingOutput) const;
 282   };
 283
 284   class LLVM_LIBRARY_VISIBILITY VerifyDebug : public DarwinTool  {
 285   public:
 286     VerifyDebug(const ToolChain &TC) : DarwinTool("darwin::VerifyDebug",
 287                                                   "dwarfdump", TC) {}
 288
 289     virtual bool hasIntegratedCPP() const { return false; }
 290
 291     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 292                               const InputInfo &Output,
 293                               const InputInfoList &Inputs,
 294                               const llvm::opt::ArgList &TCArgs,
 295                               const char *LinkingOutput) const;
 296   };
 297
 298 }
 299
 300   /// openbsd -- Directly call GNU Binutils assembler and linker
 301 namespace openbsd {
 302   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 303   public:
 304     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
 305                                          TC) {}
 306
 307     virtual bool hasIntegratedCPP() const { return false; }
 308
 309     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 310                               const InputInfo &Output,
 311                               const InputInfoList &Inputs,
 312                               const llvm::opt::ArgList &TCArgs,
 313                               const char *LinkingOutput) const;
 314   };
 315   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 316   public:
 317     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
 318
 319     virtual bool hasIntegratedCPP() const { return false; }
 320     virtual bool isLinkJob() const { return true; }
 321
 322     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 323                               const InputInfo &Output,
 324                               const InputInfoList &Inputs,
 325                               const llvm::opt::ArgList &TCArgs,
 326                               const char *LinkingOutput) const;
 327   };
 328 } // end namespace openbsd
 329
 330   /// bitrig -- Directly call GNU Binutils assembler and linker
 331 namespace bitrig {
 332   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 333   public:
 334     Assemble(const ToolChain &TC) : Tool("bitrig::Assemble", "assembler",
 335                                          TC) {}
 336
 337     virtual bool hasIntegratedCPP() const { return false; }
 338
 339     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 340                               const InputInfo &Output,
 341                               const InputInfoList &Inputs,
 342                               const llvm::opt::ArgList &TCArgs,
 343                               const char *LinkingOutput) const;
 344   };
 345   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 346   public:
 347     Link(const ToolChain &TC) : Tool("bitrig::Link", "linker", TC) {}
 348
 349     virtual bool hasIntegratedCPP() const { return false; }
 350     virtual bool isLinkJob() const { return true; }
 351
 352     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 353                               const InputInfo &Output,
 354                               const InputInfoList &Inputs,
 355                               const llvm::opt::ArgList &TCArgs,
 356                               const char *LinkingOutput) const;
 357   };
 358 } // end namespace bitrig
 359
 360   /// freebsd -- Directly call GNU Binutils assembler and linker
 361 namespace freebsd {
 362   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 363   public:
 364     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
 365                                          TC) {}
 366
 367     virtual bool hasIntegratedCPP() const { return false; }
 368
 369     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 370                               const InputInfo &Output,
 371                               const InputInfoList &Inputs,
 372                               const llvm::opt::ArgList &TCArgs,
 373                               const char *LinkingOutput) const;
 374   };
 375   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 376   public:
 377     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
 378
 379     virtual bool hasIntegratedCPP() const { return false; }
 380     virtual bool isLinkJob() const { return true; }
 381
 382     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 383                               const InputInfo &Output,
 384                               const InputInfoList &Inputs,
 385                               const llvm::opt::ArgList &TCArgs,
 386                               const char *LinkingOutput) const;
 387   };
 388 } // end namespace freebsd
 389
 390   /// netbsd -- Directly call GNU Binutils assembler and linker
 391 namespace netbsd {
 392   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 393
 394   public:
 395     Assemble(const ToolChain &TC)
 396       : Tool("netbsd::Assemble", "assembler", TC) {}
 397
 398     virtual bool hasIntegratedCPP() const { return false; }
 399
 400     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 401                               const InputInfo &Output,
 402                               const InputInfoList &Inputs,
 403                               const llvm::opt::ArgList &TCArgs,
 404                               const char *LinkingOutput) const;
 405   };
 406   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 407
 408   public:
 409     Link(const ToolChain &TC)
 410       : Tool("netbsd::Link", "linker", TC) {}
 411
 412     virtual bool hasIntegratedCPP() const { return false; }
 413     virtual bool isLinkJob() const { return true; }
 414
 415     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 416                               const InputInfo &Output,
 417                               const InputInfoList &Inputs,
 418                               const llvm::opt::ArgList &TCArgs,
 419                               const char *LinkingOutput) const;
 420   };
 421 } // end namespace netbsd
 422
 423   /// Directly call GNU Binutils' assembler and linker.
 424 namespace gnutools {
 425   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 426   public:
 427     Assemble(const ToolChain &TC) : Tool("GNU::Assemble", "assembler", TC) {}
 428
 429     virtual bool hasIntegratedCPP() const { return false; }
 430
 431     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 432                               const InputInfo &Output,
 433                               const InputInfoList &Inputs,
 434                               const llvm::opt::ArgList &TCArgs,
 435                               const char *LinkingOutput) const;
 436   };
 437   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 438   public:
 439     Link(const ToolChain &TC) : Tool("GNU::Link", "linker", TC) {}
 440
 441     virtual bool hasIntegratedCPP() const { return false; }
 442     virtual bool isLinkJob() const { return true; }
 443
 444     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 445                               const InputInfo &Output,
 446                               const InputInfoList &Inputs,
 447                               const llvm::opt::ArgList &TCArgs,
 448                               const char *LinkingOutput) const;
 449   };
 450 }
 451   /// minix -- Directly call GNU Binutils assembler and linker
 452 namespace minix {
 453   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 454   public:
 455     Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
 456                                          TC) {}
 457
 458     virtual bool hasIntegratedCPP() const { return false; }
 459
 460     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 461                               const InputInfo &Output,
 462                               const InputInfoList &Inputs,
 463                               const llvm::opt::ArgList &TCArgs,
 464                               const char *LinkingOutput) const;
 465   };
 466   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 467   public:
 468     Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
 469
 470     virtual bool hasIntegratedCPP() const { return false; }
 471     virtual bool isLinkJob() const { return true; }
 472
 473     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 474                               const InputInfo &Output,
 475                               const InputInfoList &Inputs,
 476                               const llvm::opt::ArgList &TCArgs,
 477                               const char *LinkingOutput) const;
 478   };
 479 } // end namespace minix
 480
 481   /// solaris -- Directly call Solaris assembler and linker
 482 namespace solaris {
 483   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 484   public:
 485     Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler",
 486                                          TC) {}
 487
 488     virtual bool hasIntegratedCPP() const { return false; }
 489
 490     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 491                               const InputInfo &Output,
 492                               const InputInfoList &Inputs,
 493                               const llvm::opt::ArgList &TCArgs,
 494                               const char *LinkingOutput) const;
 495   };
 496   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 497   public:
 498     Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {}
 499
 500     virtual bool hasIntegratedCPP() const { return false; }
 501     virtual bool isLinkJob() const { return true; }
 502
 503     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 504                               const InputInfo &Output,
 505                               const InputInfoList &Inputs,
 506                               const llvm::opt::ArgList &TCArgs,
 507                               const char *LinkingOutput) const;
 508   };
 509 } // end namespace solaris
 510
 511   /// auroraux -- Directly call GNU Binutils assembler and linker
 512 namespace auroraux {
 513   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 514   public:
 515     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
 516                                          TC) {}
 517
 518     virtual bool hasIntegratedCPP() const { return false; }
 519
 520     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 521                               const InputInfo &Output,
 522                               const InputInfoList &Inputs,
 523                               const llvm::opt::ArgList &TCArgs,
 524                               const char *LinkingOutput) const;
 525   };
 526   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 527   public:
 528     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
 529
 530     virtual bool hasIntegratedCPP() const { return false; }
 531     virtual bool isLinkJob() const { return true; }
 532
 533     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 534                               const InputInfo &Output,
 535                               const InputInfoList &Inputs,
 536                               const llvm::opt::ArgList &TCArgs,
 537                               const char *LinkingOutput) const;
 538   };
 539 } // end namespace auroraux
 540
 541   /// dragonfly -- Directly call GNU Binutils assembler and linker
 542 namespace dragonfly {
 543   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 544   public:
 545     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
 546                                          TC) {}
 547
 548     virtual bool hasIntegratedCPP() const { return false; }
 549
 550     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 551                               const InputInfo &Output,
 552                               const InputInfoList &Inputs,
 553                               const llvm::opt::ArgList &TCArgs,
 554                               const char *LinkingOutput) const;
 555   };
 556   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 557   public:
 558     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
 559
 560     virtual bool hasIntegratedCPP() const { return false; }
 561     virtual bool isLinkJob() const { return true; }
 562
 563     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 564                               const InputInfo &Output,
 565                               const InputInfoList &Inputs,
 566                               const llvm::opt::ArgList &TCArgs,
 567                               const char *LinkingOutput) const;
 568   };
 569 } // end namespace dragonfly
 570
 571   /// Visual studio tools.
 572 namespace visualstudio {
 573   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 574   public:
 575     Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC) {}
 576
 577     virtual bool hasIntegratedCPP() const { return false; }
 578     virtual bool isLinkJob() const { return true; }
 579
 580     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 581                               const InputInfo &Output,
 582                               const InputInfoList &Inputs,
 583                               const llvm::opt::ArgList &TCArgs,
 584                               const char *LinkingOutput) const;
 585   };
 586
 587   class LLVM_LIBRARY_VISIBILITY Compile : public Tool {
 588   public:
 589     Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC) {}
 590
 591     virtual bool hasIntegratedAssembler() const { return true; }
 592     virtual bool hasIntegratedCPP() const { return true; }
 593     virtual bool isLinkJob() const { return false; }
 594
 595     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 596                               const InputInfo &Output,
 597                               const InputInfoList &Inputs,
 598                               const llvm::opt::ArgList &TCArgs,
 599                               const char *LinkingOutput) const;
 600
 601     Command *GetCommand(Compilation &C, const JobAction &JA,
 602                         const InputInfo &Output,
 603                         const InputInfoList &Inputs,
 604                         const llvm::opt::ArgList &TCArgs,
 605                         const char *LinkingOutput) const;
 606   };
 607 } // end namespace visualstudio
 608
 609 namespace arm {
 610   StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
 611                          const llvm::Triple &Triple);
 612 }
 613 namespace XCore {
 614   // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
 615   // We simply use "clang -cc1" for those actions.
 616   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
 617   public:
 618     Assemble(const ToolChain &TC) : Tool("XCore::Assemble",
 619       "XCore-as", TC) {}
 620
 621     virtual bool hasIntegratedCPP() const { return false; }
 622     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 623                               const InputInfo &Output,
 624                               const InputInfoList &Inputs,
 625                               const llvm::opt::ArgList &TCArgs,
 626                               const char *LinkingOutput) const;
 627   };
 628
 629   class LLVM_LIBRARY_VISIBILITY Link : public Tool {
 630   public:
 631     Link(const ToolChain &TC) : Tool("XCore::Link",
 632       "XCore-ld", TC) {}
 633
 634     virtual bool hasIntegratedCPP() const { return false; }
 635     virtual bool isLinkJob() const { return true; }
 636     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 637                               const InputInfo &Output,
 638                               const InputInfoList &Inputs,
 639                               const llvm::opt::ArgList &TCArgs,
 640                               const char *LinkingOutput) const;
 641   };
 642 } // end namespace XCore.
 643
 644
 645 } // end namespace toolchains
 646 } // end namespace driver
 647 } // end namespace clang
 648
 649 #endif // CLANG_LIB_DRIVER_TOOLS_H_