clang  3.7.0
CompilerInstance.h
Go to the documentation of this file.
1 //===-- CompilerInstance.h - Clang Compiler Instance ------------*- 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_FRONTEND_COMPILERINSTANCE_H_
11 #define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
12 
13 #include "clang/AST/ASTConsumer.h"
15 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Frontend/Utils.h"
19 #include "clang/Lex/ModuleLoader.h"
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/IntrusiveRefCntPtr.h"
23 #include "llvm/ADT/StringRef.h"
24 #include <cassert>
25 #include <list>
26 #include <memory>
27 #include <string>
28 #include <utility>
29 
30 namespace llvm {
31 class raw_fd_ostream;
32 class Timer;
33 class TimerGroup;
34 }
35 
36 namespace clang {
37 class ASTContext;
38 class ASTConsumer;
39 class ASTReader;
40 class CodeCompleteConsumer;
41 class DiagnosticsEngine;
42 class DiagnosticConsumer;
43 class ExternalASTSource;
44 class FileEntry;
45 class FileManager;
46 class FrontendAction;
47 class Module;
48 class Preprocessor;
49 class Sema;
50 class SourceManager;
51 class TargetInfo;
52 
53 /// CompilerInstance - Helper class for managing a single instance of the Clang
54 /// compiler.
55 ///
56 /// The CompilerInstance serves two purposes:
57 /// (1) It manages the various objects which are necessary to run the compiler,
58 /// for example the preprocessor, the target information, and the AST
59 /// context.
60 /// (2) It provides utility routines for constructing and manipulating the
61 /// common Clang objects.
62 ///
63 /// The compiler instance generally owns the instance of all the objects that it
64 /// manages. However, clients can still share objects by manually setting the
65 /// object and retaking ownership prior to destroying the CompilerInstance.
66 ///
67 /// The compiler instance is intended to simplify clients, but not to lock them
68 /// in to the compiler instance for everything. When possible, utility functions
69 /// come in two forms; a short form that reuses the CompilerInstance objects,
70 /// and a long form that takes explicit instances of any required objects.
72  /// The options used in this compiler instance.
74 
75  /// The diagnostics engine instance.
77 
78  /// The target being compiled for.
80 
81  /// The virtual file system.
82  IntrusiveRefCntPtr<vfs::FileSystem> VirtualFileSystem;
83 
84  /// The file manager.
86 
87  /// The source manager.
89 
90  /// The preprocessor.
92 
93  /// The AST context.
95 
96  /// The AST consumer.
97  std::unique_ptr<ASTConsumer> Consumer;
98 
99  /// The code completion consumer.
100  std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
101 
102  /// \brief The semantic analysis object.
103  std::unique_ptr<Sema> TheSema;
104 
105  /// \brief The frontend timer group.
106  std::unique_ptr<llvm::TimerGroup> FrontendTimerGroup;
107 
108  /// \brief The frontend timer.
109  std::unique_ptr<llvm::Timer> FrontendTimer;
110 
111  /// \brief The ASTReader, if one exists.
112  IntrusiveRefCntPtr<ASTReader> ModuleManager;
113 
114  /// \brief The module dependency collector for crashdumps
115  std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;
116 
117  /// \brief The module provider.
118  std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;
119 
120  /// \brief The dependency file generator.
121  std::unique_ptr<DependencyFileGenerator> TheDependencyFileGenerator;
122 
123  std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;
124 
125  /// \brief The set of top-level modules that has already been loaded,
126  /// along with the module map
127  llvm::DenseMap<const IdentifierInfo *, Module *> KnownModules;
128 
129  /// \brief Module names that have an override for the target file.
130  llvm::StringMap<std::string> ModuleFileOverrides;
131 
132  /// \brief Module files that we've explicitly loaded via \ref loadModuleFile,
133  /// and their dependencies.
134  llvm::StringSet<> ExplicitlyLoadedModuleFiles;
135 
136  /// \brief The location of the module-import keyword for the last module
137  /// import.
138  SourceLocation LastModuleImportLoc;
139 
140  /// \brief The result of the last module import.
141  ///
142  ModuleLoadResult LastModuleImportResult;
143 
144  /// \brief Whether we should (re)build the global module index once we
145  /// have finished with this translation unit.
146  bool BuildGlobalModuleIndex;
147 
148  /// \brief We have a full global module index, with all modules.
149  bool HaveFullGlobalModuleIndex;
150 
151  /// \brief One or more modules failed to build.
152  bool ModuleBuildFailed;
153 
154  /// \brief Holds information about the output file.
155  ///
156  /// If TempFilename is not empty we must rename it to Filename at the end.
157  /// TempFilename may be empty and Filename non-empty if creating the temporary
158  /// failed.
159  struct OutputFile {
160  std::string Filename;
161  std::string TempFilename;
162  std::unique_ptr<raw_ostream> OS;
163 
164  OutputFile(std::string filename, std::string tempFilename,
165  std::unique_ptr<raw_ostream> OS)
166  : Filename(std::move(filename)), TempFilename(std::move(tempFilename)),
167  OS(std::move(OS)) {}
168  OutputFile(OutputFile &&O)
169  : Filename(std::move(O.Filename)),
170  TempFilename(std::move(O.TempFilename)), OS(std::move(O.OS)) {}
171  };
172 
173  /// If the output doesn't support seeking (terminal, pipe). we switch
174  /// the stream to a buffer_ostream. These are the buffer and the original
175  /// stream.
176  std::unique_ptr<llvm::raw_fd_ostream> NonSeekStream;
177 
178  /// The list of active output files.
179  std::list<OutputFile> OutputFiles;
180 
181  CompilerInstance(const CompilerInstance &) = delete;
182  void operator=(const CompilerInstance &) = delete;
183 public:
184  explicit CompilerInstance(
185  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
186  std::make_shared<PCHContainerOperations>(),
187  bool BuildingModule = false);
188  ~CompilerInstance() override;
189 
190  /// @name High-Level Operations
191  /// {
192 
193  /// ExecuteAction - Execute the provided action against the compiler's
194  /// CompilerInvocation object.
195  ///
196  /// This function makes the following assumptions:
197  ///
198  /// - The invocation options should be initialized. This function does not
199  /// handle the '-help' or '-version' options, clients should handle those
200  /// directly.
201  ///
202  /// - The diagnostics engine should have already been created by the client.
203  ///
204  /// - No other CompilerInstance state should have been initialized (this is
205  /// an unchecked error).
206  ///
207  /// - Clients should have initialized any LLVM target features that may be
208  /// required.
209  ///
210  /// - Clients should eventually call llvm_shutdown() upon the completion of
211  /// this routine to ensure that any managed objects are properly destroyed.
212  ///
213  /// Note that this routine may write output to 'stderr'.
214  ///
215  /// \param Act - The action to execute.
216  /// \return - True on success.
217  //
218  // FIXME: This function should take the stream to write any debugging /
219  // verbose output to as an argument.
220  //
221  // FIXME: Eliminate the llvm_shutdown requirement, that should either be part
222  // of the context or else not CompilerInstance specific.
223  bool ExecuteAction(FrontendAction &Act);
224 
225  /// }
226  /// @name Compiler Invocation and Options
227  /// {
228 
229  bool hasInvocation() const { return Invocation != nullptr; }
230 
232  assert(Invocation && "Compiler instance has no invocation!");
233  return *Invocation;
234  }
235 
236  /// setInvocation - Replace the current invocation.
238 
239  /// \brief Indicates whether we should (re)build the global module index.
240  bool shouldBuildGlobalModuleIndex() const;
241 
242  /// \brief Set the flag indicating whether we should (re)build the global
243  /// module index.
244  void setBuildGlobalModuleIndex(bool Build) {
245  BuildGlobalModuleIndex = Build;
246  }
247 
248  /// }
249  /// @name Forwarding Methods
250  /// {
251 
253  return Invocation->getAnalyzerOpts();
254  }
255 
257  return Invocation->getCodeGenOpts();
258  }
260  return Invocation->getCodeGenOpts();
261  }
262 
264  return Invocation->getDependencyOutputOpts();
265  }
267  return Invocation->getDependencyOutputOpts();
268  }
269 
271  return Invocation->getDiagnosticOpts();
272  }
274  return Invocation->getDiagnosticOpts();
275  }
276 
278  return Invocation->getFileSystemOpts();
279  }
281  return Invocation->getFileSystemOpts();
282  }
283 
285  return Invocation->getFrontendOpts();
286  }
288  return Invocation->getFrontendOpts();
289  }
290 
292  return Invocation->getHeaderSearchOpts();
293  }
295  return Invocation->getHeaderSearchOpts();
296  }
297 
299  return *Invocation->getLangOpts();
300  }
301  const LangOptions &getLangOpts() const {
302  return *Invocation->getLangOpts();
303  }
304 
306  return Invocation->getPreprocessorOpts();
307  }
309  return Invocation->getPreprocessorOpts();
310  }
311 
313  return Invocation->getPreprocessorOutputOpts();
314  }
316  return Invocation->getPreprocessorOutputOpts();
317  }
318 
320  return Invocation->getTargetOpts();
321  }
322  const TargetOptions &getTargetOpts() const {
323  return Invocation->getTargetOpts();
324  }
325 
326  /// }
327  /// @name Diagnostics Engine
328  /// {
329 
330  bool hasDiagnostics() const { return Diagnostics != nullptr; }
331 
332  /// Get the current diagnostics engine.
334  assert(Diagnostics && "Compiler instance has no diagnostics!");
335  return *Diagnostics;
336  }
337 
338  /// setDiagnostics - Replace the current diagnostics engine.
340 
342  assert(Diagnostics && Diagnostics->getClient() &&
343  "Compiler instance has no diagnostic client!");
344  return *Diagnostics->getClient();
345  }
346 
347  /// }
348  /// @name Target Info
349  /// {
350 
351  bool hasTarget() const { return Target != nullptr; }
352 
354  assert(Target && "Compiler instance has no target!");
355  return *Target;
356  }
357 
358  /// Replace the current diagnostics engine.
359  void setTarget(TargetInfo *Value);
360 
361  /// }
362  /// @name Virtual File System
363  /// {
364 
365  bool hasVirtualFileSystem() const { return VirtualFileSystem != nullptr; }
366 
368  assert(hasVirtualFileSystem() &&
369  "Compiler instance has no virtual file system");
370  return *VirtualFileSystem;
371  }
372 
373  /// \brief Replace the current virtual file system.
374  ///
375  /// \note Most clients should use setFileManager, which will implicitly reset
376  /// the virtual file system to the one contained in the file manager.
378  VirtualFileSystem = FS;
379  }
380 
381  /// }
382  /// @name File Manager
383  /// {
384 
385  bool hasFileManager() const { return FileMgr != nullptr; }
386 
387  /// Return the current file manager to the caller.
389  assert(FileMgr && "Compiler instance has no file manager!");
390  return *FileMgr;
391  }
392 
394  BuryPointer(FileMgr.get());
395  FileMgr.resetWithoutRelease();
396  }
397 
398  /// \brief Replace the current file manager and virtual file system.
400 
401  /// }
402  /// @name Source Manager
403  /// {
404 
405  bool hasSourceManager() const { return SourceMgr != nullptr; }
406 
407  /// Return the current source manager.
409  assert(SourceMgr && "Compiler instance has no source manager!");
410  return *SourceMgr;
411  }
412 
414  BuryPointer(SourceMgr.get());
415  SourceMgr.resetWithoutRelease();
416  }
417 
418  /// setSourceManager - Replace the current source manager.
420 
421  /// }
422  /// @name Preprocessor
423  /// {
424 
425  bool hasPreprocessor() const { return PP != nullptr; }
426 
427  /// Return the current preprocessor.
429  assert(PP && "Compiler instance has no preprocessor!");
430  return *PP;
431  }
432 
434  BuryPointer(PP.get());
435  PP.resetWithoutRelease();
436  }
437 
438  /// Replace the current preprocessor.
440 
441  /// }
442  /// @name ASTContext
443  /// {
444 
445  bool hasASTContext() const { return Context != nullptr; }
446 
448  assert(Context && "Compiler instance has no AST context!");
449  return *Context;
450  }
451 
453  BuryPointer(Context.get());
454  Context.resetWithoutRelease();
455  }
456 
457  /// setASTContext - Replace the current AST context.
459 
460  /// \brief Replace the current Sema; the compiler instance takes ownership
461  /// of S.
462  void setSema(Sema *S);
463 
464  /// }
465  /// @name ASTConsumer
466  /// {
467 
468  bool hasASTConsumer() const { return (bool)Consumer; }
469 
471  assert(Consumer && "Compiler instance has no AST consumer!");
472  return *Consumer;
473  }
474 
475  /// takeASTConsumer - Remove the current AST consumer and give ownership to
476  /// the caller.
477  std::unique_ptr<ASTConsumer> takeASTConsumer() { return std::move(Consumer); }
478 
479  /// setASTConsumer - Replace the current AST consumer; the compiler instance
480  /// takes ownership of \p Value.
481  void setASTConsumer(std::unique_ptr<ASTConsumer> Value);
482 
483  /// }
484  /// @name Semantic analysis
485  /// {
486  bool hasSema() const { return (bool)TheSema; }
487 
488  Sema &getSema() const {
489  assert(TheSema && "Compiler instance has no Sema object!");
490  return *TheSema;
491  }
492 
493  std::unique_ptr<Sema> takeSema();
494  void resetAndLeakSema();
495 
496  /// }
497  /// @name Module Management
498  /// {
499 
502 
503  std::shared_ptr<ModuleDependencyCollector> getModuleDepCollector() const;
505  std::shared_ptr<ModuleDependencyCollector> Collector);
506 
507  std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const {
508  return ThePCHContainerOperations;
509  }
510 
511  /// Return the appropriate PCHContainerWriter depending on the
512  /// current CodeGenOptions.
514  assert(Invocation && "cannot determine module format without invocation");
515  StringRef Format = getHeaderSearchOpts().ModuleFormat;
516  auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
517  if (!Writer) {
518  if (Diagnostics)
519  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
520  llvm::report_fatal_error("unknown module format");
521  }
522  return *Writer;
523  }
524 
525  /// Return the appropriate PCHContainerReader depending on the
526  /// current CodeGenOptions.
528  assert(Invocation && "cannot determine module format without invocation");
529  StringRef Format = getHeaderSearchOpts().ModuleFormat;
530  auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);
531  if (!Reader) {
532  if (Diagnostics)
533  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
534  llvm::report_fatal_error("unknown module format");
535  }
536  return *Reader;
537  }
538 
539  /// }
540  /// @name Code Completion
541  /// {
542 
543  bool hasCodeCompletionConsumer() const { return (bool)CompletionConsumer; }
544 
546  assert(CompletionConsumer &&
547  "Compiler instance has no code completion consumer!");
548  return *CompletionConsumer;
549  }
550 
551  /// setCodeCompletionConsumer - Replace the current code completion consumer;
552  /// the compiler instance takes ownership of \p Value.
554 
555  /// }
556  /// @name Frontend timer
557  /// {
558 
559  bool hasFrontendTimer() const { return (bool)FrontendTimer; }
560 
561  llvm::Timer &getFrontendTimer() const {
562  assert(FrontendTimer && "Compiler instance has no frontend timer!");
563  return *FrontendTimer;
564  }
565 
566  /// }
567  /// @name Output Files
568  /// {
569 
570  /// addOutputFile - Add an output file onto the list of tracked output files.
571  ///
572  /// \param OutFile - The output file info.
573  void addOutputFile(OutputFile &&OutFile);
574 
575  /// clearOutputFiles - Clear the output file list, destroying the contained
576  /// output streams.
577  ///
578  /// \param EraseFiles - If true, attempt to erase the files from disk.
579  void clearOutputFiles(bool EraseFiles);
580 
581  /// }
582  /// @name Construction Utility Methods
583  /// {
584 
585  /// Create the diagnostics engine using the invocation's diagnostic options
586  /// and replace any existing one with it.
587  ///
588  /// Note that this routine also replaces the diagnostic client,
589  /// allocating one if one is not provided.
590  ///
591  /// \param Client If non-NULL, a diagnostic client that will be
592  /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
593  /// unit.
594  ///
595  /// \param ShouldOwnClient If Client is non-NULL, specifies whether
596  /// the diagnostic object should take ownership of the client.
597  void createDiagnostics(DiagnosticConsumer *Client = nullptr,
598  bool ShouldOwnClient = true);
599 
600  /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
601  ///
602  /// If no diagnostic client is provided, this creates a
603  /// DiagnosticConsumer that is owned by the returned diagnostic
604  /// object, if using directly the caller is responsible for
605  /// releasing the returned DiagnosticsEngine's client eventually.
606  ///
607  /// \param Opts - The diagnostic options; note that the created text
608  /// diagnostic object contains a reference to these options.
609  ///
610  /// \param Client If non-NULL, a diagnostic client that will be
611  /// attached to (and, then, owned by) the returned DiagnosticsEngine
612  /// object.
613  ///
614  /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
615  /// used by some diagnostics printers (for logging purposes only).
616  ///
617  /// \return The new object on success, or null on failure.
620  DiagnosticConsumer *Client = nullptr,
621  bool ShouldOwnClient = true,
622  const CodeGenOptions *CodeGenOpts = nullptr);
623 
624  /// Create the file manager and replace any existing one with it.
625  void createFileManager();
626 
627  /// Create the source manager and replace any existing one with it.
628  void createSourceManager(FileManager &FileMgr);
629 
630  /// Create the preprocessor, using the invocation, file, and source managers,
631  /// and replace any existing one with it.
633 
634  std::string getSpecificModuleCachePath();
635 
636  /// Create the AST context.
637  void createASTContext();
638 
639  /// Create an external AST source to read a PCH file and attach it to the AST
640  /// context.
641  void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation,
642  bool AllowPCHWithCompilerErrors,
643  void *DeserializationListener,
644  bool OwnDeserializationListener);
645 
646  /// Create an external AST source to read a PCH file.
647  ///
648  /// \return - The new object on success, or null on failure.
650  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
651  bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
652  const PCHContainerReader &PCHContainerRdr,
653  void *DeserializationListener, bool OwnDeserializationListener,
654  bool Preamble, bool UseGlobalModuleIndex);
655 
656  /// Create a code completion consumer using the invocation; note that this
657  /// will cause the source manager to truncate the input source file at the
658  /// completion point.
660 
661  /// Create a code completion consumer to print code completion results, at
662  /// \p Filename, \p Line, and \p Column, to the given output stream \p OS.
664  Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column,
665  const CodeCompleteOptions &Opts, raw_ostream &OS);
666 
667  /// \brief Create the Sema object to be used for parsing.
668  void createSema(TranslationUnitKind TUKind,
669  CodeCompleteConsumer *CompletionConsumer);
670 
671  /// Create the frontend timer and replace any existing one with it.
672  void createFrontendTimer();
673 
674  /// Create the default output file (from the invocation's options) and add it
675  /// to the list of tracked output files.
676  ///
677  /// The files created by this function always use temporary files to write to
678  /// their result (that is, the data is written to a temporary file which will
679  /// atomically replace the target output on success).
680  ///
681  /// \return - Null on error.
682  raw_pwrite_stream *createDefaultOutputFile(bool Binary = true,
683  StringRef BaseInput = "",
684  StringRef Extension = "");
685 
686  /// Create a new output file and add it to the list of tracked output files,
687  /// optionally deriving the output path name.
688  ///
689  /// \return - Null on error.
690  raw_pwrite_stream *createOutputFile(StringRef OutputPath, bool Binary,
691  bool RemoveFileOnSignal,
692  StringRef BaseInput, StringRef Extension,
693  bool UseTemporary,
694  bool CreateMissingDirectories = false);
695 
696  /// Create a new output file, optionally deriving the output path name.
697  ///
698  /// If \p OutputPath is empty, then createOutputFile will derive an output
699  /// path location as \p BaseInput, with any suffix removed, and \p Extension
700  /// appended. If \p OutputPath is not stdout and \p UseTemporary
701  /// is true, createOutputFile will create a new temporary file that must be
702  /// renamed to \p OutputPath in the end.
703  ///
704  /// \param OutputPath - If given, the path to the output file.
705  /// \param Error [out] - On failure, the error.
706  /// \param BaseInput - If \p OutputPath is empty, the input path name to use
707  /// for deriving the output path.
708  /// \param Extension - The extension to use for derived output names.
709  /// \param Binary - The mode to open the file in.
710  /// \param RemoveFileOnSignal - Whether the file should be registered with
711  /// llvm::sys::RemoveFileOnSignal. Note that this is not safe for
712  /// multithreaded use, as the underlying signal mechanism is not reentrant
713  /// \param UseTemporary - Create a new temporary file that must be renamed to
714  /// OutputPath in the end.
715  /// \param CreateMissingDirectories - When \p UseTemporary is true, create
716  /// missing directories in the output path.
717  /// \param ResultPathName [out] - If given, the result path name will be
718  /// stored here on success.
719  /// \param TempPathName [out] - If given, the temporary file path name
720  /// will be stored here on success.
721  std::unique_ptr<raw_pwrite_stream>
722  createOutputFile(StringRef OutputPath, std::error_code &Error, bool Binary,
723  bool RemoveFileOnSignal, StringRef BaseInput,
724  StringRef Extension, bool UseTemporary,
725  bool CreateMissingDirectories, std::string *ResultPathName,
726  std::string *TempPathName);
727 
728  llvm::raw_null_ostream *createNullOutputFile();
729 
730  /// }
731  /// @name Initialization Utility Methods
732  /// {
733 
734  /// InitializeSourceManager - Initialize the source manager to set InputFile
735  /// as the main file.
736  ///
737  /// \return True on success.
739 
740  /// InitializeSourceManager - Initialize the source manager to set InputFile
741  /// as the main file.
742  ///
743  /// \return True on success.
745  DiagnosticsEngine &Diags,
746  FileManager &FileMgr,
747  SourceManager &SourceMgr,
748  const FrontendOptions &Opts);
749 
750  /// }
751 
752  // Create module manager.
753  void createModuleManager();
754 
755  bool loadModuleFile(StringRef FileName);
756 
759  bool IsInclusionDirective) override;
760 
762  SourceLocation ImportLoc) override;
763 
766  }
767 
769 
770  bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override;
771 
772  void addDependencyCollector(std::shared_ptr<DependencyCollector> Listener) {
773  DependencyCollectors.push_back(std::move(Listener));
774  }
775 };
776 
777 } // end namespace clang
778 
779 #endif
LangOptions & getLangOpts()
ASTContext & getASTContext() const
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:115
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
vfs::FileSystem & getVirtualFileSystem() const
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Defines the SourceManager interface.
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Abstract base class for actions which can be performed by the frontend.
DiagnosticOptions & getDiagnosticOpts()
bool hasCodeCompletionConsumer() const
bool InitializeSourceManager(const FrontendInputFile &Input)
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
TargetInfo & getTarget() const
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
SourceManager & getSourceManager() const
Return the current source manager.
Options for controlling the target.
Definition: TargetOptions.h:24
const DependencyOutputOptions & getDependencyOutputOpts() const
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1309
DependencyOutputOptions & getDependencyOutputOpts()
const HeaderSearchOptions & getHeaderSearchOpts() const
The virtual file system interface.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
void createFileManager()
Create the file manager and replace any existing one with it.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
CodeGenOptions & getCodeGenOpts()
const PreprocessorOptions & getPreprocessorOpts() const
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
ASTConsumer & getASTConsumer() const
Describes a module or submodule.
Definition: Basic/Module.h:49
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override
Make the given module visible.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
FrontendOptions & getFrontendOpts()
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
DiagnosticConsumer & getDiagnosticClient() const
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
HeaderSearchOptions & getHeaderSearchOpts()
Preprocessor & getPreprocessor() const
Return the current preprocessor.
AnalyzerOptionsRef getAnalyzerOpts()
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
bool hasVirtualFileSystem() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
void setPreprocessor(Preprocessor *Value)
Replace the current preprocessor.
void setVirtualFileSystem(IntrusiveRefCntPtr< vfs::FileSystem > FS)
Replace the current virtual file system.
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:33
Exposes information about the current target.
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
bool hadModuleLoaderFatalFailure() const
void setInvocation(CompilerInvocation *Value)
setInvocation - Replace the current invocation.
std::string getSpecificModuleCachePath()
void createASTContext()
Create the AST context.
const FrontendOptions & getFrontendOpts() const
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
An input file for the front end.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
void addOutputFile(OutputFile &&OutFile)
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
std::unique_ptr< Sema > takeSema()
Options controlling the behavior of code completion.
bool hasSourceManager() const
FileSystemOptions & getFileSystemOpts()
bool ExecuteAction(FrontendAction &Act)
const TargetOptions & getTargetOpts() const
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
const PCHContainerReader & getPCHContainerReader() const
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
AnnotatedLine & Line
Options for controlling the compiler diagnostics engine.
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
void createPreprocessor(TranslationUnitKind TUKind)
A global index for a set of module files, providing information about the identifiers within those mo...
Abstract interface for a consumer of code-completion information.
bool hasFrontendTimer() const
llvm::raw_null_ostream * createNullOutputFile()
const LangOptions & getLangOpts() const
const DiagnosticOptions & getDiagnosticOpts() const
FileManager & getFileManager() const
Return the current file manager to the caller.
bool loadModuleFile(StringRef FileName)
Helper class for holding the data necessary to invoke the compiler.
FrontendOptions - Options for controlling the behavior of the frontend.
Abstract interface for a module loader.
Definition: ModuleLoader.h:56
Defines the Diagnostic-related interfaces.
void clearOutputFiles(bool EraseFiles)
void BuryPointer(const void *Ptr)
CodeCompleteConsumer & getCodeCompletionConsumer() const
void setTarget(TargetInfo *Value)
Replace the current diagnostics engine.
Keeps track of options that affect how file operations are performed.
const PCHContainerWriter & getPCHContainerWriter() const
raw_pwrite_stream * createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
llvm::Timer & getFrontendTimer() const
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:163
const FileSystemOptions & getFileSystemOpts() const
const StringRef Input
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Basic/Module.h:205
const CodeGenOptions & getCodeGenOpts() const
std::unique_ptr< ASTConsumer > takeASTConsumer()
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module. This function returns an existing global module index...
raw_pwrite_stream * createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
TargetOptions & getTargetOpts()
This class handles loading and caching of source files into memory.
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
std::string ModuleFormat
The module/pch container format.
unsigned Column
Definition: Format.cpp:1202
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96