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