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
 134     const toolchains::Darwin &getDarwinToolChain() const {
 135       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
 136     }
 137
 138   public:
 139     DarwinTool(const char *Name, const ToolChain &TC) : Tool(Name, TC) {}
 140   };
 141
 142   class VISIBILITY_HIDDEN CC1 : public DarwinTool  {
 143   public:
 144     static const char *getBaseInputName(const ArgList &Args,
 145                                  const InputInfoList &Input);
 146     static const char *getBaseInputStem(const ArgList &Args,
 147                                  const InputInfoList &Input);
 148     static const char *getDependencyFileName(const ArgList &Args,
 149                                              const InputInfoList &Inputs);
 150
 151   protected:
 152     const char *getCC1Name(types::ID Type) const;
 153
 154     void AddCC1Args(const ArgList &Args, ArgStringList &CmdArgs) const;
 155     void AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
 156                            const InputInfoList &Inputs,
 157                            const ArgStringList &OutputArgs) const;
 158     void AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
 159                            const InputInfoList &Inputs,
 160                            const ArgStringList &OutputArgs) const;
 161     void AddCPPUniqueOptionsArgs(const ArgList &Args,
 162                                  ArgStringList &CmdArgs,
 163                                  const InputInfoList &Inputs) const;
 164     void AddCPPArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
 165
 166   public:
 167     CC1(const char *Name, const ToolChain &TC) : DarwinTool(Name, TC) {}
 168
 169     virtual bool acceptsPipedInput() const { return true; }
 170     virtual bool canPipeOutput() const { return true; }
 171     virtual bool hasIntegratedCPP() const { return true; }
 172   };
 173
 174   class VISIBILITY_HIDDEN Preprocess : public CC1  {
 175   public:
 176     Preprocess(const ToolChain &TC) : CC1("darwin::Preprocess", TC) {}
 177
 178     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 179                               Job &Dest,
 180                               const InputInfo &Output,
 181                               const InputInfoList &Inputs,
 182                               const ArgList &TCArgs,
 183                               const char *LinkingOutput) const;
 184   };
 185
 186   class VISIBILITY_HIDDEN Compile : public CC1  {
 187   public:
 188     Compile(const ToolChain &TC) : CC1("darwin::Compile", TC) {}
 189
 190     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 191                               Job &Dest,
 192                               const InputInfo &Output,
 193                               const InputInfoList &Inputs,
 194                               const ArgList &TCArgs,
 195                               const char *LinkingOutput) const;
 196   };
 197
 198   class VISIBILITY_HIDDEN Assemble : public DarwinTool  {
 199   public:
 200     Assemble(const ToolChain &TC) : DarwinTool("darwin::Assemble", TC) {}
 201
 202     virtual bool acceptsPipedInput() const { return true; }
 203     virtual bool canPipeOutput() const { return false; }
 204     virtual bool hasIntegratedCPP() const { return false; }
 205
 206     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 207                               Job &Dest,
 208                               const InputInfo &Output,
 209                               const InputInfoList &Inputs,
 210                               const ArgList &TCArgs,
 211                               const char *LinkingOutput) const;
 212   };
 213
 214   class VISIBILITY_HIDDEN Link : public DarwinTool  {
 215     void AddLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
 216
 217   public:
 218     Link(const ToolChain &TC) : DarwinTool("darwin::Link", TC) {}
 219
 220     virtual bool acceptsPipedInput() const { return false; }
 221     virtual bool canPipeOutput() const { return false; }
 222     virtual bool hasIntegratedCPP() const { return false; }
 223
 224     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 225                               Job &Dest,
 226                               const InputInfo &Output,
 227                               const InputInfoList &Inputs,
 228                               const ArgList &TCArgs,
 229                               const char *LinkingOutput) const;
 230   };
 231
 232   class VISIBILITY_HIDDEN Lipo : public DarwinTool  {
 233   public:
 234     Lipo(const ToolChain &TC) : DarwinTool("darwin::Lipo", TC) {}
 235
 236     virtual bool acceptsPipedInput() const { return false; }
 237     virtual bool canPipeOutput() const { return false; }
 238     virtual bool hasIntegratedCPP() const { return false; }
 239
 240     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 241                               Job &Dest,
 242                               const InputInfo &Output,
 243                               const InputInfoList &Inputs,
 244                               const ArgList &TCArgs,
 245                               const char *LinkingOutput) const;
 246   };
 247 }
 248
 249   /// openbsd -- Directly call GNU Binutils assembler and linker
 250 namespace openbsd {
 251   class VISIBILITY_HIDDEN Assemble : public Tool  {
 252   public:
 253     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", TC) {}
 254
 255     virtual bool acceptsPipedInput() const { return true; }
 256     virtual bool canPipeOutput() const { return true; }
 257     virtual bool hasIntegratedCPP() const { return false; }
 258
 259     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 260                               Job &Dest,
 261                               const InputInfo &Output,
 262                               const InputInfoList &Inputs,
 263                               const ArgList &TCArgs,
 264                               const char *LinkingOutput) const;
 265   };
 266   class VISIBILITY_HIDDEN Link : public Tool  {
 267   public:
 268     Link(const ToolChain &TC) : Tool("openbsd::Link", TC) {}
 269
 270     virtual bool acceptsPipedInput() const { return true; }
 271     virtual bool canPipeOutput() const { return true; }
 272     virtual bool hasIntegratedCPP() const { return false; }
 273
 274     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 275                               Job &Dest,
 276                               const InputInfo &Output,
 277                               const InputInfoList &Inputs,
 278                               const ArgList &TCArgs,
 279                               const char *LinkingOutput) const;
 280   };
 281 } // end namespace openbsd
 282
 283   /// freebsd -- Directly call GNU Binutils assembler and linker
 284 namespace freebsd {
 285   class VISIBILITY_HIDDEN Assemble : public Tool  {
 286   public:
 287     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", TC) {}
 288
 289     virtual bool acceptsPipedInput() const { return true; }
 290     virtual bool canPipeOutput() const { return true; }
 291     virtual bool hasIntegratedCPP() const { return false; }
 292
 293     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 294                               Job &Dest,
 295                               const InputInfo &Output,
 296                               const InputInfoList &Inputs,
 297                               const ArgList &TCArgs,
 298                               const char *LinkingOutput) const;
 299   };
 300   class VISIBILITY_HIDDEN Link : public Tool  {
 301   public:
 302     Link(const ToolChain &TC) : Tool("freebsd::Link", TC) {}
 303
 304     virtual bool acceptsPipedInput() const { return true; }
 305     virtual bool canPipeOutput() const { return true; }
 306     virtual bool hasIntegratedCPP() const { return false; }
 307
 308     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 309                               Job &Dest,
 310                               const InputInfo &Output,
 311                               const InputInfoList &Inputs,
 312                               const ArgList &TCArgs,
 313                               const char *LinkingOutput) const;
 314   };
 315 } // end namespace freebsd
 316
 317   /// auroraux -- Directly call GNU Binutils assembler and linker
 318 namespace auroraux {
 319   class VISIBILITY_HIDDEN Assemble : public Tool  {
 320   public:
 321     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", TC) {}
 322
 323     virtual bool acceptsPipedInput() const { return true; }
 324     virtual bool canPipeOutput() const { return true; }
 325     virtual bool hasIntegratedCPP() const { return false; }
 326
 327     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 328                               Job &Dest,
 329                               const InputInfo &Output,
 330                               const InputInfoList &Inputs,
 331                               const ArgList &TCArgs,
 332                               const char *LinkingOutput) const;
 333   };
 334   class VISIBILITY_HIDDEN Link : public Tool  {
 335   public:
 336     Link(const ToolChain &TC) : Tool("auroraux::Link", TC) {}
 337
 338     virtual bool acceptsPipedInput() const { return true; }
 339     virtual bool canPipeOutput() const { return true; }
 340     virtual bool hasIntegratedCPP() const { return false; }
 341
 342     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 343                               Job &Dest,
 344                               const InputInfo &Output,
 345                               const InputInfoList &Inputs,
 346                               const ArgList &TCArgs,
 347                               const char *LinkingOutput) const;
 348   };
 349 } // end namespace auroraux
 350
 351   /// dragonfly -- Directly call GNU Binutils assembler and linker
 352 namespace dragonfly {
 353   class VISIBILITY_HIDDEN Assemble : public Tool  {
 354   public:
 355     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", TC) {}
 356
 357     virtual bool acceptsPipedInput() const { return true; }
 358     virtual bool canPipeOutput() const { return true; }
 359     virtual bool hasIntegratedCPP() const { return false; }
 360
 361     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 362                               Job &Dest,
 363                               const InputInfo &Output,
 364                               const InputInfoList &Inputs,
 365                               const ArgList &TCArgs,
 366                               const char *LinkingOutput) const;
 367   };
 368   class VISIBILITY_HIDDEN Link : public Tool  {
 369   public:
 370     Link(const ToolChain &TC) : Tool("dragonfly::Link", TC) {}
 371
 372     virtual bool acceptsPipedInput() const { return true; }
 373     virtual bool canPipeOutput() const { return true; }
 374     virtual bool hasIntegratedCPP() const { return false; }
 375
 376     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 377                               Job &Dest,
 378                               const InputInfo &Output,
 379                               const InputInfoList &Inputs,
 380                               const ArgList &TCArgs,
 381                               const char *LinkingOutput) const;
 382   };
 383 } // end namespace dragonfly
 384
 385 } // end namespace toolchains
 386 } // end namespace driver
 387 } // end namespace clang
 388
 389 #endif // CLANG_LIB_DRIVER_TOOLS_H_