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