22#include "clang/Config/config.h"
44#include "llvm/ADT/IntrusiveRefCntPtr.h"
45#include "llvm/ADT/STLExtras.h"
46#include "llvm/ADT/ScopeExit.h"
47#include "llvm/ADT/Statistic.h"
48#include "llvm/Config/llvm-config.h"
49#include "llvm/Support/AdvisoryLock.h"
50#include "llvm/Support/BuryPointer.h"
51#include "llvm/Support/CrashRecoveryContext.h"
52#include "llvm/Support/Errc.h"
53#include "llvm/Support/FileSystem.h"
54#include "llvm/Support/MemoryBuffer.h"
55#include "llvm/Support/Path.h"
56#include "llvm/Support/Signals.h"
57#include "llvm/Support/TimeProfiler.h"
58#include "llvm/Support/Timer.h"
59#include "llvm/Support/VirtualFileSystem.h"
60#include "llvm/Support/VirtualOutputBackends.h"
61#include "llvm/Support/VirtualOutputError.h"
62#include "llvm/Support/raw_ostream.h"
63#include "llvm/TargetParser/Host.h"
70CompilerInstance::CompilerInstance(
71 std::shared_ptr<CompilerInvocation> Invocation,
72 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
75 Invocation(
std::move(Invocation)),
77 ThePCHContainerOperations(
std::move(PCHContainerOps)) {
78 assert(this->Invocation &&
"Invocation must not be null");
82 assert(OutputFiles.empty() &&
"Still output files in flight?");
86 return (BuildGlobalModuleIndex ||
87 (TheASTReader && TheASTReader->isGlobalIndexUnavailable() &&
89 !DisableGeneratingGlobalModuleIndex;
94 Diagnostics = std::move(
Value);
98 OwnedVerboseOutputStream.reset();
99 VerboseOutputStream = &
Value;
103 OwnedVerboseOutputStream.swap(
Value);
104 VerboseOutputStream = OwnedVerboseOutputStream.get();
122 auto &TO = AuxTargetOpts = std::make_unique<TargetOptions>();
165 assert(
Value ==
nullptr ||
167 FileMgr = std::move(
Value);
172 SourceMgr = std::move(
Value);
176 PP = std::move(
Value);
181 Context = std::move(
Value);
183 if (Context && Consumer)
192 Consumer = std::move(
Value);
194 if (Context && Consumer)
199 CompletionConsumer.reset(
Value);
203 return std::move(TheSema);
210 assert(ModCache.get() == &Reader->getModuleManager().getModuleCache() &&
211 "Expected ASTReader to use the same PCM cache");
212 TheASTReader = std::move(Reader);
215std::shared_ptr<ModuleDependencyCollector>
217 return ModuleDepCollector;
221 std::shared_ptr<ModuleDependencyCollector> Collector) {
222 ModuleDepCollector = std::move(Collector);
226 std::shared_ptr<ModuleDependencyCollector> MDC) {
229 for (
auto &Name : HeaderMapFileNames)
234 std::shared_ptr<ModuleDependencyCollector> MDC) {
241 auto PCHDir =
FileMgr.getOptionalDirectoryRef(PCHInclude);
243 MDC->addFile(PCHInclude);
249 llvm::sys::path::native(PCHDir->getName(), DirNative);
250 llvm::vfs::FileSystem &FS =
FileMgr.getVirtualFileSystem();
252 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
253 Dir != DirEnd && !EC; Dir.increment(EC)) {
262 MDC->addFile(Dir->path());
267 std::shared_ptr<ModuleDependencyCollector> MDC) {
271 if (
auto *RedirectingVFS = dyn_cast<llvm::vfs::RedirectingFileSystem>(&VFS))
272 llvm::vfs::collectVFSEntries(*RedirectingVFS, VFSEntries);
275 for (
auto &E : VFSEntries)
276 MDC->addFile(E.VPath, E.RPath);
290 llvm::makeIntrusiveRefCnt<llvm::vfs::TracingFileSystem>(std::move(VFS));
298 std::unique_ptr<raw_ostream> StreamOwner;
299 raw_ostream *OS = &llvm::errs();
302 auto FileOS = std::make_unique<llvm::raw_fd_ostream>(
304 llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF);
306 Diags.
Report(diag::warn_fe_cc_log_diagnostics_failure)
309 FileOS->SetUnbuffered();
311 StreamOwner = std::move(FileOS);
316 auto Logger = std::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
317 std::move(StreamOwner));
331 StringRef OutputFile) {
332 auto SerializedConsumer =
337 Diags.
takeClient(), std::move(SerializedConsumer)));
340 Diags.
getClient(), std::move(SerializedConsumer)));
345 bool ShouldOwnClient) {
354 auto Diags = llvm::makeIntrusiveRefCnt<DiagnosticsEngine>(
360 Diags->setClient(Client, ShouldOwnClient);
367 if (Opts.VerifyDiagnostics)
386 assert(VFS &&
"CompilerInstance needs a VFS for creating FileManager");
393 assert(Diagnostics &&
"DiagnosticsEngine needed for creating SourceManager");
394 assert(FileMgr &&
"FileManager needed for creating SourceManager");
395 SourceMgr = llvm::makeIntrusiveRefCnt<SourceManager>(
getDiagnostics(),
409 FileMgr.getVirtualFileRef(RB.first, RB.second->getBufferSize(), 0);
416 SourceMgr.overrideFileContents(FromFile, RB.second->getMemBufferRef());
418 SourceMgr.overrideFileContents(
419 FromFile, std::unique_ptr<llvm::MemoryBuffer>(RB.second));
427 Diags.
Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
437 SourceMgr.overrideFileContents(FromFile, *ToFile);
440 SourceMgr.setOverridenFilesKeepOriginalName(
450 TheASTReader.reset();
456 PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOpts(),
465 PP->createPreprocessingRecord();
469 PP->getFileManager(), PPOpts);
478 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
479 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
480 PP->getAuxTargetInfo())
481 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
484 PP->getLangOpts(), *HeaderSearchTriple);
488 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) {
490 PP->getHeaderSearchInfo().setModuleHash(ModuleHash);
491 PP->getHeaderSearchInfo().setModuleCachePath(
506 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
512 if (ModuleDepCollector) {
523 for (
auto &Listener : DependencyCollectors)
524 Listener->attachToPreprocessor(*PP);
531 if (OutputPath ==
"-")
544 if (GetDependencyDirectives)
545 PP->setDependencyDirectivesGetter(*GetDependencyDirectives);
549 assert(FileMgr &&
"Specific module cache path requires a FileManager");
557 SpecificModuleCache);
559 llvm::sys::path::append(SpecificModuleCache, ModuleHash);
560 return std::string(SpecificModuleCache);
567 auto Context = llvm::makeIntrusiveRefCnt<ASTContext>(
568 getLangOpts(), PP.getSourceManager(), PP.getIdentifierTable(),
569 PP.getSelectorTable(), PP.getBuiltinInfo(), PP.TUKind);
586 void ReadModuleName(StringRef ModuleName)
override {
589 LoadedModules.push_back(ModuleName.str());
594 for (
const std::string &LoadedModule : LoadedModules)
597 LoadedModules.clear();
600 void markAllUnavailable() {
601 for (
const std::string &LoadedModule : LoadedModules) {
604 M->HasIncompatibleModuleFile =
true;
608 SmallVector<Module *, 2> Stack;
610 while (!Stack.empty()) {
611 Module *Current = Stack.pop_back_val();
615 llvm::append_range(Stack, SubmodulesRange);
619 LoadedModules.clear();
626 bool AllowPCHWithCompilerErrors,
void *DeserializationListener,
627 bool OwnDeserializationListener) {
634 DeserializationListener, OwnDeserializationListener,
Preamble,
639 StringRef Path, StringRef Sysroot,
644 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
645 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
646 void *DeserializationListener,
bool OwnDeserializationListener,
647 bool Preamble,
bool UseGlobalModuleIndex) {
649 PP.getHeaderSearchInfo().getHeaderSearchOpts();
651 auto Reader = llvm::makeIntrusiveRefCnt<ASTReader>(
652 PP, ModCache, &Context, PCHContainerRdr, CodeGenOpts, Extensions,
653 Sysroot.empty() ?
"" : Sysroot.data(), DisableValidation,
654 AllowPCHWithCompilerErrors,
false,
661 Context.setExternalSource(Reader);
663 Reader->setDeserializationListener(
665 OwnDeserializationListener);
667 for (
auto &Listener : DependencyCollectors)
668 Listener->attachToASTReader(*Reader);
670 auto Listener = std::make_unique<ReadModuleNames>(PP);
671 auto &ListenerRef = *Listener;
673 std::move(Listener));
675 switch (Reader->ReadAST(Path,
683 PP.setPredefines(Reader->getSuggestedPredefines());
684 ListenerRef.registerAll();
700 ListenerRef.markAllUnavailable();
701 Context.setExternalSource(
nullptr);
727 if (!CompletionConsumer) {
740 timerGroup.reset(
new llvm::TimerGroup(
"clang",
"Clang time report"));
741 FrontendTimer.reset(
new llvm::Timer(
"frontend",
"Front end", *timerGroup));
761 TUKind, CompletionConsumer));
767 if (ExternalSemaSrc) {
768 TheSema->addExternalSource(ExternalSemaSrc);
769 ExternalSemaSrc->InitializeSema(*TheSema);
775 (void)TheSema->APINotes.loadCurrentModuleAPINotes(
787 for (
auto &O : OutputFiles)
788 llvm::handleAllErrors(
790 [&](
const llvm::vfs::TempFileOutputError &E) {
791 getDiagnostics().Report(diag::err_unable_to_rename_temp)
792 << E.getTempPath() << E.getOutputPath()
793 << E.convertToErrorCode().message();
795 [&](
const llvm::vfs::OutputError &E) {
796 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
797 << E.getOutputPath() << E.convertToErrorCode().message();
799 [&](
const llvm::ErrorInfoBase &EIB) {
800 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
801 << O.getPath() << EIB.message();
805 if (DeleteBuiltModules) {
806 for (
auto &
Module : BuiltModules)
807 llvm::sys::fs::remove(
Module.second);
808 BuiltModules.clear();
813 bool Binary, StringRef InFile, StringRef Extension,
bool RemoveFileOnSignal,
814 bool CreateMissingDirectories,
bool ForceUseTemporary) {
816 std::optional<SmallString<128>> PathStorage;
817 if (OutputPath.empty()) {
818 if (InFile ==
"-" || Extension.empty()) {
821 PathStorage.emplace(InFile);
822 llvm::sys::path::replace_extension(*PathStorage, Extension);
823 OutputPath = *PathStorage;
829 CreateMissingDirectories);
833 return std::make_unique<llvm::raw_null_ostream>();
840 assert(!OutputMgr &&
"Already has an output manager");
841 OutputMgr = std::move(NewOutputs);
845 assert(!OutputMgr &&
"Already has an output manager");
846 OutputMgr = llvm::makeIntrusiveRefCnt<llvm::vfs::OnDiskOutputBackend>();
860std::unique_ptr<raw_pwrite_stream>
862 bool RemoveFileOnSignal,
bool UseTemporary,
863 bool CreateMissingDirectories) {
865 createOutputFileImpl(OutputPath,
Binary, RemoveFileOnSignal, UseTemporary,
866 CreateMissingDirectories);
868 return std::move(*OS);
870 << OutputPath << errorToErrorCode(OS.takeError()).message();
875CompilerInstance::createOutputFileImpl(StringRef OutputPath,
bool Binary,
876 bool RemoveFileOnSignal,
878 bool CreateMissingDirectories) {
879 assert((!CreateMissingDirectories || UseTemporary) &&
880 "CreateMissingDirectories is only allowed when using temporary files");
884 std::optional<SmallString<128>> AbsPath;
885 if (OutputPath !=
"-" && !llvm::sys::path::is_absolute(OutputPath)) {
887 "File Manager is required to fix up relative path.\n");
889 AbsPath.emplace(OutputPath);
890 FileMgr->FixupRelativePath(*AbsPath);
891 OutputPath = *AbsPath;
899 .setDiscardOnSignal(RemoveFileOnSignal)
900 .setAtomicWrite(UseTemporary)
901 .setImplyCreateDirectories(UseTemporary && CreateMissingDirectories));
903 return O.takeError();
905 O->discardOnDestroy([](llvm::Error E) { consumeError(std::move(E)); });
906 OutputFiles.push_back(std::move(*O));
907 return OutputFiles.back().createProxy();
929 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.
getBuffer(), Kind));
930 assert(SourceMgr.getMainFileID().isValid() &&
931 "Couldn't establish MainFileID!");
935 StringRef InputFile = Input.
getFile();
938 auto FileOrErr = InputFile ==
"-"
940 : FileMgr.getFileRef(InputFile,
true);
942 auto EC = llvm::errorToErrorCode(FileOrErr.takeError());
943 if (InputFile !=
"-")
944 Diags.
Report(diag::err_fe_error_reading) << InputFile << EC.message();
946 Diags.
Report(diag::err_fe_error_reading_stdin) << EC.message();
950 SourceMgr.setMainFileID(
953 assert(SourceMgr.getMainFileID().isValid() &&
954 "Couldn't establish MainFileID!");
961 assert(
hasDiagnostics() &&
"Diagnostics engine is not initialized!");
963 assert(!
getFrontendOpts().ShowVersion &&
"Client must handle '-version'!");
970 auto FinishDiagnosticClient = llvm::make_scope_exit([&]() {
989 OS <<
"clang -cc1 version " CLANG_VERSION_STRING <<
" based upon LLVM "
990 << LLVM_VERSION_STRING <<
" default target "
991 << llvm::sys::getDefaultTargetTriple() <<
"\n";
994 llvm::EnableStatistics(
false);
1008 if (llvm::Error Err = Act.
Execute()) {
1009 consumeError(std::move(Err));
1022 llvm::PrintStatistics(OS);
1025 if (!StatsFile.empty()) {
1026 llvm::sys::fs::OpenFlags FileFlags = llvm::sys::fs::OF_TextWithCRLF;
1028 FileFlags |= llvm::sys::fs::OF_Append;
1031 std::make_unique<llvm::raw_fd_ostream>(StatsFile, EC, FileFlags);
1034 << StatsFile << EC.message();
1036 llvm::PrintStatisticsJSON(*StatS);
1055 OS << NumWarnings <<
" warning" << (NumWarnings == 1 ?
"" :
"s");
1056 if (NumWarnings && NumErrors)
1059 OS << NumErrors <<
" error" << (NumErrors == 1 ?
"" :
"s");
1060 if (NumWarnings || NumErrors) {
1064 OS <<
" when compiling for host";
1077 if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &
Error))
1083 for (
const FrontendPluginRegistry::entry &Plugin :
1084 FrontendPluginRegistry::entries()) {
1085 std::unique_ptr<PluginASTAction> P(Plugin.instantiate());
1097 if (LangOpts.OpenCL)
1106std::unique_ptr<CompilerInstance> CompilerInstance::cloneForModuleCompileImpl(
1108 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1109 std::optional<ThreadSafeCloneConfig> ThreadSafeConfig) {
1111 auto Invocation = std::make_shared<CompilerInvocation>(
getInvocation());
1113 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1117 Invocation->resetNonModularOptions();
1121 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1122 llvm::erase_if(PPOpts.
Macros,
1123 [&HSOpts](
const std::pair<std::string, bool> &def) {
1124 StringRef MacroDef = def.first;
1125 return HSOpts.ModulesIgnoreMacros.contains(
1126 llvm::CachedHashString(MacroDef.split(
'=').first));
1130 Invocation->getLangOpts().ModuleName =
1134 Invocation->getLangOpts().CurrentModule = std::string(ModuleName);
1139 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1140 FrontendOpts.
OutputFile = ModuleFileName.str();
1147 FrontendOpts.
Inputs = {std::move(Input)};
1152 DiagnosticOptions &DiagOpts = Invocation->getDiagnosticOpts();
1154 DiagOpts.VerifyDiagnostics = 0;
1156 "Module hash mismatch!");
1162 auto InstancePtr = std::make_unique<CompilerInstance>(
1164 auto &Instance = *InstancePtr;
1166 auto &
Inv = Instance.getInvocation();
1168 if (ThreadSafeConfig) {
1169 Instance.setVirtualFileSystem(ThreadSafeConfig->getVFS());
1170 Instance.createFileManager();
1176 Instance.createFileManager();
1179 if (ThreadSafeConfig) {
1180 Instance.createDiagnostics(&ThreadSafeConfig->getDiagConsumer(),
1183 Instance.createDiagnostics(
1188 Instance.getDiagnostics().setSuppressSystemWarnings(
false);
1190 Instance.createSourceManager();
1191 SourceManager &SourceMgr = Instance.getSourceManager();
1193 if (ThreadSafeConfig) {
1199 SourceMgr.pushModuleBuildStack(
1204 Instance.FailedModules = FailedModules;
1206 if (GetDependencyDirectives)
1207 Instance.GetDependencyDirectives =
1208 GetDependencyDirectives->cloneFor(Instance.getFileManager());
1210 if (ThreadSafeConfig) {
1211 Instance.setModuleDepCollector(ThreadSafeConfig->getModuleDepCollector());
1218 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1224 StringRef ModuleName,
1225 StringRef ModuleFileName,
1226 CompilerInstance &Instance) {
1227 llvm::TimeTraceScope TimeScope(
"Module Compile", ModuleName);
1231 if (
getModuleCache().getInMemoryModuleCache().isPCMFinal(ModuleFileName)) {
1238 << ModuleName << ModuleFileName;
1242 bool Crashed = !llvm::CrashRecoveryContext().RunSafelyOnNewStack(
1257 FailedModules = std::move(Instance.FailedModules);
1262 Instance.setSema(
nullptr);
1263 Instance.setASTConsumer(
nullptr);
1266 Instance.clearOutputFiles(
true);
1277 return !Instance.getDiagnostics().hasErrorOccurred() ||
1278 Instance.getFrontendOpts().AllowPCMWithCompilerErrors;
1283 StringRef Filename = llvm::sys::path::filename(
File.getName());
1285 if (Filename ==
"module_private.map")
1286 llvm::sys::path::append(PublicFilename,
"module.map");
1287 else if (Filename ==
"module.private.modulemap")
1288 llvm::sys::path::append(PublicFilename,
"module.modulemap");
1290 return std::nullopt;
1291 return FileMgr.getOptionalFileRef(PublicFilename);
1296 std::optional<ThreadSafeCloneConfig> ThreadSafeConfig) {
1312 while (Loc.
isValid() && isModuleMap(SourceMgr.getFileCharacteristic(Loc))) {
1313 ModuleMapFID = SourceMgr.getFileID(Loc);
1314 Loc = SourceMgr.getIncludeLoc(ModuleMapFID);
1318 SourceMgr.getFileEntryRefForID(ModuleMapFID);
1319 assert(ModuleMapFile &&
"Top-level module map with no FileID");
1326 ModuleMapFile = PublicMMFile;
1338 return cloneForModuleCompileImpl(
1339 ImportLoc, ModuleName,
1342 std::move(ThreadSafeConfig));
1350 llvm::sys::path::append(FakeModuleMapFile,
"__inferred_module.map");
1352 std::string InferredModuleMapContent;
1353 llvm::raw_string_ostream OS(InferredModuleMapContent);
1356 auto Instance = cloneForModuleCompileImpl(
1357 ImportLoc, ModuleName,
1360 std::move(ThreadSafeConfig));
1362 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1363 llvm::MemoryBuffer::getMemBufferCopy(InferredModuleMapContent);
1364 FileEntryRef ModuleMapFile = Instance->getFileManager().getVirtualFileRef(
1365 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1366 Instance->getSourceManager().overrideFileContents(ModuleMapFile,
1367 std::move(ModuleMapBuffer));
1377 bool *OutOfDate,
bool *Missing) {
1388 ModuleLoadCapabilities);
1406 Diags.
Report(ModuleNameLoc, diag::err_module_not_built)
1418 StringRef ModuleFileName) {
1421 ModuleNameLoc,
Module, ModuleFileName);
1425 ModuleFileName, *Instance)) {
1427 diag::err_module_not_built)
1459 Diags.
Report(ModuleNameLoc, diag::remark_module_lock)
1468 if (llvm::Error Err = Lock->tryLock().moveInto(Owned)) {
1472 Diags.
Report(ModuleNameLoc, diag::remark_module_lock_failure)
1475 ModuleNameLoc,
Module, ModuleFileName);
1480 ModuleNameLoc,
Module, ModuleFileName);
1485 switch (Lock->waitForUnlockFor(std::chrono::seconds(90))) {
1486 case llvm::WaitForUnlockResult::Success:
1488 case llvm::WaitForUnlockResult::OwnerDied:
1490 case llvm::WaitForUnlockResult::Timeout:
1494 Diags.
Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1497 Lock->unsafeMaybeUnlock();
1502 bool OutOfDate =
false;
1503 bool Missing =
false;
1505 Module, ModuleFileName, &OutOfDate, &Missing))
1507 if (!OutOfDate && !Missing)
1551 for (
auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1553 FileID FID = SourceMgr.getFileID(MD->getLocation());
1556 if (
auto *DMD = dyn_cast<DefMacroDirective>(MD))
1557 CmdLineDefinition = DMD->getMacroInfo();
1562 if (CurrentDefinition == CmdLineDefinition) {
1564 }
else if (!CurrentDefinition) {
1567 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1569 auto LatestDef = LatestLocalMD->getDefinition();
1570 assert(LatestDef.isUndefined() &&
1571 "predefined macro went away with no #undef?");
1572 PP.
Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1575 }
else if (!CmdLineDefinition) {
1578 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1580 PP.
Diag(CurrentDefinition->getDefinitionLoc(),
1581 diag::note_module_def_undef_here)
1583 }
else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1586 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1588 PP.
Diag(CurrentDefinition->getDefinitionLoc(),
1589 diag::note_module_def_undef_here)
1597 for (
const StringRef ConMacro : TopModule->
ConfigMacros) {
1612 !
getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
1618 std::string Sysroot = HSOpts.
Sysroot;
1621 std::unique_ptr<llvm::Timer> ReadTimer;
1624 ReadTimer = std::make_unique<llvm::Timer>(
"reading_modules",
1625 "Reading modules", *timerGroup);
1626 TheASTReader = llvm::makeIntrusiveRefCnt<ASTReader>(
1630 Sysroot.empty() ?
"" : Sysroot.c_str(),
1639 TheASTReader->setDeserializationListener(
1646 TheASTReader->InitializeSema(
getSema());
1650 for (
auto &Listener : DependencyCollectors)
1651 Listener->attachToASTReader(*TheASTReader);
1660 llvm::TimeRegion TimeLoading(timerGroup ? &Timer :
nullptr);
1668 bool ConfigMismatchIsRecoverable =
1673 auto Listener = std::make_unique<ReadModuleNames>(*PP);
1674 auto &ListenerRef = *Listener;
1676 std::move(Listener));
1679 switch (TheASTReader->ReadAST(
1682 &LoadedModuleFile)) {
1686 ListenerRef.registerAll();
1695 ListenerRef.markAllUnavailable();
1707 MS_PrebuiltModulePath,
1708 MS_ModuleBuildPragma
1715 Module *M, StringRef ModuleName, std::string &ModuleFilename,
1716 const std::map<std::string, std::string, std::less<>> &BuiltModules,
1718 assert(ModuleFilename.empty() &&
"Already has a module source?");
1722 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1723 if (BuiltModuleIt != BuiltModules.end()) {
1724 ModuleFilename = BuiltModuleIt->second;
1725 return MS_ModuleBuildPragma;
1735 if (!ModuleFilename.empty())
1736 return MS_PrebuiltModulePath;
1742 return MS_ModuleCache;
1745 return MS_ModuleNotFound;
1754 HS.
lookupModule(ModuleName, ImportLoc,
true, !IsInclusionDirective);
1764 std::string ModuleFilename;
1765 ModuleSource Source =
1767 if (Source == MS_ModuleNotFound) {
1770 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1773 if (ModuleFilename.empty()) {
1792 Timer.init(
"loading." + ModuleFilename,
"Loading " + ModuleFilename,
1794 llvm::TimeRegion TimeLoading(timerGroup ? &Timer :
nullptr);
1795 llvm::TimeTraceScope TimeScope(
"Module Load", ModuleName);
1799 unsigned ARRFlags = Source == MS_ModuleCache
1802 : Source == MS_PrebuiltModulePath
1806 Source == MS_PrebuiltModulePath
1808 : Source == MS_ModuleBuildPragma
1811 ImportLoc, ARRFlags)) {
1815 assert(Source != MS_ModuleCache &&
1816 "missing module, but file loaded from cache");
1820 M = HS.
lookupModule(ModuleName, ImportLoc,
true, !IsInclusionDirective);
1824 if (
auto ModuleFile = FileMgr->getOptionalFileRef(ModuleFilename))
1830 return ModuleLoadResult();
1839 if (Source == MS_PrebuiltModulePath)
1843 diag::warn_module_config_mismatch)
1852 return ModuleLoadResult();
1856 return ModuleLoadResult();
1860 if (Source != MS_ModuleCache) {
1864 return ModuleLoadResult();
1868 assert(M &&
"missing module, but trying to compile for cache");
1872 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1873 for (; Pos != PosEnd; ++Pos) {
1874 if (Pos->first == ModuleName)
1878 if (Pos != PosEnd) {
1879 SmallString<256> CyclePath;
1880 for (; Pos != PosEnd; ++Pos) {
1881 CyclePath += Pos->first;
1882 CyclePath +=
" -> ";
1884 CyclePath += ModuleName;
1887 << ModuleName << CyclePath;
1892 if (FailedModules.contains(ModuleName)) {
1894 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1902 "undiagnosed error in compileModuleAndReadAST");
1903 FailedModules.insert(ModuleName);
1915 bool IsInclusionDirective) {
1917 StringRef ModuleName = Path[0].getIdentifierInfo()->getName();
1923 if (ImportLoc.
isValid() && LastModuleImportLoc == ImportLoc) {
1925 if (LastModuleImportResult && ModuleName !=
getLangOpts().CurrentModule)
1926 TheASTReader->makeModuleVisible(LastModuleImportResult,
Visibility,
1928 return LastModuleImportResult;
1942 }
else if (ModuleName ==
getLangOpts().CurrentModule) {
1944 Module = PP->getHeaderSearchInfo().lookupModule(
1945 ModuleName, ImportLoc,
true,
1946 !IsInclusionDirective);
1957 ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
1961 DisableGeneratingGlobalModuleIndex =
true;
1973 bool MapPrivateSubModToTopLevel =
false;
1974 for (
unsigned I = 1, N = Path.size(); I != N; ++I) {
1975 StringRef Name = Path[I].getIdentifierInfo()->getName();
1984 PrivateModule.append(
"_Private");
1987 auto &II = PP->getIdentifierTable().get(
1988 PrivateModule, PP->getIdentifierInfo(
Module->
Name)->getTokenID());
1989 PrivPath.emplace_back(Path[0].getLoc(), &II);
1993 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, ImportLoc,
true,
1994 !IsInclusionDirective) ||
1996 PP->getHeaderSearchInfo()) != MS_ModuleNotFound)
1999 MapPrivateSubModToTopLevel =
true;
2000 PP->markClangModuleAsAffecting(
Module);
2002 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
2004 diag::warn_no_priv_submodule_use_toplevel)
2007 <<
SourceRange(Path[0].getLoc(), Path[I].getLoc())
2011 diag::note_private_top_level_defined);
2019 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
2023 Name.edit_distance(SubModule->Name,
2024 true, BestEditDistance);
2025 if (ED <= BestEditDistance) {
2026 if (ED < BestEditDistance) {
2028 BestEditDistance = ED;
2031 Best.push_back(SubModule->Name);
2036 if (Best.size() == 1) {
2038 diag::err_no_submodule_suggest)
2040 << Best[0] <<
SourceRange(Path[0].getLoc(), Path[I - 1].getLoc())
2053 <<
SourceRange(Path[0].getLoc(), Path[I - 1].getLoc());
2072 <<
SourceRange(Path.front().getLoc(), Path.back().getLoc());
2081 <<
SourceRange(Path.front().getLoc(), Path.back().getLoc());
2082 LastModuleImportLoc = ImportLoc;
2096 LastModuleImportLoc = ImportLoc;
2098 return LastModuleImportResult;
2102 StringRef ModuleName,
2106 for (
auto &
C : CleanModuleName)
2114 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2115 CleanModuleName,
"pcm", ModuleFileName)) {
2117 << ModuleFileName << EC.message();
2120 std::string ModuleMapFileName = (CleanModuleName +
".map").str();
2127 std::string NullTerminatedSource(Source.str());
2129 auto Other = cloneForModuleCompileImpl(ImportLoc, ModuleName, Input,
2130 StringRef(), ModuleFileName);
2135 ModuleMapFileName, NullTerminatedSource.size(), 0);
2136 Other->getSourceManager().overrideFileContents(
2137 ModuleMapFile, llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource));
2139 Other->BuiltModules = std::move(BuiltModules);
2140 Other->DeleteBuiltModules =
false;
2145 BuiltModules = std::move(
Other->BuiltModules);
2148 BuiltModules[std::string(ModuleName)] = std::string(ModuleFileName);
2149 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2161 TheASTReader->makeModuleVisible(Mod,
Visibility, ImportLoc);
2166 if (
getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2175 TheASTReader->loadGlobalIndex();
2180 llvm::sys::fs::create_directories(
2189 consumeError(std::move(Err));
2192 TheASTReader->resetForReload();
2193 TheASTReader->loadGlobalIndex();
2194 GlobalIndex = TheASTReader->getGlobalIndex();
2198 if (!HaveFullGlobalModuleIndex && GlobalIndex && !
buildingModule()) {
2200 bool RecreateIndex =
false;
2203 Module *TheModule = I->second;
2207 Path.emplace_back(TriggerLoc,
2209 std::reverse(Path.begin(), Path.end());
2212 RecreateIndex =
true;
2215 if (RecreateIndex) {
2220 consumeError(std::move(Err));
2223 TheASTReader->resetForReload();
2224 TheASTReader->loadGlobalIndex();
2225 GlobalIndex = TheASTReader->getGlobalIndex();
2227 HaveFullGlobalModuleIndex =
true;
2261 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 EnableCodeCompletion(Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column)
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 void SetupSerializedDiagnostics(DiagnosticOptions &DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)
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 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 bool readASTAfterCompileModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName, bool *OutOfDate, bool *Missing)
Read the AST right after compiling the module.
static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)
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...
static void SetUpDiagnosticLog(DiagnosticOptions &DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)
Defines the clang::FileManager interface and associated types.
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the SourceManager interface.
Defines utilities for dealing with stack allocation and stack space.
Defines version macros and version-related utility functions for Clang.
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.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
Abstract interface for callback invocations by the ASTReader.
RAII object to temporarily add an AST callback listener.
@ 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 ModuleCache &ModCache, 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.
bool hasOutputManager() const
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 setOutputManager(IntrusiveRefCntPtr< llvm::vfs::OutputBackend > NewOutputs)
Set the output manager.
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...
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)
bool compileModule(SourceLocation ImportLoc, StringRef ModuleName, StringRef ModuleFileName, CompilerInstance &Instance)
Compile a module file for the given module, using the options provided by the importing compiler inst...
std::string getSpecificModuleCachePath()
std::unique_ptr< CompilerInstance > cloneForModuleCompile(SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName, std::optional< ThreadSafeCloneConfig > ThreadSafeConfig=std::nullopt)
Creates a new CompilerInstance for compiling a module.
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
FileSystemOptions & getFileSystemOpts()
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file.
void createFileManager()
Create the file manager and replace any existing one with it.
void setVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
Use the given file system.
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.
void createOutputManager()
Create an output manager.
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< FileManager > getFileManagerPtr() const
ModuleCache & getModuleCache() const
IntrusiveRefCntPtr< ASTReader > getASTReader() const
void setTarget(TargetInfo *Value)
Replace the current Target.
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
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.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
ASTContext & getASTContext() const
IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystemPtr() const
void LoadRequestedPlugins()
Load the list of plugins requested in the FrontendOptions.
TargetOptions & getTargetOpts()
void createVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS=llvm::vfs::getRealFileSystem(), DiagnosticConsumer *DC=nullptr)
Create a virtual file system instance based on the invocation.
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.
void setSourceManager(llvm::IntrusiveRefCntPtr< SourceManager > Value)
setSourceManager - Replace the current source manager.
void setASTContext(llvm::IntrusiveRefCntPtr< ASTContext > Value)
setASTContext - Replace the current AST context.
HeaderSearchOptions & getHeaderSearchOpts()
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
void createSourceManager()
Create the source manager and replace any existing one with it.
CompilerInvocation & getInvocation()
void setVerboseOutputStream(raw_ostream &Value)
Replace the current stream for verbose output.
PreprocessorOptions & getPreprocessorOpts()
ASTConsumer & getASTConsumer() const
void setFileManager(IntrusiveRefCntPtr< FileManager > Value)
Replace the current file manager and virtual file system.
TargetInfo & getTarget() const
llvm::vfs::OutputBackend & getOutputManager()
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()
llvm::vfs::OutputBackend & getOrCreateOutputManager()
CodeGenOptions & getCodeGenOpts()
SourceManager & getSourceManager() const
Return the current source manager.
void setDiagnostics(llvm::IntrusiveRefCntPtr< DiagnosticsEngine > Value)
setDiagnostics - Replace the current diagnostics engine.
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.
bool hasVirtualFileSystem() const
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
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
static llvm::IntrusiveRefCntPtr< DiagnosticIDs > create()
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.
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
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?
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 global index for a set of module files, providing information about the identifiers within those mo...
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
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.
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
@ 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.
The module cache used for compiling modules implicitly.
virtual void prepareForGetLock(StringRef ModuleFilename)=0
May perform any work that only needs to be performed once for multiple calls getLock() with the same ...
virtual void updateModuleTimestamp(StringRef ModuleFilename)=0
Updates the timestamp denoting the last time inputs of the module file were validated.
virtual std::unique_ptr< llvm::AdvisoryLock > getLock(StringRef ModuleFilename)=0
Returns lock for the given module file. The lock is initially unlocked.
Describes the result of attempting to load a module.
bool buildingModule() const
Returns true if this instance is building a module.
ModuleLoader(bool BuildingModule=false)
llvm::StringMap< Module * >::const_iterator module_iterator
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.
Module * findOrLoadModule(StringRef Name)
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...
unsigned IsUnimportable
Whether this module has declared itself unimportable, either because it's missing a requirement from ...
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.
unsigned IsAvailable
Whether this module is available in the current translation unit.
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...
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.
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.
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
DiagnosticsEngine & getDiagnostics() const
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.
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
A trivial tuple used to represent a source range.
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
Exposes information about the current target.
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, TargetOptions &Opts)
Construct a target for the given options.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual void setAuxTarget(const TargetInfo *Aux)
void noSignedCharForObjCBool()
virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts, const TargetInfo *Aux)
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 &DiagOpts, 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.
CustomizableOptional< FileEntryRef > OptionalFileEntryRef
ArrayRef< IdentifierLoc > ModuleIdPath
A sequence of identifier/location pairs used to describe a particular module or submodule,...
ArrayRef< std::pair< std::string, FullSourceLoc > > ModuleBuildStack
The stack used when building modules on demand, which is used to provide a link between the source ma...
void ApplyHeaderSearchOptions(HeaderSearch &HS, const HeaderSearchOptions &HSOpts, const LangOptions &Lang, const llvm::Triple &triple)
Apply the header search options to get given HeaderSearch object.
@ Success
Annotation was successful.
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 ...
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
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)
void normalizeModuleCachePath(FileManager &FileMgr, StringRef Path, SmallVectorImpl< char > &NormalizedPath)
constexpr size_t DesiredStackSize
The amount of stack space that Clang would like to be provided with.
IntrusiveRefCntPtr< ModuleCache > createCrossProcessModuleCache()
Creates new ModuleCache backed by a file system directory that may be operated on by multiple process...
void noteBottomOfStack(bool ForceSet=false)
Call this once on each thread, as soon after starting the thread as feasible, to note the approximate...
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.