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