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
  17 #include "llvm/ADT/Triple.h"
  18 #include "llvm/Support/Compiler.h"
  19
  20 namespace clang {
  21 namespace driver {
  22   class Driver;
  23
  24 namespace toolchains {
  25   class Darwin;
  26 }
  27
  28 namespace tools {
  29
  30   /// \brief Clang compiler tool.
  31   class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
  32     void AddPreprocessingOptions(const Driver &D,
  33                                  const ArgList &Args,
  34                                  ArgStringList &CmdArgs,
  35                                  const InputInfo &Output,
  36                                  const InputInfoList &Inputs) const;
  37
  38     void AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
  39                           bool KernelOrKext) const;
  40     void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
  41     void AddSparcTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
  42     void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
  43
  44   public:
  45     Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
  46
  47     virtual bool hasGoodDiagnostics() const { return true; }
  48     virtual bool hasIntegratedAssembler() const { return true; }
  49     virtual bool hasIntegratedCPP() const { return true; }
  50
  51     virtual void ConstructJob(Compilation &C, const JobAction &JA,
  52                               const InputInfo &Output,
  53                               const InputInfoList &Inputs,
  54                               const ArgList &TCArgs,
  55                               const char *LinkingOutput) const;
  56   };
  57
  58   /// \brief Clang integrated assembler tool.
  59   class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
  60   public:
  61     ClangAs(const ToolChain &TC) : Tool("clang::as",
  62                                         "clang integrated assembler", TC) {}
  63
  64     virtual bool hasGoodDiagnostics() const { return true; }
  65     virtual bool hasIntegratedAssembler() const { return false; }
  66     virtual bool hasIntegratedCPP() const { return false; }
  67
  68     virtual void ConstructJob(Compilation &C, const JobAction &JA,
  69                               const InputInfo &Output,
  70                               const InputInfoList &Inputs,
  71                               const ArgList &TCArgs,
  72                               const char *LinkingOutput) const;
  73   };
  74
  75   /// gcc - Generic GCC tool implementations.
  76 namespace gcc {
  77   class LLVM_LIBRARY_VISIBILITY Common : public Tool {
  78   public:
  79     Common(const char *Name, const char *ShortName,
  80            const ToolChain &TC) : Tool(Name, ShortName, TC) {}
  81
  82     virtual void ConstructJob(Compilation &C, const JobAction &JA,
  83                               const InputInfo &Output,
  84                               const InputInfoList &Inputs,
  85                               const ArgList &TCArgs,
  86                               const char *LinkingOutput) const;
  87
  88     /// RenderExtraToolArgs - Render any arguments necessary to force
  89     /// the particular tool mode.
  90     virtual void RenderExtraToolArgs(const JobAction &JA,
  91                                      ArgStringList &CmdArgs) const = 0;
  92   };
  93
  94
  95   class LLVM_LIBRARY_VISIBILITY Preprocess : public Common {
  96   public:
  97     Preprocess(const ToolChain &TC) : Common("gcc::Preprocess",
  98                                              "gcc preprocessor", TC) {}
  99
 100     virtual bool hasGoodDiagnostics() const { return true; }
 101     virtual bool hasIntegratedCPP() const { return false; }
 102
 103     virtual void RenderExtraToolArgs(const JobAction &JA,
 104                                      ArgStringList &CmdArgs) const;
 105   };
 106
 107   class LLVM_LIBRARY_VISIBILITY Precompile : public Common  {
 108   public:
 109     Precompile(const ToolChain &TC) : Common("gcc::Precompile",
 110                                              "gcc precompile", TC) {}
 111
 112     virtual bool hasGoodDiagnostics() const { return true; }
 113     virtual bool hasIntegratedCPP() const { return true; }
 114
 115     virtual void RenderExtraToolArgs(const JobAction &JA,
 116                                      ArgStringList &CmdArgs) const;
 117   };
 118
 119   class LLVM_LIBRARY_VISIBILITY Compile : public Common  {
 120   public:
 121     Compile(const ToolChain &TC) : Common("gcc::Compile",
 122                                           "gcc frontend", TC) {}
 123
 124     virtual bool hasGoodDiagnostics() const { return true; }
 125     virtual bool hasIntegratedCPP() const { return true; }
 126
 127     virtual void RenderExtraToolArgs(const JobAction &JA,
 128                                      ArgStringList &CmdArgs) const;
 129   };
 130
 131   class LLVM_LIBRARY_VISIBILITY Assemble : public Common  {
 132   public:
 133     Assemble(const ToolChain &TC) : Common("gcc::Assemble",
 134                                            "assembler (via gcc)", TC) {}
 135
 136     virtual bool hasIntegratedCPP() const { return false; }
 137
 138     virtual void RenderExtraToolArgs(const JobAction &JA,
 139                                      ArgStringList &CmdArgs) const;
 140   };
 141
 142   class LLVM_LIBRARY_VISIBILITY Link : public Common  {
 143   public:
 144     Link(const ToolChain &TC) : Common("gcc::Link",
 145                                        "linker (via gcc)", TC) {}
 146
 147     virtual bool hasIntegratedCPP() const { return false; }
 148
 149     virtual void RenderExtraToolArgs(const JobAction &JA,
 150                                      ArgStringList &CmdArgs) const;
 151   };
 152 } // end namespace gcc
 153
 154 namespace darwin {
 155   class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
 156   protected:
 157     void AddDarwinArch(const ArgList &Args, ArgStringList &CmdArgs) const;
 158
 159     const toolchains::Darwin &getDarwinToolChain() const {
 160       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
 161     }
 162
 163   public:
 164     DarwinTool(const char *Name, const char *ShortName,
 165                const ToolChain &TC) : Tool(Name, ShortName, TC) {}
 166   };
 167
 168   class LLVM_LIBRARY_VISIBILITY CC1 : public DarwinTool  {
 169   public:
 170     static const char *getBaseInputName(const ArgList &Args,
 171                                  const InputInfoList &Input);
 172     static const char *getBaseInputStem(const ArgList &Args,
 173                                  const InputInfoList &Input);
 174     static const char *getDependencyFileName(const ArgList &Args,
 175                                              const InputInfoList &Inputs);
 176
 177   protected:
 178     const char *getCC1Name(types::ID Type) const;
 179
 180     void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
 181     void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
 182                            const InputInfoList &Inputs,
 183                            const ArgStringList &OutputArgs) const;
 184     void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
 185                            const InputInfoList &Inputs,
 186                            const ArgStringList &OutputArgs) const;
 187     void AddCPPUniqueOptionsArgs(const ArgList &Args,
 188                                  ArgStringList &CmdArgs,
 189                                  const InputInfoList &Inputs) const;
 190     void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
 191
 192   public:
 193     CC1(const char *Name, const char *ShortName,
 194         const ToolChain &TC) : DarwinTool(Name, ShortName, TC) {}
 195
 196     virtual bool hasGoodDiagnostics() const { return true; }
 197     virtual bool hasIntegratedCPP() const { return true; }
 198   };
 199
 200   class LLVM_LIBRARY_VISIBILITY Preprocess : public CC1  {
 201   public:
 202     Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess",
 203                                           "gcc preprocessor", TC) {}
 204
 205     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 206                               const InputInfo &Output,
 207                               const InputInfoList &Inputs,
 208                               const ArgList &TCArgs,
 209                               const char *LinkingOutput) const;
 210   };
 211
 212   class LLVM_LIBRARY_VISIBILITY Compile : public CC1  {
 213   public:
 214     Compile(const ToolChain &TC) : CC1("darwin::Compile", "gcc frontend", TC) {}
 215
 216     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 217                               const InputInfo &Output,
 218                               const InputInfoList &Inputs,
 219                               const ArgList &TCArgs,
 220                               const char *LinkingOutput) const;
 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 ArgList &TCArgs,
 234                               const char *LinkingOutput) const;
 235   };
 236
 237   class LLVM_LIBRARY_VISIBILITY Link : public DarwinTool  {
 238     void AddLinkArgs(Compilation &C, const ArgList &Args,
 239                      ArgStringList &CmdArgs) const;
 240
 241   public:
 242     Link(const ToolChain &TC) : DarwinTool("darwin::Link", "linker", TC) {}
 243
 244     virtual bool hasIntegratedCPP() const { return false; }
 245
 246     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 247                               const InputInfo &Output,
 248                               const InputInfoList &Inputs,
 249                               const ArgList &TCArgs,
 250                               const char *LinkingOutput) const;
 251   };
 252
 253   class LLVM_LIBRARY_VISIBILITY Lipo : public DarwinTool  {
 254   public:
 255     Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", "lipo", TC) {}
 256
 257     virtual bool hasIntegratedCPP() const { return false; }
 258
 259     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 260                               const InputInfo &Output,
 261                               const InputInfoList &Inputs,
 262                               const ArgList &TCArgs,
 263                               const char *LinkingOutput) const;
 264   };
 265
 266   class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
 267   public:
 268     Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
 269                                                "dsymutil", TC) {}
 270
 271     virtual bool hasIntegratedCPP() const { return false; }
 272
 273     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 274                               const InputInfo &Output,
 275                               const InputInfoList &Inputs,
 276                               const ArgList &TCArgs,
 277                               const char *LinkingOutput) const;
 278   };
 279 }
 280
 281   /// openbsd -- Directly call GNU Binutils assembler and linker
 282 namespace openbsd {
 283   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 284   public:
 285     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
 286                                          TC) {}
 287
 288     virtual bool hasIntegratedCPP() const { return false; }
 289
 290     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 291                               const InputInfo &Output,
 292                               const InputInfoList &Inputs,
 293                               const ArgList &TCArgs,
 294                               const char *LinkingOutput) const;
 295   };
 296   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 297   public:
 298     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
 299
 300     virtual bool hasIntegratedCPP() const { return false; }
 301
 302     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 303                               const InputInfo &Output,
 304                               const InputInfoList &Inputs,
 305                               const ArgList &TCArgs,
 306                               const char *LinkingOutput) const;
 307   };
 308 } // end namespace openbsd
 309
 310   /// freebsd -- Directly call GNU Binutils assembler and linker
 311 namespace freebsd {
 312   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 313   public:
 314     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
 315                                          TC) {}
 316
 317     virtual bool hasIntegratedCPP() const { return false; }
 318
 319     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 320                               const InputInfo &Output,
 321                               const InputInfoList &Inputs,
 322                               const ArgList &TCArgs,
 323                               const char *LinkingOutput) const;
 324   };
 325   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 326   public:
 327     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
 328
 329     virtual bool hasIntegratedCPP() const { return false; }
 330
 331     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 332                               const InputInfo &Output,
 333                               const InputInfoList &Inputs,
 334                               const ArgList &TCArgs,
 335                               const char *LinkingOutput) const;
 336   };
 337 } // end namespace freebsd
 338
 339   /// netbsd -- Directly call GNU Binutils assembler and linker
 340 namespace netbsd {
 341   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 342   private:
 343     const llvm::Triple ToolTriple;
 344
 345   public:
 346     Assemble(const ToolChain &TC, const llvm::Triple &ToolTriple)
 347       : Tool("netbsd::Assemble", "assembler", TC), ToolTriple(ToolTriple) {}
 348
 349     virtual bool hasIntegratedCPP() const { return false; }
 350
 351     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 352                               const InputInfo &Output,
 353                               const InputInfoList &Inputs,
 354                               const ArgList &TCArgs,
 355                               const char *LinkingOutput) const;
 356   };
 357   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 358   private:
 359     const llvm::Triple ToolTriple;
 360
 361   public:
 362     Link(const ToolChain &TC, const llvm::Triple &ToolTriple)
 363       : Tool("netbsd::Link", "linker", TC), ToolTriple(ToolTriple) {}
 364
 365     virtual bool hasIntegratedCPP() const { return false; }
 366
 367     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 368                               const InputInfo &Output,
 369                               const InputInfoList &Inputs,
 370                               const ArgList &TCArgs,
 371                               const char *LinkingOutput) const;
 372   };
 373 } // end namespace netbsd
 374
 375   /// linux -- Directly call GNU Binutils assembler and linker
 376 namespace linuxtools {
 377   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 378   public:
 379     Assemble(const ToolChain &TC) : Tool("linux::Assemble", "assembler",
 380                                          TC) {}
 381
 382     virtual bool hasIntegratedCPP() const { return false; }
 383
 384     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 385                               const InputInfo &Output,
 386                               const InputInfoList &Inputs,
 387                               const ArgList &TCArgs,
 388                               const char *LinkingOutput) const;
 389   };
 390   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 391   public:
 392     Link(const ToolChain &TC) : Tool("linux::Link", "linker", TC) {}
 393
 394     virtual bool hasIntegratedCPP() const { return false; }
 395
 396     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 397                               const InputInfo &Output,
 398                               const InputInfoList &Inputs,
 399                               const ArgList &TCArgs,
 400                               const char *LinkingOutput) const;
 401   };
 402 }
 403   /// minix -- Directly call GNU Binutils assembler and linker
 404 namespace minix {
 405   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 406   public:
 407     Assemble(const ToolChain &TC) : Tool("minix::Assemble", "assembler",
 408                                          TC) {}
 409
 410     virtual bool hasIntegratedCPP() const { return false; }
 411
 412     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 413                               const InputInfo &Output,
 414                               const InputInfoList &Inputs,
 415                               const ArgList &TCArgs,
 416                               const char *LinkingOutput) const;
 417   };
 418   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 419   public:
 420     Link(const ToolChain &TC) : Tool("minix::Link", "linker", TC) {}
 421
 422     virtual bool hasIntegratedCPP() const { return false; }
 423
 424     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 425                               const InputInfo &Output,
 426                               const InputInfoList &Inputs,
 427                               const ArgList &TCArgs,
 428                               const char *LinkingOutput) const;
 429   };
 430 } // end namespace minix
 431
 432   /// auroraux -- Directly call GNU Binutils assembler and linker
 433 namespace auroraux {
 434   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 435   public:
 436     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
 437                                          TC) {}
 438
 439     virtual bool hasIntegratedCPP() const { return false; }
 440
 441     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 442                               const InputInfo &Output,
 443                               const InputInfoList &Inputs,
 444                               const ArgList &TCArgs,
 445                               const char *LinkingOutput) const;
 446   };
 447   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 448   public:
 449     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
 450
 451     virtual bool hasIntegratedCPP() const { return false; }
 452
 453     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 454                               const InputInfo &Output,
 455                               const InputInfoList &Inputs,
 456                               const ArgList &TCArgs,
 457                               const char *LinkingOutput) const;
 458   };
 459 } // end namespace auroraux
 460
 461   /// dragonfly -- Directly call GNU Binutils assembler and linker
 462 namespace dragonfly {
 463   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 464   public:
 465     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
 466                                          TC) {}
 467
 468     virtual bool hasIntegratedCPP() const { return false; }
 469
 470     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 471                               const InputInfo &Output,
 472                               const InputInfoList &Inputs,
 473                               const ArgList &TCArgs,
 474                               const char *LinkingOutput) const;
 475   };
 476   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 477   public:
 478     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
 479
 480     virtual bool hasIntegratedCPP() const { return false; }
 481
 482     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 483                               const InputInfo &Output,
 484                               const InputInfoList &Inputs,
 485                               const ArgList &TCArgs,
 486                               const char *LinkingOutput) const;
 487   };
 488 } // end namespace dragonfly
 489
 490   /// Visual studio tools.
 491 namespace visualstudio {
 492   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 493   public:
 494     Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", 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 } // end namespace visualstudio
 505
 506 } // end namespace toolchains
 507 } // end namespace driver
 508 } // end namespace clang
 509
 510 #endif // CLANG_LIB_DRIVER_TOOLS_H_