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