9#ifndef LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
10#define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/DenseMap.h"
23#include "llvm/ADT/IntrusiveRefCntPtr.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/Support/BuryPointer.h"
26#include "llvm/Support/FileSystem.h"
44namespace serialization {
48class CodeCompleteConsumer;
49class DiagnosticsEngine;
50class DiagnosticConsumer;
53class InMemoryModuleCache;
81 std::shared_ptr<CompilerInvocation> Invocation;
102 std::shared_ptr<Preprocessor> PP;
111 std::unique_ptr<ASTConsumer> Consumer;
114 std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
117 std::unique_ptr<Sema> TheSema;
120 std::unique_ptr<llvm::TimerGroup> FrontendTimerGroup;
123 std::unique_ptr<llvm::Timer> FrontendTimer;
129 std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;
132 std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;
134 std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;
138 std::map<std::string, std::string, std::less<>> BuiltModules;
141 bool DeleteBuiltModules =
true;
153 bool BuildGlobalModuleIndex =
false;
156 bool HaveFullGlobalModuleIndex =
false;
159 bool DisableGeneratingGlobalModuleIndex =
false;
162 std::unique_ptr<raw_ostream> OwnedVerboseOutputStream;
165 raw_ostream *VerboseOutputStream = &llvm::errs();
174 std::optional<llvm::sys::fs::TempFile>
File;
176 OutputFile(std::string filename,
177 std::optional<llvm::sys::fs::TempFile> file)
178 :
Filename(std::move(filename)),
File(std::move(file)) {}
182 std::list<OutputFile> OutputFiles;
185 std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
191 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
192 std::make_shared<PCHContainerOperations>(),
238 assert(Invocation &&
"Compiler instance has no invocation!");
253 BuildGlobalModuleIndex = Build;
263 return Invocation->getCodeGenOpts();
266 return Invocation->getCodeGenOpts();
270 return Invocation->getDependencyOutputOpts();
273 return Invocation->getDependencyOutputOpts();
277 return Invocation->getDiagnosticOpts();
280 return Invocation->getDiagnosticOpts();
284 return Invocation->getFileSystemOpts();
287 return Invocation->getFileSystemOpts();
291 return Invocation->getFrontendOpts();
294 return Invocation->getFrontendOpts();
298 return Invocation->getHeaderSearchOpts();
301 return Invocation->getHeaderSearchOpts();
304 return Invocation->getHeaderSearchOptsPtr();
311 return Invocation->getPreprocessorOpts();
314 return Invocation->getPreprocessorOpts();
318 return Invocation->getPreprocessorOutputOpts();
321 return Invocation->getPreprocessorOutputOpts();
325 return Invocation->getTargetOpts();
328 return Invocation->getTargetOpts();
339 assert(Diagnostics &&
"Compiler instance has no diagnostics!");
344 assert(Diagnostics &&
"Compiler instance has no diagnostics!");
352 assert(Diagnostics && Diagnostics->getClient() &&
353 "Compiler instance has no diagnostic client!");
354 return *Diagnostics->getClient();
369 return *VerboseOutputStream;
379 assert(
Target &&
"Compiler instance has no target!");
384 assert(
Target &&
"Compiler instance has no target!");
417 assert(FileMgr &&
"Compiler instance has no file manager!");
422 assert(FileMgr &&
"Compiler instance has no file manager!");
427 llvm::BuryPointer(FileMgr.get());
428 FileMgr.resetWithoutRelease();
442 assert(SourceMgr &&
"Compiler instance has no source manager!");
447 assert(SourceMgr &&
"Compiler instance has no source manager!");
452 llvm::BuryPointer(SourceMgr.get());
453 SourceMgr.resetWithoutRelease();
467 assert(PP &&
"Compiler instance has no preprocessor!");
474 llvm::BuryPointer(
new std::shared_ptr<Preprocessor>(PP));
487 assert(Context &&
"Compiler instance has no AST context!");
492 assert(Context &&
"Compiler instance has no AST context!");
497 llvm::BuryPointer(Context.get());
498 Context.resetWithoutRelease();
515 assert(Consumer &&
"Compiler instance has no AST consumer!");
530 bool hasSema()
const {
return (
bool)TheSema; }
533 assert(TheSema &&
"Compiler instance has no Sema object!");
549 std::shared_ptr<ModuleDependencyCollector> Collector);
552 return ThePCHContainerOperations;
558 assert(Invocation &&
"cannot determine module format without invocation");
560 auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
563 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
564 llvm::report_fatal_error(
"unknown module format");
572 assert(Invocation &&
"cannot determine module format without invocation");
574 auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);
577 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
578 llvm::report_fatal_error(
"unknown module format");
590 assert(CompletionConsumer &&
591 "Compiler instance has no code completion consumer!");
592 return *CompletionConsumer;
606 assert(FrontendTimer &&
"Compiler instance has no frontend timer!");
607 return *FrontendTimer;
637 bool ShouldOwnClient =
true);
660 bool ShouldOwnClient =
true,
688 bool AllowPCHWithCompilerErrors,
void *DeserializationListener,
689 bool OwnDeserializationListener);
695 StringRef Path, StringRef Sysroot,
700 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
701 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
702 void *DeserializationListener,
bool OwnDeserializationListener,
703 bool Preamble,
bool UseGlobalModuleIndex);
733 bool Binary =
true, StringRef BaseInput =
"", StringRef Extension =
"",
734 bool RemoveFileOnSignal =
true,
bool CreateMissingDirectories =
false,
735 bool ForceUseTemporary =
false);
741 std::unique_ptr<raw_pwrite_stream>
742 createOutputFile(StringRef OutputPath,
bool Binary,
bool RemoveFileOnSignal,
743 bool UseTemporary,
bool CreateMissingDirectories =
false);
764 createOutputFileImpl(StringRef OutputPath,
bool Binary,
765 bool RemoveFileOnSignal,
bool UseTemporary,
766 bool CreateMissingDirectories);
793 OutputStream = std::move(OutStream);
797 return std::move(OutputStream);
820 bool IsInclusionDirective);
825 bool IsInclusionDirective)
override;
828 StringRef Source)
override;
842 DependencyCollectors.push_back(std::move(Listener));
Defines the Diagnostic-related interfaces.
Defines the SourceManager interface.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Stores options for the analyzer from the command line.
Abstract interface for a consumer of code-completion information.
Options controlling the behavior of code completion.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
void createPCHExternalASTSource(StringRef Path, DisableValidationForModuleKind DisableValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
DiagnosticConsumer & getDiagnosticClient() const
~CompilerInstance() override
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
AnalyzerOptions & getAnalyzerOpts()
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
Check global module index for missing imports.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...
FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
Create the file manager and replace any existing one with it.
const HeaderSearchOptions & getHeaderSearchOpts() const
DependencyOutputOptions & getDependencyOutputOpts()
bool hasFileManager() const
const DependencyOutputOptions & getDependencyOutputOpts() const
std::shared_ptr< Preprocessor > getPreprocessorPtr()
TargetInfo * getAuxTarget() const
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module.
raw_ostream & getVerboseOutputStream()
Get the current stream for verbose output.
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="", bool RemoveFileOnSignal=true, bool CreateMissingDirectories=false, bool ForceUseTemporary=false)
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)
const DiagnosticOptions & getDiagnosticOpts() const
std::string getSpecificModuleCachePath()
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
void setInvocation(std::shared_ptr< CompilerInvocation > Value)
setInvocation - Replace the current invocation.
const CodeGenOptions & getCodeGenOpts() const
FileSystemOptions & getFileSystemOpts()
llvm::Timer & getFrontendTimer() const
const TargetOptions & getTargetOpts() const
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file.
void setOutputStream(std::unique_ptr< llvm::raw_pwrite_stream > OutStream)
FileManager & getFileManager() const
Return the current file manager to the caller.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
IntrusiveRefCntPtr< DiagnosticsEngine > getDiagnosticsPtr() const
std::unique_ptr< Sema > takeSema()
const PreprocessorOptions & getPreprocessorOpts() const
void resetAndLeakSourceManager()
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value.
PreprocessorOutputOptions & getPreprocessorOutputOpts()
IntrusiveRefCntPtr< FileManager > getFileManagerPtr() const
IntrusiveRefCntPtr< ASTContext > getASTContextPtr() const
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
IntrusiveRefCntPtr< ASTReader > getASTReader() const
void setTarget(TargetInfo *Value)
Replace the current Target.
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
InMemoryModuleCache & getModuleCache() const
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
void createASTContext()
Create the AST context.
std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file, optionally deriving the output path name, and add it to the list of tracked...
bool hasASTContext() const
void createModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) override
Attempt to create the given module from the specified source buffer.
void resetAndLeakFileManager()
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
ASTContext & getASTContext() const
void LoadRequestedPlugins()
Load the list of plugins requested in the FrontendOptions.
TargetOptions & getTargetOpts()
IntrusiveRefCntPtr< TargetInfo > getTargetPtr() const
void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)
std::unique_ptr< llvm::raw_pwrite_stream > takeOutputStream()
bool hasInvocation() const
FrontendOptions & getFrontendOpts()
const FrontendOptions & getFrontendOpts() const
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
std::shared_ptr< CompilerInvocation > getInvocationPtr()
bool hasDiagnostics() const
bool hadModuleLoaderFatalFailure() const
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
HeaderSearchOptions & getHeaderSearchOpts()
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
bool hasCodeCompletionConsumer() const
void resetAndLeakASTContext()
bool hasFrontendTimer() const
const LangOptions & getLangOpts() const
CompilerInvocation & getInvocation()
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
void setVerboseOutputStream(raw_ostream &Value)
Replace the current stream for verbose output.
void resetAndLeakPreprocessor()
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
PreprocessorOptions & getPreprocessorOpts()
ASTConsumer & getASTConsumer() const
TargetInfo & getTarget() const
llvm::vfs::FileSystem & getVirtualFileSystem() const
const FileSystemOptions & getFileSystemOpts() const
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object.
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
DiagnosticOptions & getDiagnosticOpts()
LangOptions & getLangOpts()
CodeGenOptions & getCodeGenOpts()
SourceManager & getSourceManager() const
Return the current source manager.
IntrusiveRefCntPtr< SourceManager > getSourceManagerPtr() const
CodeCompleteConsumer & getCodeCompletionConsumer() const
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
bool hasSourceManager() const
bool hasASTConsumer() const
std::unique_ptr< raw_pwrite_stream > createNullOutputFile()
void setAuxTarget(TargetInfo *Value)
Replace the current AuxTarget.
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override
Make the given module visible.
bool loadModuleFile(StringRef FileName, serialization::ModuleFile *&LoadedModuleFile)
bool hasPreprocessor() const
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Helper class for holding the data necessary to invoke the compiler.
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Options for controlling the compiler diagnostics engine.
Concrete class used by the front-end to report problems and issues.
Implements support for file system lookup, file system caching, and directory search management.
Keeps track of options that affect how file operations are performed.
Abstract base class for actions which can be performed by the frontend.
FrontendOptions - Options for controlling the behavior of the frontend.
A global index for a set of module files, providing information about the identifiers within those mo...
In-memory cache for modules.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Describes the result of attempting to load a module.
Abstract interface for a module loader.
Describes a module or submodule.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
This abstract interface provides operations for creating containers for serialized ASTs (precompiled ...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Sema - This implements semantic analysis and AST building for C.
Encodes a location in the source.
This class handles loading and caching of source files into memory.
Exposes information about the current target.
Options for controlling the target.
Information about a module that has been loaded by the ASTReader.
Defines the clang::TargetInfo interface.
TranslationUnitKind
Describes the kind of translation unit being processed.
DisableValidationForModuleKind
Whether to disable the normal validation performed on precompiled headers and module files when they ...
Visibility
Describes the different kinds of visibility that a declaration may have.
YAML serialization mapping.