clang  3.8.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  /// Auxiliary Target info.
83 
84  /// The virtual file system.
85  IntrusiveRefCntPtr<vfs::FileSystem> VirtualFileSystem;
86 
87  /// The file manager.
89 
90  /// The source manager.
92 
93  /// The preprocessor.
95 
96  /// The AST context.
98 
99  /// The AST consumer.
100  std::unique_ptr<ASTConsumer> Consumer;
101 
102  /// The code completion consumer.
103  std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
104 
105  /// \brief The semantic analysis object.
106  std::unique_ptr<Sema> TheSema;
107 
108  /// \brief The frontend timer group.
109  std::unique_ptr<llvm::TimerGroup> FrontendTimerGroup;
110 
111  /// \brief The frontend timer.
112  std::unique_ptr<llvm::Timer> FrontendTimer;
113 
114  /// \brief The ASTReader, if one exists.
115  IntrusiveRefCntPtr<ASTReader> ModuleManager;
116 
117  /// \brief The module dependency collector for crashdumps
118  std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;
119 
120  /// \brief The module provider.
121  std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;
122 
123  /// \brief The dependency file generator.
124  std::unique_ptr<DependencyFileGenerator> TheDependencyFileGenerator;
125 
126  std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;
127 
128  /// \brief The set of top-level modules that has already been loaded,
129  /// along with the module map
130  llvm::DenseMap<const IdentifierInfo *, Module *> KnownModules;
131 
132  /// \brief The location of the module-import keyword for the last module
133  /// import.
134  SourceLocation LastModuleImportLoc;
135 
136  /// \brief The result of the last module import.
137  ///
138  ModuleLoadResult LastModuleImportResult;
139 
140  /// \brief Whether we should (re)build the global module index once we
141  /// have finished with this translation unit.
142  bool BuildGlobalModuleIndex;
143 
144  /// \brief We have a full global module index, with all modules.
145  bool HaveFullGlobalModuleIndex;
146 
147  /// \brief One or more modules failed to build.
148  bool ModuleBuildFailed;
149 
150  /// \brief Holds information about the output file.
151  ///
152  /// If TempFilename is not empty we must rename it to Filename at the end.
153  /// TempFilename may be empty and Filename non-empty if creating the temporary
154  /// failed.
155  struct OutputFile {
156  std::string Filename;
157  std::string TempFilename;
158  std::unique_ptr<raw_ostream> OS;
159 
160  OutputFile(std::string filename, std::string tempFilename,
161  std::unique_ptr<raw_ostream> OS)
162  : Filename(std::move(filename)), TempFilename(std::move(tempFilename)),
163  OS(std::move(OS)) {}
164  OutputFile(OutputFile &&O)
165  : Filename(std::move(O.Filename)),
166  TempFilename(std::move(O.TempFilename)), OS(std::move(O.OS)) {}
167  };
168 
169  /// If the output doesn't support seeking (terminal, pipe). we switch
170  /// the stream to a buffer_ostream. These are the buffer and the original
171  /// stream.
172  std::unique_ptr<llvm::raw_fd_ostream> NonSeekStream;
173 
174  /// The list of active output files.
175  std::list<OutputFile> OutputFiles;
176 
177  CompilerInstance(const CompilerInstance &) = delete;
178  void operator=(const CompilerInstance &) = delete;
179 public:
180  explicit CompilerInstance(
181  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
182  std::make_shared<PCHContainerOperations>(),
183  bool BuildingModule = false);
184  ~CompilerInstance() override;
185 
186  /// @name High-Level Operations
187  /// {
188 
189  /// ExecuteAction - Execute the provided action against the compiler's
190  /// CompilerInvocation object.
191  ///
192  /// This function makes the following assumptions:
193  ///
194  /// - The invocation options should be initialized. This function does not
195  /// handle the '-help' or '-version' options, clients should handle those
196  /// directly.
197  ///
198  /// - The diagnostics engine should have already been created by the client.
199  ///
200  /// - No other CompilerInstance state should have been initialized (this is
201  /// an unchecked error).
202  ///
203  /// - Clients should have initialized any LLVM target features that may be
204  /// required.
205  ///
206  /// - Clients should eventually call llvm_shutdown() upon the completion of
207  /// this routine to ensure that any managed objects are properly destroyed.
208  ///
209  /// Note that this routine may write output to 'stderr'.
210  ///
211  /// \param Act - The action to execute.
212  /// \return - True on success.
213  //
214  // FIXME: This function should take the stream to write any debugging /
215  // verbose output to as an argument.
216  //
217  // FIXME: Eliminate the llvm_shutdown requirement, that should either be part
218  // of the context or else not CompilerInstance specific.
219  bool ExecuteAction(FrontendAction &Act);
220 
221  /// }
222  /// @name Compiler Invocation and Options
223  /// {
224 
225  bool hasInvocation() const { return Invocation != nullptr; }
226 
228  assert(Invocation && "Compiler instance has no invocation!");
229  return *Invocation;
230  }
231 
232  /// setInvocation - Replace the current invocation.
234 
235  /// \brief Indicates whether we should (re)build the global module index.
236  bool shouldBuildGlobalModuleIndex() const;
237 
238  /// \brief Set the flag indicating whether we should (re)build the global
239  /// module index.
240  void setBuildGlobalModuleIndex(bool Build) {
241  BuildGlobalModuleIndex = Build;
242  }
243 
244  /// }
245  /// @name Forwarding Methods
246  /// {
247 
249  return Invocation->getAnalyzerOpts();
250  }
251 
253  return Invocation->getCodeGenOpts();
254  }
256  return Invocation->getCodeGenOpts();
257  }
258 
260  return Invocation->getDependencyOutputOpts();
261  }
263  return Invocation->getDependencyOutputOpts();
264  }
265 
267  return Invocation->getDiagnosticOpts();
268  }
270  return Invocation->getDiagnosticOpts();
271  }
272 
274  return Invocation->getFileSystemOpts();
275  }
277  return Invocation->getFileSystemOpts();
278  }
279 
281  return Invocation->getFrontendOpts();
282  }
284  return Invocation->getFrontendOpts();
285  }
286 
288  return Invocation->getHeaderSearchOpts();
289  }
291  return Invocation->getHeaderSearchOpts();
292  }
293 
295  return *Invocation->getLangOpts();
296  }
297  const LangOptions &getLangOpts() const {
298  return *Invocation->getLangOpts();
299  }
300 
302  return Invocation->getPreprocessorOpts();
303  }
305  return Invocation->getPreprocessorOpts();
306  }
307 
309  return Invocation->getPreprocessorOutputOpts();
310  }
312  return Invocation->getPreprocessorOutputOpts();
313  }
314 
316  return Invocation->getTargetOpts();
317  }
318  const TargetOptions &getTargetOpts() const {
319  return Invocation->getTargetOpts();
320  }
321 
322  /// }
323  /// @name Diagnostics Engine
324  /// {
325 
326  bool hasDiagnostics() const { return Diagnostics != nullptr; }
327 
328  /// Get the current diagnostics engine.
330  assert(Diagnostics && "Compiler instance has no diagnostics!");
331  return *Diagnostics;
332  }
333 
334  /// setDiagnostics - Replace the current diagnostics engine.
336 
338  assert(Diagnostics && Diagnostics->getClient() &&
339  "Compiler instance has no diagnostic client!");
340  return *Diagnostics->getClient();
341  }
342 
343  /// }
344  /// @name Target Info
345  /// {
346 
347  bool hasTarget() const { return Target != nullptr; }
348 
350  assert(Target && "Compiler instance has no target!");
351  return *Target;
352  }
353 
354  /// Replace the current Target.
355  void setTarget(TargetInfo *Value);
356 
357  /// }
358  /// @name AuxTarget Info
359  /// {
360 
361  TargetInfo *getAuxTarget() const { return AuxTarget.get(); }
362 
363  /// Replace the current AuxTarget.
365 
366  /// }
367  /// @name Virtual File System
368  /// {
369 
370  bool hasVirtualFileSystem() const { return VirtualFileSystem != nullptr; }
371 
373  assert(hasVirtualFileSystem() &&
374  "Compiler instance has no virtual file system");
375  return *VirtualFileSystem;
376  }
377 
378  /// \brief Replace the current virtual file system.
379  ///
380  /// \note Most clients should use setFileManager, which will implicitly reset
381  /// the virtual file system to the one contained in the file manager.
383  VirtualFileSystem = FS;
384  }
385 
386  /// }
387  /// @name File Manager
388  /// {
389 
390  bool hasFileManager() const { return FileMgr != nullptr; }
391 
392  /// Return the current file manager to the caller.
394  assert(FileMgr && "Compiler instance has no file manager!");
395  return *FileMgr;
396  }
397 
399  BuryPointer(FileMgr.get());
400  FileMgr.resetWithoutRelease();
401  }
402 
403  /// \brief Replace the current file manager and virtual file system.
405 
406  /// }
407  /// @name Source Manager
408  /// {
409 
410  bool hasSourceManager() const { return SourceMgr != nullptr; }
411 
412  /// Return the current source manager.
414  assert(SourceMgr && "Compiler instance has no source manager!");
415  return *SourceMgr;
416  }
417 
419  BuryPointer(SourceMgr.get());
420  SourceMgr.resetWithoutRelease();
421  }
422 
423  /// setSourceManager - Replace the current source manager.
425 
426  /// }
427  /// @name Preprocessor
428  /// {
429 
430  bool hasPreprocessor() const { return PP != nullptr; }
431 
432  /// Return the current preprocessor.
434  assert(PP && "Compiler instance has no preprocessor!");
435  return *PP;
436  }
437 
439  BuryPointer(PP.get());
440  PP.resetWithoutRelease();
441  }
442 
443  /// Replace the current preprocessor.
445 
446  /// }
447  /// @name ASTContext
448  /// {
449 
450  bool hasASTContext() const { return Context != nullptr; }
451 
453  assert(Context && "Compiler instance has no AST context!");
454  return *Context;
455  }
456 
458  BuryPointer(Context.get());
459  Context.resetWithoutRelease();
460  }
461 
462  /// setASTContext - Replace the current AST context.
464 
465  /// \brief Replace the current Sema; the compiler instance takes ownership
466  /// of S.
467  void setSema(Sema *S);
468 
469  /// }
470  /// @name ASTConsumer
471  /// {
472 
473  bool hasASTConsumer() const { return (bool)Consumer; }
474 
476  assert(Consumer && "Compiler instance has no AST consumer!");
477  return *Consumer;
478  }
479 
480  /// takeASTConsumer - Remove the current AST consumer and give ownership to
481  /// the caller.
482  std::unique_ptr<ASTConsumer> takeASTConsumer() { return std::move(Consumer); }
483 
484  /// setASTConsumer - Replace the current AST consumer; the compiler instance
485  /// takes ownership of \p Value.
486  void setASTConsumer(std::unique_ptr<ASTConsumer> Value);
487 
488  /// }
489  /// @name Semantic analysis
490  /// {
491  bool hasSema() const { return (bool)TheSema; }
492 
493  Sema &getSema() const {
494  assert(TheSema && "Compiler instance has no Sema object!");
495  return *TheSema;
496  }
497 
498  std::unique_ptr<Sema> takeSema();
499  void resetAndLeakSema();
500 
501  /// }
502  /// @name Module Management
503  /// {
504 
507 
508  std::shared_ptr<ModuleDependencyCollector> getModuleDepCollector() const;
510  std::shared_ptr<ModuleDependencyCollector> Collector);
511 
512  std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const {
513  return ThePCHContainerOperations;
514  }
515 
516  /// Return the appropriate PCHContainerWriter depending on the
517  /// current CodeGenOptions.
519  assert(Invocation && "cannot determine module format without invocation");
520  StringRef Format = getHeaderSearchOpts().ModuleFormat;
521  auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
522  if (!Writer) {
523  if (Diagnostics)
524  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
525  llvm::report_fatal_error("unknown module format");
526  }
527  return *Writer;
528  }
529 
530  /// Return the appropriate PCHContainerReader depending on the
531  /// current CodeGenOptions.
533  assert(Invocation && "cannot determine module format without invocation");
534  StringRef Format = getHeaderSearchOpts().ModuleFormat;
535  auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);
536  if (!Reader) {
537  if (Diagnostics)
538  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
539  llvm::report_fatal_error("unknown module format");
540  }
541  return *Reader;
542  }
543 
544  /// }
545  /// @name Code Completion
546  /// {
547 
548  bool hasCodeCompletionConsumer() const { return (bool)CompletionConsumer; }
549 
551  assert(CompletionConsumer &&
552  "Compiler instance has no code completion consumer!");
553  return *CompletionConsumer;
554  }
555 
556  /// setCodeCompletionConsumer - Replace the current code completion consumer;
557  /// the compiler instance takes ownership of \p Value.
559 
560  /// }
561  /// @name Frontend timer
562  /// {
563 
564  bool hasFrontendTimer() const { return (bool)FrontendTimer; }
565 
566  llvm::Timer &getFrontendTimer() const {
567  assert(FrontendTimer && "Compiler instance has no frontend timer!");
568  return *FrontendTimer;
569  }
570 
571  /// }
572  /// @name Output Files
573  /// {
574 
575  /// addOutputFile - Add an output file onto the list of tracked output files.
576  ///
577  /// \param OutFile - The output file info.
578  void addOutputFile(OutputFile &&OutFile);
579 
580  /// clearOutputFiles - Clear the output file list, destroying the contained
581  /// output streams.
582  ///
583  /// \param EraseFiles - If true, attempt to erase the files from disk.
584  void clearOutputFiles(bool EraseFiles);
585 
586  /// }
587  /// @name Construction Utility Methods
588  /// {
589 
590  /// Create the diagnostics engine using the invocation's diagnostic options
591  /// and replace any existing one with it.
592  ///
593  /// Note that this routine also replaces the diagnostic client,
594  /// allocating one if one is not provided.
595  ///
596  /// \param Client If non-NULL, a diagnostic client that will be
597  /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
598  /// unit.
599  ///
600  /// \param ShouldOwnClient If Client is non-NULL, specifies whether
601  /// the diagnostic object should take ownership of the client.
602  void createDiagnostics(DiagnosticConsumer *Client = nullptr,
603  bool ShouldOwnClient = true);
604 
605  /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
606  ///
607  /// If no diagnostic client is provided, this creates a
608  /// DiagnosticConsumer that is owned by the returned diagnostic
609  /// object, if using directly the caller is responsible for
610  /// releasing the returned DiagnosticsEngine's client eventually.
611  ///
612  /// \param Opts - The diagnostic options; note that the created text
613  /// diagnostic object contains a reference to these options.
614  ///
615  /// \param Client If non-NULL, a diagnostic client that will be
616  /// attached to (and, then, owned by) the returned DiagnosticsEngine
617  /// object.
618  ///
619  /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
620  /// used by some diagnostics printers (for logging purposes only).
621  ///
622  /// \return The new object on success, or null on failure.
625  DiagnosticConsumer *Client = nullptr,
626  bool ShouldOwnClient = true,
627  const CodeGenOptions *CodeGenOpts = nullptr);
628 
629  /// Create the file manager and replace any existing one with it.
630  void createFileManager();
631 
632  /// Create the source manager and replace any existing one with it.
633  void createSourceManager(FileManager &FileMgr);
634 
635  /// Create the preprocessor, using the invocation, file, and source managers,
636  /// and replace any existing one with it.
638 
639  std::string getSpecificModuleCachePath();
640 
641  /// Create the AST context.
642  void createASTContext();
643 
644  /// Create an external AST source to read a PCH file and attach it to the AST
645  /// context.
646  void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation,
647  bool AllowPCHWithCompilerErrors,
648  void *DeserializationListener,
649  bool OwnDeserializationListener);
650 
651  /// Create an external AST source to read a PCH file.
652  ///
653  /// \return - The new object on success, or null on failure.
655  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
656  bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
657  const PCHContainerReader &PCHContainerRdr,
659  void *DeserializationListener, bool OwnDeserializationListener,
660  bool Preamble, bool UseGlobalModuleIndex);
661 
662  /// Create a code completion consumer using the invocation; note that this
663  /// will cause the source manager to truncate the input source file at the
664  /// completion point.
666 
667  /// Create a code completion consumer to print code completion results, at
668  /// \p Filename, \p Line, and \p Column, to the given output stream \p OS.
670  Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column,
671  const CodeCompleteOptions &Opts, raw_ostream &OS);
672 
673  /// \brief Create the Sema object to be used for parsing.
674  void createSema(TranslationUnitKind TUKind,
675  CodeCompleteConsumer *CompletionConsumer);
676 
677  /// Create the frontend timer and replace any existing one with it.
678  void createFrontendTimer();
679 
680  /// Create the default output file (from the invocation's options) and add it
681  /// to the list of tracked output files.
682  ///
683  /// The files created by this function always use temporary files to write to
684  /// their result (that is, the data is written to a temporary file which will
685  /// atomically replace the target output on success).
686  ///
687  /// \return - Null on error.
688  raw_pwrite_stream *createDefaultOutputFile(bool Binary = true,
689  StringRef BaseInput = "",
690  StringRef Extension = "");
691 
692  /// Create a new output file and add it to the list of tracked output files,
693  /// optionally deriving the output path name.
694  ///
695  /// \return - Null on error.
696  raw_pwrite_stream *createOutputFile(StringRef OutputPath, bool Binary,
697  bool RemoveFileOnSignal,
698  StringRef BaseInput, StringRef Extension,
699  bool UseTemporary,
700  bool CreateMissingDirectories = false);
701 
702  /// Create a new output file, optionally deriving the output path name.
703  ///
704  /// If \p OutputPath is empty, then createOutputFile will derive an output
705  /// path location as \p BaseInput, with any suffix removed, and \p Extension
706  /// appended. If \p OutputPath is not stdout and \p UseTemporary
707  /// is true, createOutputFile will create a new temporary file that must be
708  /// renamed to \p OutputPath in the end.
709  ///
710  /// \param OutputPath - If given, the path to the output file.
711  /// \param Error [out] - On failure, the error.
712  /// \param BaseInput - If \p OutputPath is empty, the input path name to use
713  /// for deriving the output path.
714  /// \param Extension - The extension to use for derived output names.
715  /// \param Binary - The mode to open the file in.
716  /// \param RemoveFileOnSignal - Whether the file should be registered with
717  /// llvm::sys::RemoveFileOnSignal. Note that this is not safe for
718  /// multithreaded use, as the underlying signal mechanism is not reentrant
719  /// \param UseTemporary - Create a new temporary file that must be renamed to
720  /// OutputPath in the end.
721  /// \param CreateMissingDirectories - When \p UseTemporary is true, create
722  /// missing directories in the output path.
723  /// \param ResultPathName [out] - If given, the result path name will be
724  /// stored here on success.
725  /// \param TempPathName [out] - If given, the temporary file path name
726  /// will be stored here on success.
727  std::unique_ptr<raw_pwrite_stream>
728  createOutputFile(StringRef OutputPath, std::error_code &Error, bool Binary,
729  bool RemoveFileOnSignal, StringRef BaseInput,
730  StringRef Extension, bool UseTemporary,
731  bool CreateMissingDirectories, std::string *ResultPathName,
732  std::string *TempPathName);
733 
734  llvm::raw_null_ostream *createNullOutputFile();
735 
736  /// }
737  /// @name Initialization Utility Methods
738  /// {
739 
740  /// InitializeSourceManager - Initialize the source manager to set InputFile
741  /// as the main file.
742  ///
743  /// \return True on success.
745 
746  /// InitializeSourceManager - Initialize the source manager to set InputFile
747  /// as the main file.
748  ///
749  /// \return True on success.
751  DiagnosticsEngine &Diags,
752  FileManager &FileMgr,
753  SourceManager &SourceMgr,
754  const FrontendOptions &Opts);
755 
756  /// }
757 
758  // Create module manager.
759  void createModuleManager();
760 
761  bool loadModuleFile(StringRef FileName);
762 
765  bool IsInclusionDirective) override;
766 
768  SourceLocation ImportLoc) override;
769 
772  }
773 
775 
776  bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override;
777 
778  void addDependencyCollector(std::shared_ptr<DependencyCollector> Listener) {
779  DependencyCollectors.push_back(std::move(Listener));
780  }
781 };
782 
783 } // end namespace clang
784 
785 #endif
LangOptions & getLangOpts()
ASTContext & getASTContext() const
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
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
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:36
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...
vfs::FileSystem & getVirtualFileSystem() const
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...
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)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file...
void setAuxTarget(TargetInfo *Value)
Replace the current AuxTarget.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
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:1307
DependencyOutputOptions & getDependencyOutputOpts()
const HeaderSearchOptions & getHeaderSearchOpts() const
The virtual file system interface.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
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:47
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.
This abstract interface provides operations for creating containers for serialized ASTs (precompiled ...
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)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value...
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
HeaderSearchOptions & getHeaderSearchOpts()
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Preprocessor & getPreprocessor() const
Return the current preprocessor.
AnalyzerOptionsRef getAnalyzerOpts()
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
bool hasVirtualFileSystem() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
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
StringRef Filename
Definition: Format.cpp:1723
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E).
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.
friend class ASTContext
Definition: Type.h:4012
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)
addOutputFile - Add an output file onto the list of tracked output files.
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
Check global module index for missing imports.
std::unique_ptr< Sema > takeSema()
bool hasSourceManager() const
FileSystemOptions & getFileSystemOpts()
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object...
const TargetOptions & getTargetOpts() const
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
AnnotatedLine & Line
Options for controlling the compiler diagnostics engine.
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
A global index for a set of module files, providing information about the identifiers within those mo...
TargetInfo * getAuxTarget() const
Abstract interface for a consumer of code-completion information.
Options controlling the behavior of code completion.
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)
clearOutputFiles - Clear the output file list, destroying the contained output streams.
void BuryPointer(const void *Ptr)
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
CodeCompleteConsumer & getCodeCompletionConsumer() const
void setTarget(TargetInfo *Value)
Replace the current Target.
Keeps track of options that affect how file operations are performed.
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
raw_pwrite_stream * createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
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:178
const FileSystemOptions & getFileSystemOpts() const
const StringRef Input
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Basic/Module.h:206
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
const CodeGenOptions & getCodeGenOpts() const
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
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.
raw_pwrite_stream * createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
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:1349
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96