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