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>(),
241 assert(Invocation &&
"Compiler instance has no invocation!");
256 BuildGlobalModuleIndex = Build;
266 return Invocation->getCodeGenOpts();
269 return Invocation->getCodeGenOpts();
273 return Invocation->getDependencyOutputOpts();
276 return Invocation->getDependencyOutputOpts();
280 return Invocation->getDiagnosticOpts();
283 return Invocation->getDiagnosticOpts();
287 return Invocation->getFileSystemOpts();
290 return Invocation->getFileSystemOpts();
294 return Invocation->getFrontendOpts();
297 return Invocation->getFrontendOpts();
301 return Invocation->getHeaderSearchOpts();
304 return Invocation->getHeaderSearchOpts();
307 return Invocation->getHeaderSearchOptsPtr();
312 return Invocation->getAPINotesOpts();
318 return Invocation->getLangOptsPtr();
322 return Invocation->getPreprocessorOpts();
325 return Invocation->getPreprocessorOpts();
329 return Invocation->getPreprocessorOutputOpts();
332 return Invocation->getPreprocessorOutputOpts();
336 return Invocation->getTargetOpts();
339 return Invocation->getTargetOpts();
350 assert(Diagnostics &&
"Compiler instance has no diagnostics!");
355 assert(Diagnostics &&
"Compiler instance has no diagnostics!");
363 assert(Diagnostics && Diagnostics->getClient() &&
364 "Compiler instance has no diagnostic client!");
365 return *Diagnostics->getClient();
380 return *VerboseOutputStream;
390 assert(
Target &&
"Compiler instance has no target!");
395 assert(
Target &&
"Compiler instance has no target!");
428 assert(FileMgr &&
"Compiler instance has no file manager!");
433 assert(FileMgr &&
"Compiler instance has no file manager!");
438 llvm::BuryPointer(FileMgr.get());
439 FileMgr.resetWithoutRelease();
453 assert(SourceMgr &&
"Compiler instance has no source manager!");
458 assert(SourceMgr &&
"Compiler instance has no source manager!");
463 llvm::BuryPointer(SourceMgr.get());
464 SourceMgr.resetWithoutRelease();
478 assert(PP &&
"Compiler instance has no preprocessor!");
485 llvm::BuryPointer(
new std::shared_ptr<Preprocessor>(PP));
498 assert(Context &&
"Compiler instance has no AST context!");
503 assert(Context &&
"Compiler instance has no AST context!");
508 llvm::BuryPointer(Context.get());
509 Context.resetWithoutRelease();
526 assert(Consumer &&
"Compiler instance has no AST consumer!");
541 bool hasSema()
const {
return (
bool)TheSema; }
544 assert(TheSema &&
"Compiler instance has no Sema object!");
560 std::shared_ptr<ModuleDependencyCollector> Collector);
563 return ThePCHContainerOperations;
569 assert(Invocation &&
"cannot determine module format without invocation");
571 auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
574 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
575 llvm::report_fatal_error(
"unknown module format");
583 assert(Invocation &&
"cannot determine module format without invocation");
585 auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);
588 Diagnostics->Report(diag::err_module_format_unhandled) << Format;
589 llvm::report_fatal_error(
"unknown module format");
601 assert(CompletionConsumer &&
602 "Compiler instance has no code completion consumer!");
603 return *CompletionConsumer;
617 assert(FrontendTimer &&
"Compiler instance has no frontend timer!");
618 return *FrontendTimer;
648 bool ShouldOwnClient =
true);
671 bool ShouldOwnClient =
true,
699 bool AllowPCHWithCompilerErrors,
void *DeserializationListener,
700 bool OwnDeserializationListener);
706 StringRef Path, StringRef Sysroot,
711 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
712 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
713 void *DeserializationListener,
bool OwnDeserializationListener,
714 bool Preamble,
bool UseGlobalModuleIndex);
744 bool Binary =
true, StringRef BaseInput =
"", StringRef Extension =
"",
745 bool RemoveFileOnSignal =
true,
bool CreateMissingDirectories =
false,
746 bool ForceUseTemporary =
false);
752 std::unique_ptr<raw_pwrite_stream>
753 createOutputFile(StringRef OutputPath,
bool Binary,
bool RemoveFileOnSignal,
754 bool UseTemporary,
bool CreateMissingDirectories =
false);
775 createOutputFileImpl(StringRef OutputPath,
bool Binary,
776 bool RemoveFileOnSignal,
bool UseTemporary,
777 bool CreateMissingDirectories);
804 OutputStream = std::move(OutStream);
808 return std::move(OutputStream);
831 bool IsInclusionDirective);
836 bool IsInclusionDirective)
override;
839 StringRef Source)
override;
853 DependencyCollectors.push_back(std::move(Listener));
Defines the Diagnostic-related interfaces.
llvm::MachO::Target Target
Defines the SourceManager interface.
Tracks various options which control how API notes are found and handled.
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 printDiagnosticStats()
At the end of a compilation, print the number of warnings/errors.
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)
std::shared_ptr< LangOptions > getLangOptsPtr() const
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()
const APINotesOptions & getAPINotesOpts() const
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
APINotesOptions & getAPINotesOpts()
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.
The JSON file list parser is used to communicate input to InstallAPI.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
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.