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 LLVM_CLANG_DRIVER_DRIVER_H
11#define LLVM_CLANG_DRIVER_DRIVER_H
12
13#include "clang/Basic/Diagnostic.h"
14#include "clang/Basic/LLVM.h"
15#include "clang/Driver/Phases.h"
16#include "clang/Driver/Types.h"
17#include "clang/Driver/Util.h"
18#include "llvm/ADT/StringMap.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/Triple.h"
21#include "llvm/Support/Path.h" // FIXME: Kill when CompilationInfo lands.
22
23#include <list>
24#include <map>
25#include <memory>
26#include <set>
27#include <string>
28
29namespace llvm {
30namespace opt {
31  class Arg;
32  class ArgList;
33  class DerivedArgList;
34  class InputArgList;
35  class OptTable;
36}
37}
38
39namespace clang {
40
41namespace vfs {
42class FileSystem;
43}
44
45namespace driver {
46
47  class Action;
48  class Command;
49  class Compilation;
50  class InputInfo;
51  class JobList;
52  class JobAction;
53  class SanitizerArgs;
54  class ToolChain;
55
56/// Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
57enum LTOKind {
58  LTOK_None,
59  LTOK_Full,
60  LTOK_Thin,
61  LTOK_Unknown
62};
63
64/// Driver - Encapsulate logic for constructing compilation processes
65/// from a set of gcc-driver-like command line arguments.
66class Driver {
67  llvm::opt::OptTable *Opts;
68
69  DiagnosticsEngine &Diags;
70
71  IntrusiveRefCntPtr<vfs::FileSystem> VFS;
72
73  enum DriverMode {
74    GCCMode,
75    GXXMode,
76    CPPMode,
77    CLMode
78  } Mode;
79
80  enum SaveTempsMode {
81    SaveTempsNone,
82    SaveTempsCwd,
83    SaveTempsObj
84  } SaveTemps;
85
86  enum BitcodeEmbedMode {
87    EmbedNone,
88    EmbedMarker,
89    EmbedBitcode
90  } BitcodeEmbed;
91
92  /// LTO mode selected via -f(no-)?lto(=.*)? options.
93  LTOKind LTOMode;
94
95public:
96  // Diag - Forwarding function for diagnostics.
97  DiagnosticBuilder Diag(unsigned DiagID) const {
98    return Diags.Report(DiagID);
99  }
100
101  // FIXME: Privatize once interface is stable.
102public:
103  /// The name the driver was invoked as.
104  std::string Name;
105
106  /// The path the driver executable was in, as invoked from the
107  /// command line.
108  std::string Dir;
109
110  /// The original path to the clang executable.
111  std::string ClangExecutable;
112
113  /// The path to the installed clang directory, if any.
114  std::string InstalledDir;
115
116  /// The path to the compiler resource directory.
117  std::string ResourceDir;
118
119  /// A prefix directory used to emulate a limited subset of GCC's '-Bprefix'
120  /// functionality.
121  /// FIXME: This type of customization should be removed in favor of the
122  /// universal driver when it is ready.
123  typedef SmallVector<std::string, 4> prefix_list;
124  prefix_list PrefixDirs;
125
126  /// sysroot, if present
127  std::string SysRoot;
128
129  /// Dynamic loader prefix, if present
130  std::string DyldPrefix;
131
132  /// If the standard library is used
133  bool UseStdLib;
134
135  /// Default target triple.
136  std::string DefaultTargetTriple;
137
138  /// Driver title to use with help.
139  std::string DriverTitle;
140
141  /// Information about the host which can be overridden by the user.
142  std::string HostBits, HostMachine, HostSystem, HostRelease;
143
144  /// The file to log CC_PRINT_OPTIONS output to, if enabled.
145  const char *CCPrintOptionsFilename;
146
147  /// The file to log CC_PRINT_HEADERS output to, if enabled.
148  const char *CCPrintHeadersFilename;
149
150  /// The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
151  const char *CCLogDiagnosticsFilename;
152
153  /// A list of inputs and their types for the given arguments.
154  typedef SmallVector<std::pair<types::ID, const llvm::opt::Arg *>, 16>
155      InputList;
156
157  /// Whether the driver should follow g++ like behavior.
158  bool CCCIsCXX() const { return Mode == GXXMode; }
159
160  /// Whether the driver is just the preprocessor.
161  bool CCCIsCPP() const { return Mode == CPPMode; }
162
163  /// Whether the driver should follow cl.exe like behavior.
164  bool IsCLMode() const { return Mode == CLMode; }
165
166  /// Only print tool bindings, don't build any jobs.
167  unsigned CCCPrintBindings : 1;
168
169  /// Set CC_PRINT_OPTIONS mode, which is like -v but logs the commands to
170  /// CCPrintOptionsFilename or to stderr.
171  unsigned CCPrintOptions : 1;
172
173  /// Set CC_PRINT_HEADERS mode, which causes the frontend to log header include
174  /// information to CCPrintHeadersFilename or to stderr.
175  unsigned CCPrintHeaders : 1;
176
177  /// Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics
178  /// to CCLogDiagnosticsFilename or to stderr, in a stable machine readable
179  /// format.
180  unsigned CCLogDiagnostics : 1;
181
182  /// Whether the driver is generating diagnostics for debugging purposes.
183  unsigned CCGenDiagnostics : 1;
184
185private:
186  /// Name to use when invoking gcc/g++.
187  std::string CCCGenericGCCName;
188
189  /// Whether to check that input files exist when constructing compilation
190  /// jobs.
191  unsigned CheckInputsExist : 1;
192
193public:
194  /// Use lazy precompiled headers for PCH support.
195  unsigned CCCUsePCH : 1;
196
197private:
198  /// Certain options suppress the 'no input files' warning.
199  unsigned SuppressMissingInputWarning : 1;
200
201  std::list<std::string> TempFiles;
202  std::list<std::string> ResultFiles;
203
204  /// \brief Cache of all the ToolChains in use by the driver.
205  ///
206  /// This maps from the string representation of a triple to a ToolChain
207  /// created targeting that triple. The driver owns all the ToolChain objects
208  /// stored in it, and will clean them up when torn down.
209  mutable llvm::StringMap<ToolChain *> ToolChains;
210
211private:
212  /// TranslateInputArgs - Create a new derived argument list from the input
213  /// arguments, after applying the standard argument translations.
214  llvm::opt::DerivedArgList *
215  TranslateInputArgs(const llvm::opt::InputArgList &Args) const;
216
217  // getFinalPhase - Determine which compilation mode we are in and record
218  // which option we used to determine the final phase.
219  phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL,
220                           llvm::opt::Arg **FinalPhaseArg = nullptr) const;
221
222  // Before executing jobs, sets up response files for commands that need them.
223  void setUpResponseFiles(Compilation &C, Command &Cmd);
224
225  void generatePrefixedToolNames(const char *Tool, const ToolChain &TC,
226                                 SmallVectorImpl<std::string> &Names) const;
227
228public:
229  Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple,
230         DiagnosticsEngine &Diags,
231         IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
232  ~Driver();
233
234  /// @name Accessors
235  /// @{
236
237  /// Name to use when invoking gcc/g++.
238  const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; }
239
240  const llvm::opt::OptTable &getOpts() const { return *Opts; }
241
242  const DiagnosticsEngine &getDiags() const { return Diags; }
243
244  vfs::FileSystem &getVFS() const { return *VFS; }
245
246  bool getCheckInputsExist() const { return CheckInputsExist; }
247
248  void setCheckInputsExist(bool Value) { CheckInputsExist = Value; }
249
250  const std::string &getTitle() { return DriverTitle; }
251  void setTitle(std::string Value) { DriverTitle = std::move(Value); }
252
253  /// \brief Get the path to the main clang executable.
254  const char *getClangProgramPath() const {
255    return ClangExecutable.c_str();
256  }
257
258  /// \brief Get the path to where the clang executable was installed.
259  const char *getInstalledDir() const {
260    if (!InstalledDir.empty())
261      return InstalledDir.c_str();
262    return Dir.c_str();
263  }
264  void setInstalledDir(StringRef Value) {
265    InstalledDir = Value;
266  }
267
268  bool isSaveTempsEnabled() const { return SaveTemps != SaveTempsNone; }
269  bool isSaveTempsObj() const { return SaveTemps == SaveTempsObj; }
270
271  bool embedBitcodeEnabled() const { return BitcodeEmbed == EmbedBitcode; }
272  bool embedBitcodeMarkerOnly() const { return BitcodeEmbed == EmbedMarker; }
273
274  /// @}
275  /// @name Primary Functionality
276  /// @{
277
278  /// CreateOffloadingDeviceToolChains - create all the toolchains required to
279  /// support offloading devices given the programming models specified in the
280  /// current compilation. Also, update the host tool chain kind accordingly.
281  void CreateOffloadingDeviceToolChains(Compilation &C, InputList &Inputs);
282
283  /// BuildCompilation - Construct a compilation object for a command
284  /// line argument vector.
285  ///
286  /// \return A compilation, or 0 if none was built for the given
287  /// argument vector. A null return value does not necessarily
288  /// indicate an error condition, the diagnostics should be queried
289  /// to determine if an error occurred.
290  Compilation *BuildCompilation(ArrayRef<const char *> Args);
291
292  /// @name Driver Steps
293  /// @{
294
295  /// ParseDriverMode - Look for and handle the driver mode option in Args.
296  void ParseDriverMode(ArrayRef<const char *> Args);
297
298  /// ParseArgStrings - Parse the given list of strings into an
299  /// ArgList.
300  llvm::opt::InputArgList ParseArgStrings(ArrayRef<const char *> Args);
301
302  /// BuildInputs - Construct the list of inputs and their types from
303  /// the given arguments.
304  ///
305  /// \param TC - The default host tool chain.
306  /// \param Args - The input arguments.
307  /// \param Inputs - The list to store the resulting compilation
308  /// inputs onto.
309  void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args,
310                   InputList &Inputs) const;
311
312  /// BuildActions - Construct the list of actions to perform for the
313  /// given arguments, which are only done for a single architecture.
314  ///
315  /// \param C - The compilation that is being built.
316  /// \param Args - The input arguments.
317  /// \param Actions - The list to store the resulting actions onto.
318  void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args,
319                    const InputList &Inputs, ActionList &Actions) const;
320
321  /// BuildUniversalActions - Construct the list of actions to perform
322  /// for the given arguments, which may require a universal build.
323  ///
324  /// \param C - The compilation that is being built.
325  /// \param TC - The default host tool chain.
326  void BuildUniversalActions(Compilation &C, const ToolChain &TC,
327                             const InputList &BAInputs) const;
328
329  /// BuildJobs - Bind actions to concrete tools and translate
330  /// arguments to form the list of jobs to run.
331  ///
332  /// \param C - The compilation that is being built.
333  void BuildJobs(Compilation &C) const;
334
335  /// ExecuteCompilation - Execute the compilation according to the command line
336  /// arguments and return an appropriate exit code.
337  ///
338  /// This routine handles additional processing that must be done in addition
339  /// to just running the subprocesses, for example reporting errors, setting
340  /// up response files, removing temporary files, etc.
341  int ExecuteCompilation(Compilation &C,
342     SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands);
343
344  /// generateCompilationDiagnostics - Generate diagnostics information
345  /// including preprocessed source file(s).
346  ///
347  void generateCompilationDiagnostics(Compilation &C,
348                                      const Command &FailingCommand);
349
350  /// @}
351  /// @name Helper Methods
352  /// @{
353
354  /// PrintActions - Print the list of actions.
355  void PrintActions(const Compilation &C) const;
356
357  /// PrintHelp - Print the help text.
358  ///
359  /// \param ShowHidden - Show hidden options.
360  void PrintHelp(bool ShowHidden) const;
361
362  /// PrintVersion - Print the driver version.
363  void PrintVersion(const Compilation &C, raw_ostream &OS) const;
364
365  /// GetFilePath - Lookup \p Name in the list of file search paths.
366  ///
367  /// \param TC - The tool chain for additional information on
368  /// directories to search.
369  //
370  // FIXME: This should be in CompilationInfo.
371  std::string GetFilePath(const char *Name, const ToolChain &TC) const;
372
373  /// GetProgramPath - Lookup \p Name in the list of program search paths.
374  ///
375  /// \param TC - The provided tool chain for additional information on
376  /// directories to search.
377  //
378  // FIXME: This should be in CompilationInfo.
379  std::string GetProgramPath(const char *Name, const ToolChain &TC) const;
380
381  /// HandleImmediateArgs - Handle any arguments which should be
382  /// treated before building actions or binding tools.
383  ///
384  /// \return Whether any compilation should be built for this
385  /// invocation.
386  bool HandleImmediateArgs(const Compilation &C);
387
388  /// ConstructAction - Construct the appropriate action to do for
389  /// \p Phase on the \p Input, taking in to account arguments
390  /// like -fsyntax-only or --analyze.
391  Action *ConstructPhaseAction(Compilation &C, const llvm::opt::ArgList &Args,
392                               phases::ID Phase, Action *Input) const;
393
394  /// BuildJobsForAction - Construct the jobs to perform for the action \p A and
395  /// return an InputInfo for the result of running \p A.  Will only construct
396  /// jobs for a given (Action, ToolChain, BoundArch) tuple once.
397  InputInfo BuildJobsForAction(Compilation &C, const Action *A,
398                               const ToolChain *TC, const char *BoundArch,
399                               bool AtTopLevel, bool MultipleArchs,
400                               const char *LinkingOutput,
401                               std::map<std::pair<const Action *, std::string>,
402                                        InputInfo> &CachedResults) const;
403
404  /// Returns the default name for linked images (e.g., "a.out").
405  const char *getDefaultImageName() const;
406
407  /// GetNamedOutputPath - Return the name to use for the output of
408  /// the action \p JA. The result is appended to the compilation's
409  /// list of temporary or result files, as appropriate.
410  ///
411  /// \param C - The compilation.
412  /// \param JA - The action of interest.
413  /// \param BaseInput - The original input file that this action was
414  /// triggered by.
415  /// \param BoundArch - The bound architecture.
416  /// \param AtTopLevel - Whether this is a "top-level" action.
417  /// \param MultipleArchs - Whether multiple -arch options were supplied.
418  const char *GetNamedOutputPath(Compilation &C,
419                                 const JobAction &JA,
420                                 const char *BaseInput,
421                                 const char *BoundArch,
422                                 bool AtTopLevel,
423                                 bool MultipleArchs) const;
424
425  /// GetTemporaryPath - Return the pathname of a temporary file to use
426  /// as part of compilation; the file will have the given prefix and suffix.
427  ///
428  /// GCC goes to extra lengths here to be a bit more robust.
429  std::string GetTemporaryPath(StringRef Prefix, const char *Suffix) const;
430
431  /// Return the pathname of the pch file in clang-cl mode.
432  std::string GetClPchPath(Compilation &C, StringRef BaseName) const;
433
434  /// ShouldUseClangCompiler - Should the clang compiler be used to
435  /// handle this action.
436  bool ShouldUseClangCompiler(const JobAction &JA) const;
437
438  /// Returns true if we are performing any kind of LTO.
439  bool isUsingLTO() const { return LTOMode != LTOK_None; }
440
441  /// Get the specific kind of LTO being performed.
442  LTOKind getLTOMode() const { return LTOMode; }
443
444private:
445  /// Parse the \p Args list for LTO options and record the type of LTO
446  /// compilation based on which -f(no-)?lto(=.*)? option occurs last.
447  void setLTOMode(const llvm::opt::ArgList &Args);
448
449  /// \brief Retrieves a ToolChain for a particular \p Target triple.
450  ///
451  /// Will cache ToolChains for the life of the driver object, and create them
452  /// on-demand.
453  const ToolChain &getToolChain(const llvm::opt::ArgList &Args,
454                                const llvm::Triple &Target) const;
455
456  /// @}
457
458  /// \brief Get bitmasks for which option flags to include and exclude based on
459  /// the driver mode.
460  std::pair<unsigned, unsigned> getIncludeExcludeOptionFlagMasks() const;
461
462  /// Helper used in BuildJobsForAction.  Doesn't use the cache when building
463  /// jobs specifically for the given action, but will use the cache when
464  /// building jobs for the Action's inputs.
465  InputInfo BuildJobsForActionNoCache(
466      Compilation &C, const Action *A, const ToolChain *TC,
467      const char *BoundArch, bool AtTopLevel, bool MultipleArchs,
468      const char *LinkingOutput,
469      std::map<std::pair<const Action *, std::string>, InputInfo>
470          &CachedResults) const;
471
472public:
473  /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
474  /// return the grouped values as integers. Numbers which are not
475  /// provided are set to 0.
476  ///
477  /// \return True if the entire string was parsed (9.2), or all
478  /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
479  /// groups were parsed but extra characters remain at the end.
480  static bool GetReleaseVersion(const char *Str, unsigned &Major,
481                                unsigned &Minor, unsigned &Micro,
482                                bool &HadExtra);
483
484  /// Parse digits from a string \p Str and fulfill \p Digits with
485  /// the parsed numbers. This method assumes that the max number of
486  /// digits to look for is equal to Digits.size().
487  ///
488  /// \return True if the entire string was parsed and there are
489  /// no extra characters remaining at the end.
490  static bool GetReleaseVersion(const char *Str,
491                                MutableArrayRef<unsigned> Digits);
492};
493
494/// \return True if the last defined optimization level is -Ofast.
495/// And False otherwise.
496bool isOptimizationLevelFast(const llvm::opt::ArgList &Args);
497
498} // end namespace driver
499} // end namespace clang
500
501#endif
502