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   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     const toolchains::Darwin &getDarwinToolChain() const {
 205       return reinterpret_cast<const toolchains::Darwin&>(getToolChain());
 206     }
 207
 208   public:
 209     Link(const ToolChain &TC)
 210       : Tool("darwin::Link", TC) {
 211     }
 212
 213     virtual bool acceptsPipedInput() const { return false; }
 214     virtual bool canPipeOutput() const { return false; }
 215     virtual bool hasIntegratedCPP() const { return false; }
 216
 217     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 218                               Job &Dest,
 219                               const InputInfo &Output,
 220                               const InputInfoList &Inputs,
 221                               const ArgList &TCArgs,
 222                               const char *LinkingOutput) const;
 223   };
 224
 225   class VISIBILITY_HIDDEN Lipo : public Tool  {
 226   public:
 227     Lipo(const ToolChain &TC) : Tool("darwin::Lipo", TC) {}
 228
 229     virtual bool acceptsPipedInput() const { return false; }
 230     virtual bool canPipeOutput() const { return false; }
 231     virtual bool hasIntegratedCPP() const { return false; }
 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
 242   /// openbsd -- Directly call GNU Binutils assembler and linker
 243 namespace openbsd {
 244   class VISIBILITY_HIDDEN Assemble : public Tool  {
 245   public:
 246     Assemble(const ToolChain &TC) : Tool("openbsd::Assemble", TC) {}
 247
 248     virtual bool acceptsPipedInput() const { return true; }
 249     virtual bool canPipeOutput() const { return true; }
 250     virtual bool hasIntegratedCPP() const { return false; }
 251
 252     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 253                               Job &Dest,
 254                               const InputInfo &Output,
 255                               const InputInfoList &Inputs,
 256                               const ArgList &TCArgs,
 257                               const char *LinkingOutput) const;
 258   };
 259   class VISIBILITY_HIDDEN Link : public Tool  {
 260   public:
 261     Link(const ToolChain &TC) : Tool("openbsd::Link", TC) {}
 262
 263     virtual bool acceptsPipedInput() const { return true; }
 264     virtual bool canPipeOutput() const { return true; }
 265     virtual bool hasIntegratedCPP() const { return false; }
 266
 267     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 268                               Job &Dest,
 269                               const InputInfo &Output,
 270                               const InputInfoList &Inputs,
 271                               const ArgList &TCArgs,
 272                               const char *LinkingOutput) const;
 273   };
 274 } // end namespace openbsd
 275
 276   /// freebsd -- Directly call GNU Binutils assembler and linker
 277 namespace freebsd {
 278   class VISIBILITY_HIDDEN Assemble : public Tool  {
 279   public:
 280     Assemble(const ToolChain &TC) : Tool("freebsd::Assemble", TC) {}
 281
 282     virtual bool acceptsPipedInput() const { return true; }
 283     virtual bool canPipeOutput() const { return true; }
 284     virtual bool hasIntegratedCPP() const { return false; }
 285
 286     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 287                               Job &Dest,
 288                               const InputInfo &Output,
 289                               const InputInfoList &Inputs,
 290                               const ArgList &TCArgs,
 291                               const char *LinkingOutput) const;
 292   };
 293   class VISIBILITY_HIDDEN Link : public Tool  {
 294   public:
 295     Link(const ToolChain &TC) : Tool("freebsd::Link", TC) {}
 296
 297     virtual bool acceptsPipedInput() const { return true; }
 298     virtual bool canPipeOutput() const { return true; }
 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 } // end namespace freebsd
 309
 310   /// auroraux -- Directly call GNU Binutils assembler and linker
 311 namespace auroraux {
 312   class VISIBILITY_HIDDEN Assemble : public Tool  {
 313   public:
 314     Assemble(const ToolChain &TC) : Tool("auroraux::Assemble", TC) {}
 315
 316     virtual bool acceptsPipedInput() const { return true; }
 317     virtual bool canPipeOutput() const { return true; }
 318     virtual bool hasIntegratedCPP() const { return false; }
 319
 320     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 321                               Job &Dest,
 322                               const InputInfo &Output,
 323                               const InputInfoList &Inputs,
 324                               const ArgList &TCArgs,
 325                               const char *LinkingOutput) const;
 326   };
 327   class VISIBILITY_HIDDEN Link : public Tool  {
 328   public:
 329     Link(const ToolChain &TC) : Tool("auroraux::Link", TC) {}
 330
 331     virtual bool acceptsPipedInput() const { return true; }
 332     virtual bool canPipeOutput() const { return true; }
 333     virtual bool hasIntegratedCPP() const { return false; }
 334
 335     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 336                               Job &Dest,
 337                               const InputInfo &Output,
 338                               const InputInfoList &Inputs,
 339                               const ArgList &TCArgs,
 340                               const char *LinkingOutput) const;
 341   };
 342 } // end namespace auroraux
 343
 344   /// dragonfly -- Directly call GNU Binutils assembler and linker
 345 namespace dragonfly {
 346   class VISIBILITY_HIDDEN Assemble : public Tool  {
 347   public:
 348     Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", 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   class VISIBILITY_HIDDEN Link : public Tool  {
 362   public:
 363     Link(const ToolChain &TC) : Tool("dragonfly::Link", TC) {}
 364
 365     virtual bool acceptsPipedInput() const { return true; }
 366     virtual bool canPipeOutput() const { return true; }
 367     virtual bool hasIntegratedCPP() const { return false; }
 368
 369     virtual void ConstructJob(Compilation &C, const JobAction &JA,
 370                               Job &Dest,
 371                               const InputInfo &Output,
 372                               const InputInfoList &Inputs,
 373                               const ArgList &TCArgs,
 374                               const char *LinkingOutput) const;
 375   };
 376 } // end namespace dragonfly
 377
 378 } // end namespace toolchains
 379 } // end namespace driver
 380 } // end namespace clang
 381
 382 #endif // CLANG_LIB_DRIVER_TOOLS_H_