contrib/llvm/tools/clang/include/clang/Driver/Driver.h

   1 //===--- Driver.h - Clang GCC Compatible Driver -----------------*- 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_DRIVER_DRIVER_H_
  11 #define CLANG_DRIVER_DRIVER_H_
  12
  13 #include "clang/Basic/Diagnostic.h"
  14
  15 #include "clang/Driver/Phases.h"
  16 #include "clang/Driver/Types.h"
  17 #include "clang/Driver/Util.h"
  18
  19 #include "llvm/ADT/StringMap.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/Triple.h"
  22 #include "llvm/Support/Path.h" // FIXME: Kill when CompilationInfo
  23                               // lands.
  24 #include <list>
  25 #include <set>
  26 #include <string>
  27
  28 namespace llvm {
  29   template<typename T> class ArrayRef;
  30 }
  31 namespace clang {
  32 namespace driver {
  33   class Action;
  34   class Arg;
  35   class ArgList;
  36   class Command;
  37   class Compilation;
  38   class DerivedArgList;
  39   class InputArgList;
  40   class InputInfo;
  41   class JobAction;
  42   class OptTable;
  43   class ToolChain;
  44
  45 /// Driver - Encapsulate logic for constructing compilation processes
  46 /// from a set of gcc-driver-like command line arguments.
  47 class Driver {
  48   OptTable *Opts;
  49
  50   DiagnosticsEngine &Diags;
  51
  52 public:
  53   // Diag - Forwarding function for diagnostics.
  54   DiagnosticBuilder Diag(unsigned DiagID) const {
  55     return Diags.Report(DiagID);
  56   }
  57
  58   // FIXME: Privatize once interface is stable.
  59 public:
  60   /// The name the driver was invoked as.
  61   std::string Name;
  62
  63   /// The path the driver executable was in, as invoked from the
  64   /// command line.
  65   std::string Dir;
  66
  67   /// The original path to the clang executable.
  68   std::string ClangExecutable;
  69
  70   /// The path to the installed clang directory, if any.
  71   std::string InstalledDir;
  72
  73   /// The path to the compiler resource directory.
  74   std::string ResourceDir;
  75
  76   /// A prefix directory used to emulated a limited subset of GCC's '-Bprefix'
  77   /// functionality.
  78   /// FIXME: This type of customization should be removed in favor of the
  79   /// universal driver when it is ready.
  80   typedef SmallVector<std::string, 4> prefix_list;
  81   prefix_list PrefixDirs;
  82
  83   /// sysroot, if present
  84   std::string SysRoot;
  85
  86   /// If the standard library is used
  87   bool UseStdLib;
  88
  89   /// Default target triple.
  90   std::string DefaultTargetTriple;
  91
  92   /// Default name for linked images (e.g., "a.out").
  93   std::string DefaultImageName;
  94
  95   /// Driver title to use with help.
  96   std::string DriverTitle;
  97
  98   /// Information about the host which can be overridden by the user.
  99   std::string HostBits, HostMachine, HostSystem, HostRelease;
 100
 101   /// The file to log CC_PRINT_OPTIONS output to, if enabled.
 102   const char *CCPrintOptionsFilename;
 103
 104   /// The file to log CC_PRINT_HEADERS output to, if enabled.
 105   const char *CCPrintHeadersFilename;
 106
 107   /// The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
 108   const char *CCLogDiagnosticsFilename;
 109
 110   /// A list of inputs and their types for the given arguments.
 111   typedef SmallVector<std::pair<types::ID, const Arg*>, 16> InputList;
 112
 113   /// Whether the driver should follow g++ like behavior.
 114   unsigned CCCIsCXX : 1;
 115
 116   /// Whether the driver is just the preprocessor.
 117   unsigned CCCIsCPP : 1;
 118
 119   /// Echo commands while executing (in -v style).
 120   unsigned CCCEcho : 1;
 121
 122   /// Only print tool bindings, don't build any jobs.
 123   unsigned CCCPrintBindings : 1;
 124
 125   /// Set CC_PRINT_OPTIONS mode, which is like -v but logs the commands to
 126   /// CCPrintOptionsFilename or to stderr.
 127   unsigned CCPrintOptions : 1;
 128
 129   /// Set CC_PRINT_HEADERS mode, which causes the frontend to log header include
 130   /// information to CCPrintHeadersFilename or to stderr.
 131   unsigned CCPrintHeaders : 1;
 132
 133   /// Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics
 134   /// to CCLogDiagnosticsFilename or to stderr, in a stable machine readable
 135   /// format.
 136   unsigned CCLogDiagnostics : 1;
 137
 138   /// Whether the driver is generating diagnostics for debugging purposes.
 139   unsigned CCGenDiagnostics : 1;
 140
 141 private:
 142   /// Name to use when invoking gcc/g++.
 143   std::string CCCGenericGCCName;
 144
 145   /// Whether to check that input files exist when constructing compilation
 146   /// jobs.
 147   unsigned CheckInputsExist : 1;
 148
 149   /// Use the clang compiler where possible.
 150   unsigned CCCUseClang : 1;
 151
 152   /// Use clang for handling C++ and Objective-C++ inputs.
 153   unsigned CCCUseClangCXX : 1;
 154
 155   /// Use clang as a preprocessor (clang's preprocessor will still be
 156   /// used where an integrated CPP would).
 157   unsigned CCCUseClangCPP : 1;
 158
 159 public:
 160   /// Use lazy precompiled headers for PCH support.
 161   unsigned CCCUsePCH : 1;
 162
 163 private:
 164   /// Only use clang for the given architectures (only used when
 165   /// non-empty).
 166   std::set<llvm::Triple::ArchType> CCCClangArchs;
 167
 168   /// Certain options suppress the 'no input files' warning.
 169   bool SuppressMissingInputWarning : 1;
 170
 171   std::list<std::string> TempFiles;
 172   std::list<std::string> ResultFiles;
 173
 174   /// \brief Cache of all the ToolChains in use by the driver.
 175   ///
 176   /// This maps from the string representation of a triple to a ToolChain
 177   /// created targetting that triple. The driver owns all the ToolChain objects
 178   /// stored in it, and will clean them up when torn down.
 179   mutable llvm::StringMap<ToolChain *> ToolChains;
 180
 181 private:
 182   /// TranslateInputArgs - Create a new derived argument list from the input
 183   /// arguments, after applying the standard argument translations.
 184   DerivedArgList *TranslateInputArgs(const InputArgList &Args) const;
 185
 186   // getFinalPhase - Determine which compilation mode we are in and record
 187   // which option we used to determine the final phase.
 188   phases::ID getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg = 0)
 189     const;
 190
 191 public:
 192   Driver(StringRef _ClangExecutable,
 193          StringRef _DefaultTargetTriple,
 194          StringRef _DefaultImageName,
 195          bool IsProduction,
 196          DiagnosticsEngine &_Diags);
 197   ~Driver();
 198
 199   /// @name Accessors
 200   /// @{
 201
 202   /// Name to use when invoking gcc/g++.
 203   const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; }
 204
 205
 206   const OptTable &getOpts() const { return *Opts; }
 207
 208   const DiagnosticsEngine &getDiags() const { return Diags; }
 209
 210   bool getCheckInputsExist() const { return CheckInputsExist; }
 211
 212   void setCheckInputsExist(bool Value) { CheckInputsExist = Value; }
 213
 214   const std::string &getTitle() { return DriverTitle; }
 215   void setTitle(std::string Value) { DriverTitle = Value; }
 216
 217   /// \brief Get the path to the main clang executable.
 218   const char *getClangProgramPath() const {
 219     return ClangExecutable.c_str();
 220   }
 221
 222   /// \brief Get the path to where the clang executable was installed.
 223   const char *getInstalledDir() const {
 224     if (!InstalledDir.empty())
 225       return InstalledDir.c_str();
 226     return Dir.c_str();
 227   }
 228   void setInstalledDir(StringRef Value) {
 229     InstalledDir = Value;
 230   }
 231
 232   /// @}
 233   /// @name Primary Functionality
 234   /// @{
 235
 236   /// BuildCompilation - Construct a compilation object for a command
 237   /// line argument vector.
 238   ///
 239   /// \return A compilation, or 0 if none was built for the given
 240   /// argument vector. A null return value does not necessarily
 241   /// indicate an error condition, the diagnostics should be queried
 242   /// to determine if an error occurred.
 243   Compilation *BuildCompilation(ArrayRef<const char *> Args);
 244
 245   /// @name Driver Steps
 246   /// @{
 247
 248   /// ParseArgStrings - Parse the given list of strings into an
 249   /// ArgList.
 250   InputArgList *ParseArgStrings(ArrayRef<const char *> Args);
 251
 252   /// BuildInputs - Construct the list of inputs and their types from
 253   /// the given arguments.
 254   ///
 255   /// \param TC - The default host tool chain.
 256   /// \param Args - The input arguments.
 257   /// \param Inputs - The list to store the resulting compilation
 258   /// inputs onto.
 259   void BuildInputs(const ToolChain &TC, const DerivedArgList &Args,
 260                    InputList &Inputs) const;
 261
 262   /// BuildActions - Construct the list of actions to perform for the
 263   /// given arguments, which are only done for a single architecture.
 264   ///
 265   /// \param TC - The default host tool chain.
 266   /// \param Args - The input arguments.
 267   /// \param Actions - The list to store the resulting actions onto.
 268   void BuildActions(const ToolChain &TC, const DerivedArgList &Args,
 269                     const InputList &Inputs, ActionList &Actions) const;
 270
 271   /// BuildUniversalActions - Construct the list of actions to perform
 272   /// for the given arguments, which may require a universal build.
 273   ///
 274   /// \param TC - The default host tool chain.
 275   /// \param Args - The input arguments.
 276   /// \param Actions - The list to store the resulting actions onto.
 277   void BuildUniversalActions(const ToolChain &TC, const DerivedArgList &Args,
 278                              const InputList &BAInputs,
 279                              ActionList &Actions) const;
 280
 281   /// BuildJobs - Bind actions to concrete tools and translate
 282   /// arguments to form the list of jobs to run.
 283   ///
 284   /// \arg C - The compilation that is being built.
 285   void BuildJobs(Compilation &C) const;
 286
 287   /// ExecuteCompilation - Execute the compilation according to the command line
 288   /// arguments and return an appropriate exit code.
 289   ///
 290   /// This routine handles additional processing that must be done in addition
 291   /// to just running the subprocesses, for example reporting errors, removing
 292   /// temporary files, etc.
 293   int ExecuteCompilation(const Compilation &C,
 294                          const Command *&FailingCommand) const;
 295
 296   /// generateCompilationDiagnostics - Generate diagnostics information
 297   /// including preprocessed source file(s).
 298   ///
 299   void generateCompilationDiagnostics(Compilation &C,
 300                                       const Command *FailingCommand);
 301
 302   /// @}
 303   /// @name Helper Methods
 304   /// @{
 305
 306   /// PrintActions - Print the list of actions.
 307   void PrintActions(const Compilation &C) const;
 308
 309   /// PrintHelp - Print the help text.
 310   ///
 311   /// \param ShowHidden - Show hidden options.
 312   void PrintHelp(bool ShowHidden) const;
 313
 314   /// PrintOptions - Print the list of arguments.
 315   void PrintOptions(const ArgList &Args) const;
 316
 317   /// PrintVersion - Print the driver version.
 318   void PrintVersion(const Compilation &C, raw_ostream &OS) const;
 319
 320   /// GetFilePath - Lookup \arg Name in the list of file search paths.
 321   ///
 322   /// \arg TC - The tool chain for additional information on
 323   /// directories to search.
 324   //
 325   // FIXME: This should be in CompilationInfo.
 326   std::string GetFilePath(const char *Name, const ToolChain &TC) const;
 327
 328   /// GetProgramPath - Lookup \arg Name in the list of program search
 329   /// paths.
 330   ///
 331   /// \arg TC - The provided tool chain for additional information on
 332   /// directories to search.
 333   ///
 334   /// \arg WantFile - False when searching for an executable file, otherwise
 335   /// true.  Defaults to false.
 336   //
 337   // FIXME: This should be in CompilationInfo.
 338   std::string GetProgramPath(const char *Name, const ToolChain &TC,
 339                               bool WantFile = false) const;
 340
 341   /// HandleImmediateArgs - Handle any arguments which should be
 342   /// treated before building actions or binding tools.
 343   ///
 344   /// \return Whether any compilation should be built for this
 345   /// invocation.
 346   bool HandleImmediateArgs(const Compilation &C);
 347
 348   /// ConstructAction - Construct the appropriate action to do for
 349   /// \arg Phase on the \arg Input, taking in to account arguments
 350   /// like -fsyntax-only or --analyze.
 351   Action *ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
 352                                Action *Input) const;
 353
 354
 355   /// BuildJobsForAction - Construct the jobs to perform for the
 356   /// action \arg A.
 357   void BuildJobsForAction(Compilation &C,
 358                           const Action *A,
 359                           const ToolChain *TC,
 360                           const char *BoundArch,
 361                           bool AtTopLevel,
 362                           const char *LinkingOutput,
 363                           InputInfo &Result) const;
 364
 365   /// GetNamedOutputPath - Return the name to use for the output of
 366   /// the action \arg JA. The result is appended to the compilation's
 367   /// list of temporary or result files, as appropriate.
 368   ///
 369   /// \param C - The compilation.
 370   /// \param JA - The action of interest.
 371   /// \param BaseInput - The original input file that this action was
 372   /// triggered by.
 373   /// \param AtTopLevel - Whether this is a "top-level" action.
 374   const char *GetNamedOutputPath(Compilation &C,
 375                                  const JobAction &JA,
 376                                  const char *BaseInput,
 377                                  bool AtTopLevel) const;
 378
 379   /// GetTemporaryPath - Return the pathname of a temporary file to use
 380   /// as part of compilation; the file will have the given prefix and suffix.
 381   ///
 382   /// GCC goes to extra lengths here to be a bit more robust.
 383   std::string GetTemporaryPath(StringRef Prefix, const char *Suffix) const;
 384
 385   /// ShouldUseClangCompilar - Should the clang compiler be used to
 386   /// handle this action.
 387   bool ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
 388                               const llvm::Triple &ArchName) const;
 389
 390   bool IsUsingLTO(const ArgList &Args) const;
 391
 392 private:
 393   /// \brief Retrieves a ToolChain for a particular target triple.
 394   ///
 395   /// Will cache ToolChains for the life of the driver object, and create them
 396   /// on-demand.
 397   const ToolChain &getToolChain(const ArgList &Args,
 398                                 StringRef DarwinArchName = "") const;
 399
 400   /// @}
 401
 402 public:
 403   /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
 404   /// return the grouped values as integers. Numbers which are not
 405   /// provided are set to 0.
 406   ///
 407   /// \return True if the entire string was parsed (9.2), or all
 408   /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
 409   /// groups were parsed but extra characters remain at the end.
 410   static bool GetReleaseVersion(const char *Str, unsigned &Major,
 411                                 unsigned &Minor, unsigned &Micro,
 412                                 bool &HadExtra);
 413 };
 414
 415 } // end namespace driver
 416 } // end namespace clang
 417
 418 #endif