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   class LLVM_LIBRARY_VISIBILITY Dsymutil : public DarwinTool  {
 293   public:
 294     Dsymutil(const ToolChain &TC) : DarwinTool("darwin::Dsymutil",
 295                                                "dsymutil", TC) {}
 296
 297     virtual bool acceptsPipedInput() const { return false; }
 298     virtual bool canPipeOutput() const { return false; }
 299     virtual bool hasIntegratedCPP() const { return false; }
 300
 301     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 302                               Job &Dest,
 303                               const InputInfo &Output,
 304                               const InputInfoList &Inputs,
 305                               const ArgList &TCArgs,
 306                               const char *LinkingOutput) const;
 307   };
 308 }
 309
 310   /// openbsd -- Directly call GNU Binutils assembler and linker
 311 namespace openbsd {
 312   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 313   public:
 314     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", "assembler",
 315                                          TC) {}
 316
 317     virtual bool acceptsPipedInput() const { return true; }
 318     virtual bool canPipeOutput() const { return true; }
 319     virtual bool hasIntegratedCPP() const { return false; }
 320
 321     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 322                               Job &Dest,
 323                               const InputInfo &Output,
 324                               const InputInfoList &Inputs,
 325                               const ArgList &TCArgs,
 326                               const char *LinkingOutput) const;
 327   };
 328   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 329   public:
 330     Link(const ToolChain &TC) : Tool("openbsd::Link", "linker", TC) {}
 331
 332     virtual bool acceptsPipedInput() const { return true; }
 333     virtual bool canPipeOutput() const { return true; }
 334     virtual bool hasIntegratedCPP() const { return false; }
 335
 336     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 337                               Job &Dest,
 338                               const InputInfo &Output,
 339                               const InputInfoList &Inputs,
 340                               const ArgList &TCArgs,
 341                               const char *LinkingOutput) const;
 342   };
 343 } // end namespace openbsd
 344
 345   /// freebsd -- Directly call GNU Binutils assembler and linker
 346 namespace freebsd {
 347   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 348   public:
 349     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", "assembler",
 350                                          TC) {}
 351
 352     virtual bool acceptsPipedInput() const { return true; }
 353     virtual bool canPipeOutput() const { return true; }
 354     virtual bool hasIntegratedCPP() const { return false; }
 355
 356     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 357                               Job &Dest,
 358                               const InputInfo &Output,
 359                               const InputInfoList &Inputs,
 360                               const ArgList &TCArgs,
 361                               const char *LinkingOutput) const;
 362   };
 363   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 364   public:
 365     Link(const ToolChain &TC) : Tool("freebsd::Link", "linker", TC) {}
 366
 367     virtual bool acceptsPipedInput() const { return true; }
 368     virtual bool canPipeOutput() const { return true; }
 369     virtual bool hasIntegratedCPP() const { return false; }
 370
 371     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 372                               Job &Dest,
 373                               const InputInfo &Output,
 374                               const InputInfoList &Inputs,
 375                               const ArgList &TCArgs,
 376                               const char *LinkingOutput) const;
 377   };
 378 } // end namespace freebsd
 379
 380   /// auroraux -- Directly call GNU Binutils assembler and linker
 381 namespace auroraux {
 382   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 383   public:
 384     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", "assembler",
 385                                          TC) {}
 386
 387     virtual bool acceptsPipedInput() const { return true; }
 388     virtual bool canPipeOutput() const { return true; }
 389     virtual bool hasIntegratedCPP() const { return false; }
 390
 391     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 392                               Job &Dest,
 393                               const InputInfo &Output,
 394                               const InputInfoList &Inputs,
 395                               const ArgList &TCArgs,
 396                               const char *LinkingOutput) const;
 397   };
 398   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 399   public:
 400     Link(const ToolChain &TC) : Tool("auroraux::Link", "linker", TC) {}
 401
 402     virtual bool acceptsPipedInput() const { return true; }
 403     virtual bool canPipeOutput() const { return true; }
 404     virtual bool hasIntegratedCPP() const { return false; }
 405
 406     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 407                               Job &Dest,
 408                               const InputInfo &Output,
 409                               const InputInfoList &Inputs,
 410                               const ArgList &TCArgs,
 411                               const char *LinkingOutput) const;
 412   };
 413 } // end namespace auroraux
 414
 415   /// dragonfly -- Directly call GNU Binutils assembler and linker
 416 namespace dragonfly {
 417   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
 418   public:
 419     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
 420                                          TC) {}
 421
 422     virtual bool acceptsPipedInput() const { return true; }
 423     virtual bool canPipeOutput() const { return true; }
 424     virtual bool hasIntegratedCPP() const { return false; }
 425
 426     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 427                               Job &Dest,
 428                               const InputInfo &Output,
 429                               const InputInfoList &Inputs,
 430                               const ArgList &TCArgs,
 431                               const char *LinkingOutput) const;
 432   };
 433   class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
 434   public:
 435     Link(const ToolChain &TC) : Tool("dragonfly::Link", "linker", TC) {}
 436
 437     virtual bool acceptsPipedInput() const { return true; }
 438     virtual bool canPipeOutput() const { return true; }
 439     virtual bool hasIntegratedCPP() const { return false; }
 440
 441     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 442                               Job &Dest,
 443                               const InputInfo &Output,
 444                               const InputInfoList &Inputs,
 445                               const ArgList &TCArgs,
 446                               const char *LinkingOutput) const;
 447   };
 448 } // end namespace dragonfly
 449
 450 } // end namespace toolchains
 451 } // end namespace driver
 452 } // end namespace clang
 453
 454 #endif // CLANG_LIB_DRIVER_TOOLS_H_