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/Util.h"
  17
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/ADT/Triple.h"
  20 #include "llvm/System/Path.h" // FIXME: Kill when CompilationInfo
  21                               // lands.
  22 #include <list>
  23 #include <set>
  24 #include <string>
  25
  26 namespace llvm {
  27   class raw_ostream;
  28 }
  29 namespace clang {
  30 namespace driver {
  31   class Action;
  32   class ArgList;
  33   class Compilation;
  34   class HostInfo;
  35   class InputArgList;
  36   class InputInfo;
  37   class JobAction;
  38   class OptTable;
  39   class PipedJob;
  40   class ToolChain;
  41
  42 /// Driver - Encapsulate logic for constructing compilation processes
  43 /// from a set of gcc-driver-like command line arguments.
  44 class Driver {
  45   OptTable *Opts;
  46
  47   Diagnostic &Diags;
  48
  49 public:
  50   // Diag - Forwarding function for diagnostics.
  51   DiagnosticBuilder Diag(unsigned DiagID) const {
  52     return Diags.Report(DiagID);
  53   }
  54
  55   // FIXME: Privatize once interface is stable.
  56 public:
  57   /// The name the driver was invoked as.
  58   std::string Name;
  59
  60   /// The path the driver executable was in, as invoked from the
  61   /// command line.
  62   std::string Dir;
  63
  64   /// The path to the compiler resource directory.
  65   std::string ResourceDir;
  66
  67   /// Default host triple.
  68   std::string DefaultHostTriple;
  69
  70   /// Default name for linked images (e.g., "a.out").
  71   std::string DefaultImageName;
  72
  73   /// Host information for the platform the driver is running as. This
  74   /// will generally be the actual host platform, but not always.
  75   const HostInfo *Host;
  76
  77   /// Information about the host which can be overriden by the user.
  78   std::string HostBits, HostMachine, HostSystem, HostRelease;
  79
  80   /// Name to use when calling the generic gcc.
  81   std::string CCCGenericGCCName;
  82
  83   /// Whether the driver should follow g++ like behavior.
  84   unsigned CCCIsCXX : 1;
  85
  86   /// Echo commands while executing (in -v style).
  87   unsigned CCCEcho : 1;
  88
  89   /// Only print tool bindings, don't build any jobs.
  90   unsigned CCCPrintBindings : 1;
  91
  92 private:
  93   /// Whether to check that input files exist when constructing compilation
  94   /// jobs.
  95   unsigned CheckInputsExist : 1;
  96
  97   /// Use the clang compiler where possible.
  98   unsigned CCCUseClang : 1;
  99
 100   /// Use clang for handling C++ and Objective-C++ inputs.
 101   unsigned CCCUseClangCXX : 1;
 102
 103   /// Use clang as a preprocessor (clang's preprocessor will still be
 104   /// used where an integrated CPP would).
 105   unsigned CCCUseClangCPP : 1;
 106
 107 public:
 108   /// Use lazy precompiled headers for PCH support.
 109   unsigned CCCUsePCH : 1;
 110
 111 private:
 112   /// Only use clang for the given architectures (only used when
 113   /// non-empty).
 114   std::set<llvm::Triple::ArchType> CCCClangArchs;
 115
 116   /// Certain options suppress the 'no input files' warning.
 117   bool SuppressMissingInputWarning : 1;
 118
 119   std::list<std::string> TempFiles;
 120   std::list<std::string> ResultFiles;
 121
 122 public:
 123   Driver(llvm::StringRef _Name, llvm::StringRef _Dir,
 124          llvm::StringRef _DefaultHostTriple,
 125          llvm::StringRef _DefaultImageName,
 126          bool IsProduction, Diagnostic &_Diags);
 127   ~Driver();
 128
 129   /// @name Accessors
 130   /// @{
 131
 132   const OptTable &getOpts() const { return *Opts; }
 133
 134   const Diagnostic &getDiags() const { return Diags; }
 135
 136   bool getCheckInputsExist() const { return CheckInputsExist; }
 137
 138   void setCheckInputsExist(bool Value) { CheckInputsExist = Value; }
 139
 140   /// @}
 141   /// @name Primary Functionality
 142   /// @{
 143
 144   /// BuildCompilation - Construct a compilation object for a command
 145   /// line argument vector.
 146   ///
 147   /// \return A compilation, or 0 if none was built for the given
 148   /// argument vector. A null return value does not necessarily
 149   /// indicate an error condition, the diagnostics should be queried
 150   /// to determine if an error occurred.
 151   Compilation *BuildCompilation(int argc, const char **argv);
 152
 153   /// @name Driver Steps
 154   /// @{
 155
 156   /// ParseArgStrings - Parse the given list of strings into an
 157   /// ArgList.
 158   InputArgList *ParseArgStrings(const char **ArgBegin, const char **ArgEnd);
 159
 160   /// BuildActions - Construct the list of actions to perform for the
 161   /// given arguments, which are only done for a single architecture.
 162   ///
 163   /// \param Args - The input arguments.
 164   /// \param Actions - The list to store the resulting actions onto.
 165   void BuildActions(const ArgList &Args, ActionList &Actions) const;
 166
 167   /// BuildUniversalActions - Construct the list of actions to perform
 168   /// for the given arguments, which may require a universal build.
 169   ///
 170   /// \param Args - The input arguments.
 171   /// \param Actions - The list to store the resulting actions onto.
 172   void BuildUniversalActions(const ArgList &Args, ActionList &Actions) const;
 173
 174   /// BuildJobs - Bind actions to concrete tools and translate
 175   /// arguments to form the list of jobs to run.
 176   ///
 177   /// \arg C - The compilation that is being built.
 178   void BuildJobs(Compilation &C) const;
 179
 180   /// ExecuteCompilation - Execute the compilation according to the command line
 181   /// arguments and return an appropriate exit code.
 182   ///
 183   /// This routine handles additional processing that must be done in addition
 184   /// to just running the subprocesses, for example reporting errors, removing
 185   /// temporary files, etc.
 186   int ExecuteCompilation(const Compilation &C) const;
 187
 188   /// @}
 189   /// @name Helper Methods
 190   /// @{
 191
 192   /// PrintActions - Print the list of actions.
 193   void PrintActions(const Compilation &C) const;
 194
 195   /// PrintHelp - Print the help text.
 196   ///
 197   /// \param ShowHidden - Show hidden options.
 198   void PrintHelp(bool ShowHidden) const;
 199
 200   /// PrintOptions - Print the list of arguments.
 201   void PrintOptions(const ArgList &Args) const;
 202
 203   /// PrintVersion - Print the driver version.
 204   void PrintVersion(const Compilation &C, llvm::raw_ostream &OS) const;
 205
 206   /// GetFilePath - Lookup \arg Name in the list of file search paths.
 207   ///
 208   /// \arg TC - The tool chain for additional information on
 209   /// directories to search.
 210   //
 211   // FIXME: This should be in CompilationInfo.
 212   std::string GetFilePath(const char *Name, const ToolChain &TC) const;
 213
 214   /// GetProgramPath - Lookup \arg Name in the list of program search
 215   /// paths.
 216   ///
 217   /// \arg TC - The provided tool chain for additional information on
 218   /// directories to search.
 219   ///
 220   /// \arg WantFile - False when searching for an executable file, otherwise
 221   /// true.  Defaults to false.
 222   //
 223   // FIXME: This should be in CompilationInfo.
 224   std::string GetProgramPath(const char *Name, const ToolChain &TC,
 225                               bool WantFile = false) const;
 226
 227   /// HandleImmediateArgs - Handle any arguments which should be
 228   /// treated before building actions or binding tools.
 229   ///
 230   /// \return Whether any compilation should be built for this
 231   /// invocation.
 232   bool HandleImmediateArgs(const Compilation &C);
 233
 234   /// ConstructAction - Construct the appropriate action to do for
 235   /// \arg Phase on the \arg Input, taking in to account arguments
 236   /// like -fsyntax-only or --analyze.
 237   Action *ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
 238                                Action *Input) const;
 239
 240
 241   /// BuildJobsForAction - Construct the jobs to perform for the
 242   /// action \arg A.
 243   void BuildJobsForAction(Compilation &C,
 244                           const Action *A,
 245                           const ToolChain *TC,
 246                           const char *BoundArch,
 247                           bool CanAcceptPipe,
 248                           bool AtTopLevel,
 249                           const char *LinkingOutput,
 250                           InputInfo &Result) const;
 251
 252   /// GetNamedOutputPath - Return the name to use for the output of
 253   /// the action \arg JA. The result is appended to the compilation's
 254   /// list of temporary or result files, as appropriate.
 255   ///
 256   /// \param C - The compilation.
 257   /// \param JA - The action of interest.
 258   /// \param BaseInput - The original input file that this action was
 259   /// triggered by.
 260   /// \param AtTopLevel - Whether this is a "top-level" action.
 261   const char *GetNamedOutputPath(Compilation &C,
 262                                  const JobAction &JA,
 263                                  const char *BaseInput,
 264                                  bool AtTopLevel) const;
 265
 266   /// GetTemporaryPath - Return the pathname of a temporary file to
 267   /// use as part of compilation; the file will have the given suffix.
 268   ///
 269   /// GCC goes to extra lengths here to be a bit more robust.
 270   std::string GetTemporaryPath(const char *Suffix) const;
 271
 272   /// GetHostInfo - Construct a new host info object for the given
 273   /// host triple.
 274   const HostInfo *GetHostInfo(const char *HostTriple) const;
 275
 276   /// ShouldUseClangCompilar - Should the clang compiler be used to
 277   /// handle this action.
 278   bool ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
 279                               const llvm::Triple &ArchName) const;
 280
 281   /// @}
 282
 283   /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
 284   /// return the grouped values as integers. Numbers which are not
 285   /// provided are set to 0.
 286   ///
 287   /// \return True if the entire string was parsed (9.2), or all
 288   /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
 289   /// groups were parsed but extra characters remain at the end.
 290   static bool GetReleaseVersion(const char *Str, unsigned &Major,
 291                                 unsigned &Minor, unsigned &Micro,
 292                                 bool &HadExtra);
 293 };
 294
 295 } // end namespace driver
 296 } // end namespace clang
 297
 298 #endif