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