Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CompilerInstance_8cpp_source.html below:

clang: lib/Frontend/CompilerInstance.cpp Source File

;

CompilerInstance::CompilerInstance(

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

ModuleCache(SharedModuleCache ? SharedModuleCache

ThePCHContainerOperations(

::move(PCHContainerOps)) {}

assert(OutputFiles.empty() &&

);

std::shared_ptr<CompilerInvocation>

) {

Invocation = std::move(

);

(BuildGlobalModuleIndex ||

(TheASTReader && TheASTReader->isGlobalIndexUnavailable() &&

!DisableGeneratingGlobalModuleIndex;

OwnedVerboseOutputStream.reset();

VerboseOutputStream = &

;

OwnedVerboseOutputStream.swap(

);

VerboseOutputStream = OwnedVerboseOutputStream.get();

TO = std::make_shared<TargetOptions>();

PP = std::move(

);

(Context && Consumer)

Consumer = std::move(

);

(Context && Consumer)

CompletionConsumer.reset(

);

std::move(TheSema);

assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() &&

);

TheASTReader = std::move(Reader);

std::shared_ptr<ModuleDependencyCollector>

ModuleDepCollector;

std::shared_ptr<ModuleDependencyCollector> Collector) {

ModuleDepCollector = std::move(Collector);

std::shared_ptr<ModuleDependencyCollector> MDC) {

(

&Name : HeaderMapFileNames)

std::shared_ptr<ModuleDependencyCollector> MDC) {

MDC->addFile(PCHInclude);

llvm::sys::path::native(PCHDir->getName(), DirNative);

(llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;

Dir != DirEnd && !EC; Dir.increment(EC)) {

MDC->addFile(Dir->path());

std::shared_ptr<ModuleDependencyCollector> MDC) {

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =

llvm::MemoryBuffer::getFile(VFSFile);

llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),

, VFSFile, VFSEntries);

(

&

: VFSEntries)

MDC->addFile(

.VPath,

.RPath);

std::unique_ptr<raw_ostream> StreamOwner;

raw_ostream *OS = &llvm::errs();

FileOS = std::make_unique<llvm::raw_fd_ostream>(

llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF);

Diags.

(diag::warn_fe_cc_log_diagnostics_failure)

FileOS->SetUnbuffered();

StreamOwner = std::move(FileOS);

Logger = std::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,

std::move(StreamOwner));

StringRef OutputFile) {

SerializedConsumer =

Diags.

(), std::move(SerializedConsumer)));

Diags.

(), std::move(SerializedConsumer)));

ShouldOwnClient) {

Diags->setClient(Client, ShouldOwnClient);

(Opts->VerifyDiagnostics)

VFS = FileMgr ? &FileMgr->getVirtualFileSystem()

assert(VFS &&

);

llvm::makeIntrusiveRefCnt<llvm::vfs::TracingFileSystem>(std::move(VFS));

FileMgr.get();

FromFile, std::unique_ptr<llvm::MemoryBuffer>(RB.second));

Diags.

(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;

TheASTReader.reset();

PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(),

PP->createPreprocessingRecord();

PP->getFileManager(), PPOpts);

llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();

(PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&

PP->getAuxTargetInfo())

HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();

PP->getLangOpts(), *HeaderSearchTriple);

(PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) {

PP->getHeaderSearchInfo().setModuleHash(ModuleHash);

PP->getHeaderSearchInfo().setModuleCachePath(

ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(

(ModuleDepCollector) {

(

&Listener : DependencyCollectors)

Listener->attachToPreprocessor(*PP);

(OutputPath ==

)

llvm::sys::path::append(SpecificModuleCache, ModuleHash);

std::string(SpecificModuleCache);

ReadModuleName(StringRef ModuleName)

{

LoadedModules.push_back(ModuleName.str());

(

std::string &LoadedModule : LoadedModules)

LoadedModules.clear();

markAllUnavailable() {

(

std::string &LoadedModule : LoadedModules) {

M->HasIncompatibleModuleFile =

;

(!Stack.empty()) {

*Current = Stack.pop_back_val();

(Current->IsUnimportable)

;

Current->IsAvailable =

;

SubmodulesRange = Current->submodules();

Stack.insert(Stack.end(), SubmodulesRange.begin(),

SubmodulesRange.end());

LoadedModules.clear();

AllowPCHWithCompilerErrors,

*DeserializationListener,

OwnDeserializationListener) {

DeserializationListener, OwnDeserializationListener,

,

StringRef

, StringRef Sysroot,

<std::shared_ptr<ModuleFileExtension>> Extensions,

<std::shared_ptr<DependencyCollector>> DependencyCollectors,

*DeserializationListener,

OwnDeserializationListener,

,

UseGlobalModuleIndex) {

PP, ModuleCache, &Context, PCHContainerRdr, Extensions,

Sysroot.empty() ?

: Sysroot.data(), DisableValidation,

AllowPCHWithCompilerErrors,

,

UseGlobalModuleIndex));

Reader->setDeserializationListener(

OwnDeserializationListener);

(

&Listener : DependencyCollectors)

Listener->attachToASTReader(*Reader);

Listener = std::make_unique<ReadModuleNames>(PP);

&ListenerRef = *Listener;

std::move(Listener));

(Reader->ReadAST(

,

ListenerRef.registerAll();

ListenerRef.markAllUnavailable();

(!CompletionConsumer) {

.Line,

.Column)) {

timerGroup.reset(

llvm::TimerGroup(

,

));

FrontendTimer.reset(

llvm::Timer(

,

, *timerGroup));

TUKind, CompletionConsumer));

(ExternalSemaSrc) {

TheSema->addExternalSource(ExternalSemaSrc.get());

ExternalSemaSrc->InitializeSema(*TheSema);

(void)TheSema->APINotes.loadCurrentModuleAPINotes(

(OutputFile &OF : OutputFiles) {

consumeError(OF.File->discard());

(!OF.Filename.empty())

llvm::sys::fs::remove(OF.Filename);

(OF.File->TmpName.empty()) {

consumeError(OF.File->discard());

llvm::Error

= OF.File->keep(OF.Filename);

<< OF.File->TmpName << OF.Filename << std::move(

);

llvm::sys::fs::remove(OF.File->TmpName);

(DeleteBuiltModules) {

(

&

: BuiltModules)

llvm::sys::fs::remove(

.second);

BuiltModules.clear();

Binary, StringRef InFile, StringRef Extension,

RemoveFileOnSignal,

CreateMissingDirectories,

ForceUseTemporary) {

std::optional<SmallString<128>> PathStorage;

(OutputPath.empty()) {

(InFile ==

|| Extension.empty()) {

PathStorage.emplace(InFile);

llvm::sys::path::replace_extension(*PathStorage, Extension);

OutputPath = *PathStorage;

CreateMissingDirectories);

std::make_unique<llvm::raw_null_ostream>();

std::unique_ptr<raw_pwrite_stream>

RemoveFileOnSignal,

UseTemporary,

CreateMissingDirectories) {

createOutputFileImpl(OutputPath, Binary, RemoveFileOnSignal, UseTemporary,

CreateMissingDirectories);

std::move(*OS);

<< OutputPath << errorToErrorCode(OS.takeError()).message();

CompilerInstance::createOutputFileImpl(StringRef OutputPath,

Binary,

RemoveFileOnSignal,

CreateMissingDirectories) {

assert((!CreateMissingDirectories || UseTemporary) &&

);

std::optional<SmallString<128>> AbsPath;

(OutputPath !=

&& !llvm::sys::path::is_absolute(OutputPath)) {

);

AbsPath.emplace(OutputPath);

FileMgr->FixupRelativePath(*AbsPath);

OutputPath = *AbsPath;

std::unique_ptr<llvm::raw_fd_ostream> OS;

std::optional<StringRef> OSFile;

(OutputPath ==

)

UseTemporary =

;

llvm::sys::fs::file_status Status;

llvm::sys::fs::status(OutputPath, Status);

(llvm::sys::fs::exists(Status)) {

(!llvm::sys::fs::can_write(OutputPath))

llvm::errorCodeToError(

(!llvm::sys::fs::is_regular_file(Status))

UseTemporary =

;

std::optional<llvm::sys::fs::TempFile> Temp;

StringRef OutputExtension = llvm::sys::path::extension(OutputPath);

StringRef(OutputPath).drop_back(OutputExtension.size());

TempPath +=

;

TempPath += OutputExtension;

llvm::sys::fs::OpenFlags BinaryFlags =

? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text;

llvm::sys::fs::TempFile::create(

TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write,

llvm::Error

= handleErrors(

ExpectedFile.takeError(), [&](

llvm::ECError &

) -> llvm::Error {

std::error_code EC = E.convertToErrorCode();

if (CreateMissingDirectories &&

EC == llvm::errc::no_such_file_or_directory) {

StringRef Parent = llvm::sys::path::parent_path(OutputPath);

EC = llvm::sys::fs::create_directories(Parent);

ExpectedFile = llvm::sys::fs::TempFile::create(

TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write,

return llvm::errorCodeToError(

llvm::errc::no_such_file_or_directory);

llvm::errorCodeToError(EC);

consumeError(std::move(

));

Temp = std::move(ExpectedFile.get());

OS.reset(

llvm::raw_fd_ostream(Temp->FD,

));

OSFile = Temp->TmpName;

OS.reset(

llvm::raw_fd_ostream(

(Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));

llvm::errorCodeToError(EC);

OutputFiles.emplace_back(((OutputPath !=

) ? OutputPath :

).str(),

(!Binary || OS->supportsSeeking())

std::move(OS);

std::make_unique<llvm::buffer_unique_ostream>(std::move(OS));

);

StringRef InputFile = Input.

();

FileOrErr = InputFile ==

EC = llvm::errorToErrorCode(FileOrErr.takeError());

(InputFile !=

)

Diags.

(diag::err_fe_error_reading) << InputFile << EC.message();

Diags.

(diag::err_fe_error_reading_stdin) << EC.message();

);

assert(

() &&

);

assert(!

().ShowHelp &&

);

assert(!

().ShowVersion &&

);

FinishDiagnosticClient = llvm::make_scope_exit([&]() {

OS <<

CLANG_VERSION_STRING <<

<< LLVM_VERSION_STRING <<

<< llvm::sys::getDefaultTargetTriple() <<

;

llvm::EnableStatistics(

);

(llvm::Error Err = Act.

()) {

consumeError(std::move(Err));

llvm::PrintStatistics(OS);

(!StatsFile.empty()) {

llvm::sys::fs::OpenFlags FileFlags = llvm::sys::fs::OF_TextWithCRLF;

FileFlags |= llvm::sys::fs::OF_Append;

std::make_unique<llvm::raw_fd_ostream>(StatsFile, EC, FileFlags);

<< StatsFile << EC.message();

llvm::PrintStatisticsJSON(*StatS);

OS << NumWarnings <<

<< (NumWarnings == 1 ?

:

);

(NumWarnings && NumErrors)

OS << NumErrors <<

<< (NumErrors == 1 ?

:

);

(NumWarnings || NumErrors) {

OS <<

;

OS <<

;

(llvm::sys::DynamicLibrary::LoadLibraryPermanently(

.c_str(), &Error))

(

FrontendPluginRegistry::entry &Plugin :

FrontendPluginRegistry::entries()) {

std::unique_ptr<PluginASTAction>

(Plugin.instantiate());

(LangOpts.OpenCL)

StringRef OriginalModuleMapFile, StringRef ModuleFileName,

llvm::TimeTraceScope TimeScope(

, ModuleName);

ImportLoc, diag::err_module_rebuild_finalized)

std::make_shared<CompilerInvocation>(ImportingInstance.

());

llvm::erase_if(PPOpts.

,

[&HSOpts](

std::pair<std::string, bool> &def) {

StringRef MacroDef = def.first;

return HSOpts.ModulesIgnoreMacros.contains(

llvm::CachedHashString(MacroDef.split(

).first));

Invocation->getLangOpts().ModuleName =

Invocation->getLangOpts().CurrentModule = std::string(ModuleName);

FrontendOpts.

= ModuleFileName.str();

FrontendOpts.

= {Input};

DiagOpts.VerifyDiagnostics = 0;

Invocation->getModuleHash() &&

);

&

= *Invocation;

Instance.setInvocation(std::move(Invocation));

Instance.createDiagnostics(

Instance.getDiagnostics().setSuppressSystemWarnings(

);

Instance.createSourceManager(Instance.getFileManager());

diag::remark_module_build)

<< ModuleName << ModuleFileName;

PreBuildStep(Instance);

Crashed = !llvm::CrashRecoveryContext().RunSafelyOnThread(

Instance.ExecuteAction(Action);

PostBuildStep(Instance);

diag::remark_module_build_done)

Instance.setSema(

);

Instance.setASTConsumer(

);

Instance.clearOutputFiles(

);

!Instance.getDiagnostics().hasErrorOccurred() ||

Instance.getFrontendOpts().AllowPCMWithCompilerErrors;

StringRef

= llvm::sys::path::filename(

.getName());

(

==

)

llvm::sys::path::append(PublicFilename,

);

(

==

)

llvm::sys::path::append(PublicFilename,

);

std::nullopt;

StringRef ModuleFileName) {

assert(ModuleMapFile &&

);

ModuleMapFile = PublicMMFile;

llvm::sys::path::append(FakeModuleMapFile,

);

std::string InferredModuleMapContent;

llvm::raw_string_ostream OS(InferredModuleMapContent);

std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =

llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);

FileEntryRef ModuleMapFile = Instance.getFileManager().getVirtualFileRef(

FakeModuleMapFile, InferredModuleMapContent.size(), 0);

Instance.getSourceManager().overrideFileContents(

ModuleMapFile, std::move(ModuleMapBuffer));

ModuleLoadCapabilities);

Diags.

(ModuleNameLoc, diag::err_module_not_built)

StringRef ModuleFileName) {

diag::err_module_not_built)

Diags.

(ModuleNameLoc, diag::remark_module_lock)

StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);

llvm::sys::fs::create_directories(Dir);

llvm::LockFileManager Locked(ModuleFileName);

llvm::LockFileManager::LFS_Error:

Diags.

(ModuleNameLoc, diag::remark_module_lock_failure)

<<

->

<< Locked.getErrorMessage();

Locked.unsafeRemoveLockFile();

llvm::LockFileManager::LFS_Owned:

ModuleNameLoc,

, ModuleFileName);

llvm::LockFileManager::LFS_Shared:

(Locked.waitForUnlock()) {

llvm::LockFileManager::Res_Success:

llvm::LockFileManager::Res_OwnerDied:

llvm::LockFileManager::Res_Timeout:

Diags.

(ModuleNameLoc, diag::remark_module_lock_timeout)

Locked.unsafeRemoveLockFile();

OutOfDate =

;

, ModuleFileName, &OutOfDate))

(!

->hadMacroDefinition())

*CmdLineDefinition =

;

(

*MD = LatestLocalMD; MD; MD = MD->getPrevious()) {

(

*DMD = dyn_cast<DefMacroDirective>(MD))

CmdLineDefinition = DMD->getMacroInfo();

(CurrentDefinition == CmdLineDefinition) {

}

(!CurrentDefinition) {

PP.

(ImportLoc, diag::warn_module_config_macro_undef)

LatestDef = LatestLocalMD->getDefinition();

assert(LatestDef.isUndefined() &&

);

PP.

(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)

}

(!CmdLineDefinition) {

PP.

(ImportLoc, diag::warn_module_config_macro_undef)

PP.

(CurrentDefinition->getDefinitionLoc(),

diag::note_module_def_undef_here)

}

(!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,

PP.

(ImportLoc, diag::warn_module_config_macro_undef)

PP.

(CurrentDefinition->getDefinitionLoc(),

diag::note_module_def_undef_here)

(

StringRef ConMacro : TopModule->

) {

llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None);

llvm::sys::fs::file_status StatBuf;

assert(!TimestampFile.empty());

llvm::sys::path::append(TimestampFile,

);

(std::error_code EC = llvm::sys::fs::status(TimestampFile, StatBuf)) {

(EC == std::errc::no_such_file_or_directory) {

time_t TimeStampModTime =

llvm::sys::toTimeT(StatBuf.getLastModificationTime());

time_t CurrentTime = time(

);

(llvm::sys::fs::directory_iterator Dir(HSOpts.

, EC),

Dir != DirEnd && !EC; Dir.increment(EC)) {

(!llvm::sys::fs::is_directory(Dir->path()))

(llvm::sys::fs::directory_iterator

(Dir->path(), EC), FileEnd;

!= FileEnd && !EC;

.increment(EC)) {

StringRef Extension = llvm::sys::path::extension(

->path());

(Extension !=

&& Extension !=

&&

llvm::sys::path::filename(

->path()) !=

)

(llvm::sys::fs::status(

->path(), StatBuf))

time_t FileAccessTime = llvm::sys::toTimeT(StatBuf.getLastAccessedTime());

(CurrentTime - FileAccessTime <=

llvm::sys::fs::remove(

->path());

std::string TimpestampFilename =

->path() +

;

llvm::sys::fs::remove(TimpestampFilename);

(llvm::sys::fs::directory_iterator(Dir->path(), EC) ==

llvm::sys::fs::directory_iterator() && !EC)

llvm::sys::fs::remove(Dir->path());

!

().getHeaderSearchInfo().getModuleCachePath().empty() &&

std::string Sysroot = HSOpts.

;

std::unique_ptr<llvm::Timer> ReadTimer;

ReadTimer = std::make_unique<llvm::Timer>(

,

, *timerGroup);

Sysroot.empty() ?

: Sysroot.c_str(),

TheASTReader->setDeserializationListener(

TheASTReader->InitializeSema(

());

(

&Listener : DependencyCollectors)

Listener->attachToASTReader(*TheASTReader);

Timer.init(

+

.str(),

+

.str(),

llvm::TimeRegion TimeLoading(timerGroup ? &Timer :

);

ConfigMismatchIsRecoverable =

Listener = std::make_unique<ReadModuleNames>(*PP);

&ListenerRef = *Listener;

std::move(Listener));

(TheASTReader->ReadAST(

&LoadedModuleFile)) {

ListenerRef.registerAll();

ListenerRef.markAllUnavailable();

MS_PrebuiltModulePath,

MS_ModuleBuildPragma

*M, StringRef ModuleName, std::string &ModuleFilename,

std::map<std::string, std::string, std::less<>> &BuiltModules,

assert(ModuleFilename.empty() &&

);

BuiltModuleIt = BuiltModules.find(ModuleName);

(BuiltModuleIt != BuiltModules.end()) {

ModuleFilename = BuiltModuleIt->second;

MS_ModuleBuildPragma;

(!ModuleFilename.empty())

MS_PrebuiltModulePath;

MS_ModuleCache;

MS_ModuleNotFound;

HS.

(ModuleName, ImportLoc,

, !IsInclusionDirective);

std::string ModuleFilename;

ModuleSource Source =

(Source == MS_ModuleNotFound) {

<< ModuleName <<

(ImportLoc, ModuleNameLoc);

(ModuleFilename.empty()) {

Timer.init(

+ ModuleFilename,

+ ModuleFilename,

llvm::TimeRegion TimeLoading(timerGroup ? &Timer :

);

llvm::TimeTraceScope TimeScope(

, ModuleName);

ARRFlags = Source == MS_ModuleCache

: Source == MS_PrebuiltModulePath

Source == MS_PrebuiltModulePath

: Source == MS_ModuleBuildPragma

ImportLoc, ARRFlags)) {

assert(Source != MS_ModuleCache &&

);

M = HS.

(ModuleName, ImportLoc,

, !IsInclusionDirective);

(

ModuleFile = FileMgr->getOptionalFileRef(ModuleFilename))

(Source == MS_PrebuiltModulePath)

diag::warn_module_config_mismatch)

(Source != MS_ModuleCache) {

assert(M &&

);

ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();

(; Pos != PosEnd; ++Pos) {

(Pos->first == ModuleName)

(Pos != PosEnd) {

(; Pos != PosEnd; ++Pos) {

CyclePath += Pos->first;

CyclePath +=

;

CyclePath += ModuleName;

<< ModuleName << CyclePath;

(FailedModules && FailedModules->hasAlreadyFailed(ModuleName)) {

<< ModuleName <<

(ImportLoc, ModuleNameLoc);

);

FailedModules->addFailed(ModuleName);

IsInclusionDirective) {

StringRef ModuleName =

[0].first->getName();

(ImportLoc.

() && LastModuleImportLoc == ImportLoc) {

(LastModuleImportResult && ModuleName !=

().CurrentModule)

TheASTReader->makeModuleVisible(LastModuleImportResult,

,

LastModuleImportResult;

}

(ModuleName ==

().CurrentModule) {

ModuleName, ImportLoc,

,

!IsInclusionDirective);

ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);

(!

.isNormal())

DisableGeneratingGlobalModuleIndex =

;

MapPrivateSubModToTopLevel =

;

(

I = 1, N =

.size(); I != N; ++I) {

StringRef Name =

[I].first->getName();

PrivateModule.append(

);

PrivPath.push_back(std::make_pair(&II,

[0].second));

!IsInclusionDirective) ||

MapPrivateSubModToTopLevel =

;

diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {

diag::warn_no_priv_submodule_use_toplevel)

diag::note_private_top_level_defined);

BestEditDistance = (std::numeric_limits<unsigned>::max)();

Name.edit_distance(SubModule->Name,

, BestEditDistance);

(ED <= BestEditDistance) {

(ED < BestEditDistance) {

BestEditDistance = ED;

Best.push_back(SubModule->Name);

(Best.size() == 1) {

LastModuleImportLoc = ImportLoc;

LastModuleImportLoc = ImportLoc;

LastModuleImportResult;

StringRef ModuleName,

(

&

: CleanModuleName)

(std::error_code EC = llvm::sys::fs::createTemporaryFile(

CleanModuleName,

, ModuleFileName)) {

<< ModuleFileName << EC.message();

std::string ModuleMapFileName = (CleanModuleName +

).str();

std::string NullTerminatedSource(Source.str());

ModuleMapFileName, NullTerminatedSource.size(), 0);

.getSourceManager().overrideFileContents(

ModuleMapFile, llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource));

.BuiltModules = std::move(BuiltModules);

.DeleteBuiltModules =

;

BuiltModules = std::move(

.BuiltModules);

ModuleFileName, PreBuildStep, PostBuildStep)) {

BuiltModules[std::string(ModuleName)] = std::string(ModuleFileName);

llvm::sys::RemoveFileOnSignal(ModuleFileName);

TheASTReader->makeModuleVisible(Mod,

, ImportLoc);

(

().getHeaderSearchInfo().getModuleCachePath().empty())

TheASTReader->loadGlobalIndex();

llvm::sys::fs::create_directories(

consumeError(std::move(Err));

TheASTReader->resetForReload();

TheASTReader->loadGlobalIndex();

GlobalIndex = TheASTReader->getGlobalIndex();

(!HaveFullGlobalModuleIndex && GlobalIndex && !

()) {

RecreateIndex =

;

*TheModule = I->second;

.push_back(std::make_pair(

std::reverse(

.begin(),

.end());

RecreateIndex =

;

(RecreateIndex) {

consumeError(std::move(Err));

TheASTReader->resetForReload();

TheASTReader->loadGlobalIndex();

GlobalIndex = TheASTReader->getGlobalIndex();

HaveFullGlobalModuleIndex =

;

ExternalSemaSrc = std::move(ESS);

Defines the clang::ASTContext interface.

Defines the Diagnostic-related interfaces.

static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)

static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, StringRef ModuleName, FrontendInputFile Input, StringRef OriginalModuleMapFile, StringRef ModuleFileName, llvm::function_ref< void(CompilerInstance &)> PreBuildStep=[](CompilerInstance &) {}, llvm::function_ref< void(CompilerInstance &)> PostBuildStep=[](CompilerInstance &) {})

Compile a module file for the given module, using the options provided by the importing compiler inst...

static bool EnableCodeCompletion(Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column)

static void pruneModuleCache(const HeaderSearchOptions &HSOpts)

Prune the module cache of modules that haven't been accessed in a long time.

static bool compileModuleAndReadASTImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)

Compile a module in a separate compiler instance and read the AST, returning true if the module compi...

static bool compileModuleAndReadASTBehindLock(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)

Compile a module in a separate compiler instance and read the AST, returning true if the module compi...

static bool readASTAfterCompileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName, bool *OutOfDate)

Read the AST right after compiling the module.

static Language getLanguageFromOptions(const LangOptions &LangOpts)

Determine the appropriate source input kind based on language options.

static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc)

Diagnose differences between the current definition of the given configuration macro and the definiti...

static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr< ModuleDependencyCollector > MDC)

static ModuleSource selectModuleSource(Module *M, StringRef ModuleName, std::string &ModuleFilename, const std::map< std::string, std::string, std::less<> > &BuiltModules, HeaderSearch &HS)

Select a source for loading the named module and compute the filename to load it from.

static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)

static void writeTimestampFile(StringRef TimestampFile)

Write a new timestamp file with the given path.

static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)

static bool compileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName)

Compile a module file for the given module in a separate compiler instance, using the options provide...

static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)

static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)

static OptionalFileEntryRef getPublicModuleMap(FileEntryRef File, FileManager &FileMgr)

static void checkConfigMacros(Preprocessor &PP, Module *M, SourceLocation ImportLoc)

static bool compileModuleAndReadAST(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)

Compile a module in a separate compiler instance and read the AST, returning true if the module compi...

Defines the clang::FileManager interface and associated types.

Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...

llvm::MachO::Target Target

Defines the clang::Preprocessor interface.

Defines the SourceManager interface.

Defines utilities for dealing with stack allocation and stack space.

Defines version macros and version-related utility functions for Clang.

std::vector< std::string > ModuleSearchPaths

The set of search paths where we API notes can be found for particular modules.

virtual void Initialize(ASTContext &Context)

Initialize - This is called to initialize the consumer, providing the ASTContext.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

void setASTMutationListener(ASTMutationListener *Listener)

Attach an AST mutation listener to the AST context.

void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)

Attach an external AST source to the AST context.

Abstract interface for callback invocations by the ASTReader.

RAII object to temporarily add an AST callback listener.

Reads an AST files chain containing the contents of a translation unit.

@ ARR_Missing

The client can handle an AST file that cannot load because it is missing.

@ ARR_None

The client can't handle any AST loading failures.

@ ARR_ConfigurationMismatch

The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...

@ ARR_OutOfDate

The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...

@ ARR_TreatModuleWithErrorsAsOutOfDate

If a module file is marked with errors treat it as out-of-date so the caller can rebuild it.

static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)

Read the control block for the named AST file.

ASTReadResult

The result of reading the control block of an AST file, which can fail for various reasons.

@ Success

The control block was read successfully.

@ ConfigurationMismatch

The AST file was written with a different language/target configuration.

@ OutOfDate

The AST file is out-of-date relative to its input files, and needs to be regenerated.

@ Failure

The AST file itself appears corrupted.

@ VersionMismatch

The AST file was written by a different version of Clang.

@ HadErrors

The AST file has errors.

@ Missing

The AST file was missing.

ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client a...

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...

std::string DwarfDebugFlags

The string to embed in the debug information for the compile unit, if non-empty.

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...

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.

FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)

Create the file manager and replace any existing one with it.

DependencyOutputOptions & getDependencyOutputOpts()

bool hasFileManager() const

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)

void createDiagnostics(llvm::vfs::FileSystem &VFS, DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)

Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...

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.

std::shared_ptr< FailedModulesSet > getFailedModulesSetPtr() const

FileSystemOptions & getFileSystemOpts()

bool InitializeSourceManager(const FrontendInputFile &Input)

InitializeSourceManager - Initialize the source manager to set InputFile as the main file.

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.

std::unique_ptr< Sema > takeSema()

void printDiagnosticStats()

At the end of a compilation, print the number of warnings/errors.

void setASTConsumer(std::unique_ptr< ASTConsumer > Value)

setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value.

PreprocessorOutputOptions & getPreprocessorOutputOpts()

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.

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()

void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)

FrontendOptions & getFrontendOpts()

std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const

bool hasDiagnostics() 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 hasFailedModulesSet() const

CompilerInvocation & getInvocation()

void setVerboseOutputStream(raw_ostream &Value)

Replace the current stream for verbose output.

PreprocessorOptions & getPreprocessorOpts()

ASTConsumer & getASTConsumer() const

TargetInfo & getTarget() const

llvm::vfs::FileSystem & getVirtualFileSystem() 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.

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.

void createFailedModulesSet()

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.

LangOptions & getLangOpts()

Mutable getters.

FrontendOptions & getFrontendOpts()

std::string getModuleHash() const

Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...

DependencyOutputOptions - Options for controlling the compiler dependency file generation.

ShowIncludesDestination ShowIncludesDest

Destination of cl.exe style /showIncludes info.

std::string DOTOutputFile

The file to write GraphViz-formatted header dependencies to.

std::string ModuleDependencyOutputDir

The directory to copy module dependencies to when collecting them.

std::string OutputFile

The file to write dependency output to.

std::string HeaderIncludeOutputFile

The file to write header include output to.

unsigned ShowHeaderIncludes

Show header inclusions (-H).

Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...

unsigned getNumErrors() const

virtual void finish()

Callback to inform the diagnostic client that processing of all source files has ended.

unsigned getNumWarnings() const

Used for handling and querying diagnostic IDs.

Options for controlling the compiler diagnostics engine.

std::string DiagnosticLogFile

The file to log diagnostic output to.

std::vector< std::string > SystemHeaderWarningsModules

The list of -Wsystem-headers-in-module=... options used to override whether -Wsystem-headers is enabl...

std::string DiagnosticSerializationFile

The file to serialize diagnostics to (non-appending).

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool hasErrorOccurred() const

void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)

Set the diagnostic client associated with this diagnostic object.

std::unique_ptr< DiagnosticConsumer > takeClient()

Return the current diagnostic client along with ownership of that client.

DiagnosticConsumer * getClient()

Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const

Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...

bool ownsClient() const

Determine whether this DiagnosticsEngine object own its client.

StringRef getName() const

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

StringRef getName() const

The name of this FileEntry.

StringRef getNameAsRequested() const

The name of this FileEntry, as originally requested without applying any remappings for VFS 'use-exte...

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

void AddStats(const FileManager &Other)

Import statistics from a child FileManager and add them to this current FileManager.

llvm::vfs::FileSystem & getVirtualFileSystem() const

OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)

Get a FileEntryRef if it exists, without doing anything on error.

llvm::Expected< FileEntryRef > getSTDIN()

Get the FileEntryRef for stdin, returning an error if stdin cannot be read.

FileEntryRef getVirtualFileRef(StringRef Filename, off_t Size, time_t ModificationTime)

Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...

OptionalDirectoryEntryRef getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)

Get a DirectoryEntryRef if it exists, without doing anything on error.

LLVM_DEPRECATED("Functions returning DirectoryEntry are deprecated.", "getOptionalDirectoryRef()") llvm LLVM_DEPRECATED("Functions returning FileEntry are deprecated.", "getOptionalFileRef()") llvm llvm::Expected< FileEntryRef > getFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true, bool IsText=true)

Lookup, cache, and verify the specified directory (real or virtual).

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...

Abstract base class for actions which can be performed by the frontend.

virtual void EndSourceFile()

Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...

bool PrepareToExecute(CompilerInstance &CI)

Prepare the action to execute on the given compiler instance.

llvm::Error Execute()

Set the source manager's main input file, and run the action.

bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)

Prepare the action for processing the input file Input.

virtual bool isModelParsingAction() const

Is this action invoked on a model file?

An input file for the front end.

llvm::MemoryBufferRef getBuffer() const

InputKind getKind() const

StringRef getFile() const

FrontendOptions - Options for controlling the behavior of the frontend.

unsigned BuildingImplicitModule

Whether we are performing an implicit module build.

unsigned AllowPCMWithCompilerErrors

Output (and read) PCM files regardless of compiler errors.

unsigned BuildingImplicitModuleUsesLock

Whether to use a filesystem lock when building implicit modules.

unsigned ModulesShareFileManager

Whether to share the FileManager when building modules.

std::optional< std::string > AuxTargetCPU

Auxiliary target CPU for CUDA/HIP compilation.

std::string StatsFile

Filename to write statistics to.

std::string OutputFile

The output file, if any.

std::string ActionName

The name of the action to run when using a plugin action.

ParsedSourceLocation CodeCompletionAt

If given, enable code completion at the provided location.

std::string OriginalModuleMap

When the input is a module map, the original module map file from which that map was inferred,...

unsigned GenerateGlobalModuleIndex

Whether we can generate the global module index if needed.

unsigned DisableFree

Disable memory freeing on exit.

SmallVector< FrontendInputFile, 0 > Inputs

The input files and their types.

frontend::ActionKind ProgramAction

The frontend action to perform.

std::optional< std::vector< std::string > > AuxTargetFeatures

Auxiliary target features for CUDA/HIP compilation.

A SourceLocation and its associated SourceManager.

A global index for a set of module files, providing information about the identifiers within those mo...

bool lookupIdentifier(llvm::StringRef Name, HitSet &Hits)

Look for all of the module files with information about the given identifier, e.g....

static llvm::Error writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)

Write a global index into the given.

One of these records is kept for each identifier that is lexed.

tok::TokenKind getTokenID() const

If this is a source-language token (e.g.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

In-memory cache for modules.

bool isPCMFinal(llvm::StringRef Filename) const

Check whether the PCM is final and has been shown to work.

The kind of a file that we've been handed as an input.

@ FPE_Default

Used internally to represent initial unspecified value.

@ FPE_Ignore

Assume that floating-point exceptions are masked.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

std::string ModuleName

The module currently being compiled as specified by -fmodule-name.

Encapsulates the data about a macro definition (e.g.

Describes the result of attempting to load a module.

Abstract interface for a module loader.

bool buildingModule() const

Returns true if this instance is building a module.

llvm::StringMap< Module * >::const_iterator module_iterator

Module * findModule(StringRef Name) const

Retrieve a module with the given name.

module_iterator module_begin() const

OptionalFileEntryRef getModuleMapFileForUniquing(const Module *M) const

std::optional< Module * > getCachedModuleLoad(const IdentifierInfo &II)

Return a cached module load.

module_iterator module_end() const

FileID getContainingModuleMapFileID(const Module *Module) const

Retrieve the module map file containing the definition of the given module.

void resolveLinkAsDependencies(Module *Mod)

Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...

void cacheModuleLoad(const IdentifierInfo &II, Module *M)

Cache a module load. M might be nullptr.

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

Module * findSubmodule(StringRef Name) const

Find the submodule with the given name.

std::vector< std::string > ConfigMacros

The set of "configuration macros", which are macros that (intentionally) change how this module is bu...

NameVisibilityKind

Describes the visibility of the various names within a particular module.

@ Hidden

All of the names in this module are hidden.

void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const

Print the module map for this module to the given stream.

SourceLocation DefinitionLoc

The location of the module definition.

unsigned IsSystem

Whether this is a "system" module (which assumes that all headers in it are system headers).

std::string Name

The name of this module.

llvm::iterator_range< submodule_iterator > submodules()

OptionalDirectoryEntryRef Directory

The build directory of this module.

unsigned IsFromModuleFile

Whether this module was loaded from a module file.

unsigned HasIncompatibleModuleFile

Whether we tried and failed to load a module file for this module.

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

OptionalFileEntryRef getASTFile() const

The serialized AST file for this module, if one was created.

This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...

@ ReplaceAction

Replace the main action.

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

std::vector< std::pair< std::string, std::string > > RemappedFiles

The set of file remappings, which take existing files on the system (the first part of each pair) and...

std::pair< unsigned, bool > PrecompiledPreambleBytes

If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...

bool RemappedFilesKeepOriginalName

True if the SourceManager should report the original file name for contents of files that were remapp...

void resetNonModularOptions()

Reset any options that are not considered when building a module.

bool RetainRemappedFileBuffers

Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...

bool DetailedRecord

Whether we should maintain a detailed record of all macro definitions and expansions.

std::string ImplicitPCHInclude

The implicit PCH included at the start of the translation unit, or empty.

DisableValidationForModuleKind DisablePCHOrModuleValidation

Whether to disable most of the normal validation performed on precompiled headers and module files.

std::vector< std::pair< std::string, bool > > Macros

std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers

The set of file-to-buffer remappings, which take existing files on the system (the first part of each...

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

void markClangModuleAsAffecting(Module *M)

Mark the given clang module as affecting the current clang module or translation unit.

const MacroInfo * getMacroInfo(const IdentifierInfo *II) const

MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const

Given an identifier, return the latest non-imported macro directive for that identifier.

bool SetCodeCompletionPoint(FileEntryRef File, unsigned Line, unsigned Column)

Specify the point at which code-completion will be performed.

const TranslationUnitKind TUKind

The kind of translation unit we are processing.

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

SourceManager & getSourceManager() const

static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, const Module &M, DiagnosticsEngine &Diags)

Check that the given module is available, producing a diagnostic if not.

FileManager & getFileManager() const

FileID getPredefinesFileID() const

Returns the FileID for the preprocessor predefines.

HeaderSearch & getHeaderSearchInfo() const

void setPredefines(std::string P)

Set the predefines for this Preprocessor.

IdentifierTable & getIdentifierTable()

Builtin::Context & getBuiltinInfo()

DiagnosticsEngine & getDiagnostics() const

SelectorTable & getSelectorTable()

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

A simple code-completion consumer that prints the results it receives in a simple format.

Sema - This implements semantic analysis and AST building for C.

ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

This class handles loading and caching of source files into memory.

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

void setModuleBuildStack(ModuleBuildStack stack)

Set the module build stack.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

void setOverridenFilesKeepOriginalName(bool value)

Set true if the SourceManager should report the original file name for contents of files that were ov...

ModuleBuildStack getModuleBuildStack() const

Retrieve the module build stack.

FileID getMainFileID() const

Returns the FileID of the main source file.

void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)

Push an entry to the module build stack.

void overrideFileContents(FileEntryRef SourceFile, const llvm::MemoryBufferRef &Buffer)

Override the contents of the given source file by providing an already-allocated buffer.

SourceLocation getIncludeLoc(FileID FID) const

Returns the include location if FID is a #include'd file otherwise it returns an invalid location.

void setMainFileID(FileID FID)

Set the file ID for the main source file.

SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const

Return the file characteristic of the specified source location, indicating whether this is a normal ...

A trivial tuple used to represent a source range.

Exposes information about the current target.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)

Construct a target for the given options.

virtual void setAuxTarget(const TargetInfo *Aux)

void noSignedCharForObjCBool()

virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts)

Set forced language options.

std::string CPU

If given, the name of the target CPU to generate code for.

VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to c...

Information about a module that has been loaded by the ASTReader.

Defines the clang::TargetInfo interface.

CharacteristicKind

Indicates whether a file or directory holds normal user code, system code, or system code which is im...

@ PluginAction

Run a plugin action,.

@ RewriteObjC

ObjC->C Rewriter.

bool Inv(InterpState &S, CodePtr OpPC)

@ MK_PCH

File is a PCH file treated as such.

@ MK_Preamble

File is a PCH file treated as the preamble.

@ MK_ExplicitModule

File is an explicitly-loaded module.

@ MK_ImplicitModule

File is an implicitly-loaded module.

@ MK_PrebuiltModule

File is from a prebuilt module path.

std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)

Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.

The JSON file list parser is used to communicate input to InstallAPI.

void ApplyHeaderSearchOptions(HeaderSearch &HS, const HeaderSearchOptions &HSOpts, const LangOptions &Lang, const llvm::Triple &triple)

Apply the header search options to get given HeaderSearch object.

void noteBottomOfStack()

Call this once on each thread, as soon after starting the thread as feasible, to note the approximate...

void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts, const CodeGenOptions &CodeGenOpts)

InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...

std::error_code make_error_code(BuildPreambleError Error)

LLVM_READONLY bool isAlphanumeric(unsigned char c)

Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].

Language

The language for the input, used to select and validate the language standard and possible actions.

@ C

Languages that the frontend can parse and compile.

@ Result

The result type of a method or function.

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)

constexpr size_t DesiredStackSize

The amount of stack space that Clang would like to be provided with.

void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, llvm::vfs::FileSystem &VFS, bool ReportDiags=true)

ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...

TranslationUnitKind

Describes the kind of translation unit being processed.

void AttachHeaderIncludeGen(Preprocessor &PP, const DependencyOutputOptions &DepOpts, bool ShowAllHeaders=false, StringRef OutputPath={}, bool ShowDepth=true, bool MSStyle=false)

AttachHeaderIncludeGen - Create a header include list generator, and attach it to the given preproces...

DisableValidationForModuleKind

Whether to disable the normal validation performed on precompiled headers and module files when they ...

@ Other

Other implicit parameter.

Visibility

Describes the different kinds of visibility that a declaration may have.

void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)

AttachDependencyGraphGen - Create a dependency graph generator, and attach it to the given preprocess...

A source location that has been parsed on the command line.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4