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