21 #include "clang/Config/config.h"
39 #include "llvm/ADT/Statistic.h"
40 #include "llvm/Support/CrashRecoveryContext.h"
41 #include "llvm/Support/Errc.h"
42 #include "llvm/Support/FileSystem.h"
43 #include "llvm/Support/Host.h"
44 #include "llvm/Support/LockFileManager.h"
45 #include "llvm/Support/MemoryBuffer.h"
46 #include "llvm/Support/Path.h"
47 #include "llvm/Support/Program.h"
48 #include "llvm/Support/Signals.h"
49 #include "llvm/Support/Timer.h"
50 #include "llvm/Support/raw_ostream.h"
52 #include <system_error>
56 using namespace clang;
58 CompilerInstance::CompilerInstance(
59 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
64 ThePCHContainerOperations(std::move(PCHContainerOps)) {
71 assert(OutputFiles.empty() &&
"Still output files in flight?");
75 std::shared_ptr<CompilerInvocation>
Value) {
76 Invocation = std::move(Value);
80 return (BuildGlobalModuleIndex ||
81 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
98 VirtualFileSystem.reset();
106 PP = std::move(Value);
112 if (Context && Consumer)
121 Consumer = std::move(Value);
123 if (Context && Consumer)
128 CompletionConsumer.reset(Value);
132 return std::move(TheSema);
136 return ModuleManager;
139 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&
140 "Expected ASTReader to use the same PCM cache");
141 ModuleManager = std::move(Reader);
144 std::shared_ptr<ModuleDependencyCollector>
146 return ModuleDepCollector;
150 std::shared_ptr<ModuleDependencyCollector> Collector) {
151 ModuleDepCollector = std::move(Collector);
155 std::shared_ptr<ModuleDependencyCollector> MDC) {
158 for (
auto &
Name : HeaderMapFileNames)
163 std::shared_ptr<ModuleDependencyCollector> MDC) {
172 MDC->addFile(PCHInclude);
178 llvm::sys::path::native(PCHDir->
getName(), DirNative);
182 Dir != DirEnd && !EC; Dir.
increment(EC)) {
190 MDC->addFile(Dir->getName());
195 std::shared_ptr<ModuleDependencyCollector> MDC) {
202 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
Buffer =
203 llvm::MemoryBuffer::getFile(VFSFile);
207 VFSFile, VFSEntries);
210 for (
auto &
E : VFSEntries)
211 MDC->addFile(
E.VPath,
E.RPath);
219 std::unique_ptr<raw_ostream> StreamOwner;
220 raw_ostream *OS = &llvm::errs();
223 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
225 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
227 Diags.
Report(diag::warn_fe_cc_log_diagnostics_failure)
230 FileOS->SetUnbuffered();
232 StreamOwner = std::move(FileOS);
237 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
238 std::move(StreamOwner));
248 StringRef OutputFile) {
249 auto SerializedConsumer =
254 Diags.
takeClient(), std::move(SerializedConsumer)));
257 Diags.
getClient(), std::move(SerializedConsumer)));
262 bool ShouldOwnClient) {
270 bool ShouldOwnClient,
279 Diags->setClient(Client, ShouldOwnClient);
284 if (Opts->VerifyDiagnostics)
329 Diags.
Report(diag::err_fe_remap_missing_from_file) << RB.first;
346 Diags.
Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
354 Diags.
Report(diag::err_fe_remap_missing_from_file) << RF.first;
381 PP = std::make_shared<Preprocessor>(
391 PTHMgr->setPreprocessor(&*PP);
392 PP->setPTHManager(PTHMgr);
396 PP->createPreprocessingRecord();
400 PP->getFileManager(), PPOpts);
409 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
410 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
411 PP->getAuxTargetInfo())
412 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
415 PP->getLangOpts(), *HeaderSearchTriple);
419 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
425 TheDependencyFileGenerator.reset(
434 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
440 if (ModuleDepCollector) {
447 for (
auto &Listener : DependencyCollectors)
448 Listener->attachToPreprocessor(*PP);
455 if (OutputPath ==
"-")
474 llvm::sys::path::append(SpecificModuleCache,
476 return SpecificModuleCache.str();
493 StringRef Path,
bool DisablePCHValidation,
bool AllowPCHWithCompilerErrors,
494 void *DeserializationListener,
bool OwnDeserializationListener) {
501 TheDependencyFileGenerator.get(),
502 DependencyCollectors,
503 DeserializationListener,
504 OwnDeserializationListener, Preamble,
509 StringRef Path, StringRef Sysroot,
bool DisablePCHValidation,
512 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
514 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
515 void *DeserializationListener,
bool OwnDeserializationListener,
516 bool Preamble,
bool UseGlobalModuleIndex) {
520 PP, &Context, PCHContainerRdr, Extensions,
521 Sysroot.empty() ?
"" : Sysroot.data(), DisablePCHValidation,
522 AllowPCHWithCompilerErrors,
false,
529 Reader->setDeserializationListener(
530 static_cast<ASTDeserializationListener *>(DeserializationListener),
531 OwnDeserializationListener);
535 for (
auto &Listener : DependencyCollectors)
536 Listener->attachToASTReader(*Reader);
538 switch (Reader->ReadAST(Path,
588 if (!CompletionConsumer) {
594 if (!CompletionConsumer)
602 if (CompletionConsumer->isOutputBinary() &&
603 llvm::sys::ChangeStdoutToBinary()) {
610 FrontendTimerGroup.reset(
611 new llvm::TimerGroup(
"frontend",
"Clang front-end time report"));
613 new llvm::Timer(
"frontend",
"Clang front-end timer",
614 *FrontendTimerGroup));
634 TUKind, CompletionConsumer));
636 if (ExternalSemaSrc) {
637 TheSema->addExternalSource(ExternalSemaSrc.get());
638 ExternalSemaSrc->InitializeSema(*TheSema);
645 OutputFiles.push_back(std::move(OutFile));
649 for (OutputFile &OF : OutputFiles) {
650 if (!OF.TempFilename.empty()) {
652 llvm::sys::fs::remove(OF.TempFilename);
658 FileMgr->FixupRelativePath(NewOutFile);
659 if (std::error_code ec =
660 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
662 << OF.TempFilename << OF.Filename << ec.message();
664 llvm::sys::fs::remove(OF.TempFilename);
667 }
else if (!OF.Filename.empty() && EraseFiles)
668 llvm::sys::fs::remove(OF.Filename);
671 if (DeleteBuiltModules) {
672 for (
auto &
Module : BuiltModules)
673 llvm::sys::fs::remove(
Module.second);
674 BuiltModules.clear();
676 NonSeekStream.reset();
679 std::unique_ptr<raw_pwrite_stream>
681 StringRef Extension) {
683 true, InFile, Extension,
688 return llvm::make_unique<llvm::raw_null_ostream>();
691 std::unique_ptr<raw_pwrite_stream>
693 bool RemoveFileOnSignal, StringRef InFile,
694 StringRef Extension,
bool UseTemporary,
695 bool CreateMissingDirectories) {
696 std::string OutputPathName, TempPathName;
699 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
700 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
710 OutputFile((OutputPathName !=
"-") ? OutputPathName :
"", TempPathName));
716 StringRef OutputPath, std::error_code &Error,
bool Binary,
717 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
718 bool UseTemporary,
bool CreateMissingDirectories,
719 std::string *ResultPathName, std::string *TempPathName) {
720 assert((!CreateMissingDirectories || UseTemporary) &&
721 "CreateMissingDirectories is only allowed when using temporary files");
723 std::string OutFile, TempFile;
724 if (!OutputPath.empty()) {
725 OutFile = OutputPath;
726 }
else if (InFile ==
"-") {
728 }
else if (!Extension.empty()) {
730 llvm::sys::path::replace_extension(Path, Extension);
731 OutFile = Path.str();
736 std::unique_ptr<llvm::raw_fd_ostream> OS;
741 UseTemporary =
false;
743 llvm::sys::fs::file_status
Status;
744 llvm::sys::fs::status(OutputPath, Status);
745 if (llvm::sys::fs::exists(Status)) {
747 if (!llvm::sys::fs::can_write(OutputPath)) {
754 if (!llvm::sys::fs::is_regular_file(Status))
755 UseTemporary =
false;
764 TempPath +=
"-%%%%%%%%";
767 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
769 if (CreateMissingDirectories &&
770 EC == llvm::errc::no_such_file_or_directory) {
771 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
772 EC = llvm::sys::fs::create_directories(Parent);
774 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
779 OS.reset(
new llvm::raw_fd_ostream(fd,
true));
780 OSFile = TempFile = TempPath.str();
789 OS.reset(
new llvm::raw_fd_ostream(
791 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
797 if (RemoveFileOnSignal)
798 llvm::sys::RemoveFileOnSignal(OSFile);
801 *ResultPathName = OutFile;
803 *TempPathName = TempFile;
805 if (!Binary || OS->supportsSeeking())
806 return std::move(OS);
808 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
809 assert(!NonSeekStream);
810 NonSeekStream = std::move(OS);
836 std::unique_ptr<llvm::MemoryBuffer>(Input.
getBuffer()), Kind));
838 "Couldn't establish MainFileID!");
842 StringRef InputFile = Input.
getFile();
845 if (InputFile !=
"-") {
848 File = FileMgr.
getFile(InputFile,
true);
863 Includers.push_back(std::make_pair(FindFile, FindFile->
getDir()));
866 UnusedCurDir, Includers,
877 Diags.
Report(diag::err_fe_error_reading) << InputFile;
890 File = FileMgr.
getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
893 Diags.
Report(diag::err_cannot_open_file) << InputFile
894 << MB.getError().message();
902 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
903 llvm::MemoryBuffer::getSTDIN();
904 if (std::error_code EC = SBOrErr.getError()) {
905 Diags.
Report(diag::err_fe_error_reading_stdin) << EC.message();
908 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
911 SB->getBufferSize(), 0);
918 "Couldn't establish MainFileID!");
925 assert(
hasDiagnostics() &&
"Diagnostics engine is not initialized!");
927 assert(!
getFrontendOpts().ShowVersion &&
"Client must handle '-version'!");
931 raw_ostream &OS = llvm::errs();
942 auto TO = std::make_shared<TargetOptions>();
963 OS <<
"clang -cc1 version " CLANG_VERSION_STRING
964 <<
" based upon " << BACKEND_PACKAGE_STRING
965 <<
" default target " << llvm::sys::getDefaultTargetTriple() <<
"\n";
971 llvm::EnableStatistics(
false);
995 OS << NumWarnings <<
" warning" << (NumWarnings == 1 ?
"" :
"s");
996 if (NumWarnings && NumErrors)
999 OS << NumErrors <<
" error" << (NumErrors == 1 ?
"" :
"s");
1000 if (NumWarnings || NumErrors)
1001 OS <<
" generated.\n";
1009 llvm::PrintStatistics(OS);
1012 if (!StatsFile.empty()) {
1014 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1015 llvm::sys::fs::F_Text);
1018 << StatsFile << EC.message();
1020 llvm::PrintStatisticsJSON(*StatS);
1030 if (LangOpts.OpenCL)
1045 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1048 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1052 std::make_shared<CompilerInvocation>(ImportingInstance.
getInvocation());
1059 PPOpts.resetNonModularOptions();
1064 PPOpts.Macros.erase(
1065 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1066 [&HSOpts](
const std::pair<std::string, bool> &def) {
1067 StringRef MacroDef = def.first;
1069 llvm::CachedHashString(MacroDef.split(
'=').first)) > 0;
1071 PPOpts.Macros.end());
1074 Invocation->getLangOpts()->CurrentModule = ModuleName;
1083 std::make_shared<PreprocessorOptions::FailedModulesSet>();
1090 FrontendOpts.
OutputFile = ModuleFileName.str();
1097 FrontendOpts.
Inputs = {Input};
1100 PPOpts.RetainRemappedFileBuffers =
true;
1102 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1104 Invocation->getModuleHash() &&
"Module hash mismatch!");
1112 auto &Inv = *Invocation;
1124 Instance.createSourceManager(Instance.getFileManager());
1138 diag::remark_module_build)
1139 << ModuleName << ModuleFileName;
1141 PreBuildStep(Instance);
1145 const unsigned ThreadStackSize = 8 << 20;
1146 llvm::CrashRecoveryContext CRC;
1147 CRC.RunSafelyOnThread(
1154 PostBuildStep(Instance);
1157 diag::remark_module_build_done)
1164 Instance.clearOutputFiles(
true);
1166 return !Instance.getDiagnostics().hasErrorOccurred();
1175 StringRef ModuleFileName) {
1197 llvm::sys::path::append(FakeModuleMapFile,
"__inferred_module.map");
1199 std::string InferredModuleMapContent;
1200 llvm::raw_string_ostream OS(InferredModuleMapContent);
1210 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1211 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1212 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1213 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1214 Instance.getSourceManager().overrideFileContents(
1215 ModuleMapFile, std::move(ModuleMapBuffer));
1231 StringRef ModuleFileName) {
1234 auto diagnoseBuildFailure = [&] {
1235 Diags.
Report(ModuleNameLoc, diag::err_module_not_built)
1241 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1242 llvm::sys::fs::create_directories(Dir);
1246 llvm::LockFileManager Locked(ModuleFileName);
1248 case llvm::LockFileManager::LFS_Error:
1252 Diags.
Report(ModuleNameLoc, diag::remark_module_lock_failure)
1253 << Module->
Name << Locked.getErrorMessage();
1255 Locked.unsafeRemoveLockFile();
1257 case llvm::LockFileManager::LFS_Owned:
1261 diagnoseBuildFailure();
1266 case llvm::LockFileManager::LFS_Shared:
1269 switch (Locked.waitForUnlock()) {
1270 case llvm::LockFileManager::Res_Success:
1273 case llvm::LockFileManager::Res_OwnerDied:
1275 case llvm::LockFileManager::Res_Timeout:
1279 Diags.
Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1282 Locked.unsafeRemoveLockFile();
1292 ModuleLoadCapabilities);
1295 Locked == llvm::LockFileManager::LFS_Shared) {
1301 diagnoseBuildFailure();
1305 diagnoseBuildFailure();
1326 for (
auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1331 if (
auto *DMD = dyn_cast<DefMacroDirective>(MD))
1332 CmdLineDefinition = DMD->getMacroInfo();
1337 if (CurrentDefinition == CmdLineDefinition) {
1339 }
else if (!CurrentDefinition) {
1342 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1344 auto LatestDef = LatestLocalMD->getDefinition();
1345 assert(LatestDef.isUndefined() &&
1346 "predefined macro went away with no #undef?");
1347 PP.
Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1350 }
else if (!CmdLineDefinition) {
1353 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1355 PP.
Diag(CurrentDefinition->getDefinitionLoc(),
1356 diag::note_module_def_undef_here)
1358 }
else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1361 PP.
Diag(ImportLoc, diag::warn_module_config_macro_undef)
1363 PP.
Diag(CurrentDefinition->getDefinitionLoc(),
1364 diag::note_module_def_undef_here)
1372 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1378 struct stat StatBuf;
1381 assert(!TimestampFile.empty());
1382 llvm::sys::path::append(TimestampFile,
"modules.timestamp");
1385 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1387 if (errno == ENOENT) {
1395 time_t TimeStampModTime = StatBuf.st_mtime;
1396 time_t CurrentTime = time(
nullptr);
1409 llvm::sys::path::native(HSOpts.
ModuleCachePath, ModuleCachePathNative);
1410 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1411 Dir != DirEnd && !EC; Dir.increment(EC)) {
1413 if (!llvm::sys::fs::is_directory(Dir->path()))
1417 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1418 File != FileEnd && !EC; File.increment(EC)) {
1420 StringRef Extension = llvm::sys::path::extension(File->path());
1421 if (Extension !=
".pcm" && Extension !=
".timestamp" &&
1422 llvm::sys::path::filename(File->path()) !=
"modules.idx")
1427 if (::stat(File->path().c_str(), &StatBuf))
1431 time_t FileAccessTime = StatBuf.st_atime;
1432 if (CurrentTime - FileAccessTime <=
1438 llvm::sys::fs::remove(File->path());
1441 std::string TimpestampFilename = File->path() +
".timestamp";
1442 llvm::sys::fs::remove(TimpestampFilename);
1447 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1448 llvm::sys::fs::directory_iterator() && !EC)
1449 llvm::sys::fs::remove(Dir->path());
1454 if (!ModuleManager) {
1461 !
getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1468 std::string Sysroot = HSOpts.
Sysroot;
1470 std::unique_ptr<llvm::Timer> ReadTimer;
1471 if (FrontendTimerGroup)
1472 ReadTimer = llvm::make_unique<llvm::Timer>(
"reading_modules",
1474 *FrontendTimerGroup);
1483 std::move(ReadTimer));
1492 ModuleManager->InitializeSema(
getSema());
1496 if (TheDependencyFileGenerator)
1497 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1498 for (
auto &Listener : DependencyCollectors)
1499 Listener->attachToASTReader(*ModuleManager);
1505 if (FrontendTimerGroup)
1506 Timer.init(
"preloading." + FileName.str(),
"Preloading " + FileName.str(),
1507 *FrontendTimerGroup);
1508 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer :
nullptr);
1519 void ReadModuleName(StringRef ModuleName)
override {
1520 LoadedModules.push_back(
1524 void registerAll() {
1525 for (
auto *II : LoadedModules) {
1531 LoadedModules.clear();
1534 void markAllUnavailable() {
1535 for (
auto *II : LoadedModules) {
1546 while (!Stack.empty()) {
1550 Stack.insert(Stack.end(),
1555 LoadedModules.clear();
1563 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1564 auto &ListenerRef = *Listener;
1566 std::move(Listener));
1575 ListenerRef.registerAll();
1584 ListenerRef.markAllUnavailable();
1596 bool IsInclusionDirective) {
1598 StringRef ModuleName = Path[0].first->getName();
1604 if (ImportLoc.
isValid() && LastModuleImportLoc == ImportLoc) {
1607 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1609 return LastModuleImportResult;
1615 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1616 = KnownModules.find(Path[0].first);
1617 if (Known != KnownModules.end()) {
1619 Module = Known->second;
1622 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1623 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1626 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1628 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1630 std::string ModuleFileName;
1632 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1633 } Source = ModuleNotFound;
1637 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1638 if (BuiltModuleIt != BuiltModules.end()) {
1639 ModuleFileName = BuiltModuleIt->second;
1640 Source = ModuleBuildPragma;
1645 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(
1646 ModuleName,
"",
true);
1647 if (!ModuleFileName.empty())
1648 Source = PrebuiltModulePath;
1652 if (Source == ModuleNotFound && Module) {
1653 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
1654 Source = ModuleCache;
1657 if (Source == ModuleNotFound) {
1660 << ModuleName <<
SourceRange(ImportLoc, ModuleNameLoc);
1661 ModuleBuildFailed =
true;
1665 if (ModuleFileName.empty()) {
1674 ModuleBuildFailed =
true;
1683 if (FrontendTimerGroup)
1684 Timer.init(
"loading." + ModuleFileName,
"Loading " + ModuleFileName,
1685 *FrontendTimerGroup);
1686 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer :
nullptr);
1690 unsigned ARRFlags = Source == ModuleCache ?
1693 switch (ModuleManager->ReadAST(ModuleFileName,
1694 Source == PrebuiltModulePath
1696 : Source == ModuleBuildPragma
1699 ImportLoc, ARRFlags)) {
1701 if (Source != ModuleCache && !Module) {
1702 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1704 FileMgr->getFile(ModuleFileName) != Module->
getASTFile()) {
1709 ModuleBuildFailed =
true;
1710 KnownModules[Path[0].first] =
nullptr;
1719 if (Source != ModuleCache) {
1723 ModuleBuildFailed =
true;
1724 KnownModules[Path[0].first] =
nullptr;
1729 assert(Module &&
"missing module file");
1732 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1733 for (; Pos != PosEnd; ++Pos) {
1734 if (Pos->first == ModuleName)
1738 if (Pos != PosEnd) {
1740 for (; Pos != PosEnd; ++Pos) {
1741 CyclePath += Pos->first;
1742 CyclePath +=
" -> ";
1744 CyclePath += ModuleName;
1747 << ModuleName << CyclePath;
1758 ModuleBuildFailed =
true;
1766 "undiagnosed error in compileAndLoadModule");
1769 KnownModules[Path[0].first] =
nullptr;
1770 ModuleBuildFailed =
true;
1779 if (Source == PrebuiltModulePath)
1783 diag::warn_module_config_mismatch)
1792 KnownModules[Path[0].first] =
nullptr;
1798 KnownModules[Path[0].first] =
nullptr;
1799 ModuleBuildFailed =
true;
1804 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1813 if (Path.size() > 1) {
1814 for (
unsigned I = 1, N = Path.size();
I != N; ++
I) {
1815 StringRef
Name = Path[
I].first->getName();
1826 unsigned ED = Name.edit_distance((*J)->Name,
1829 if (ED <= BestEditDistance) {
1830 if (ED < BestEditDistance) {
1832 BestEditDistance = ED;
1835 Best.push_back((*J)->Name);
1840 if (Best.size() == 1) {
1842 diag::err_no_submodule_suggest)
1877 <<
SourceRange(Path.front().second, Path.back().second);
1886 <<
SourceRange(Path.front().second, Path.back().second);
1887 LastModuleImportLoc = ImportLoc;
1892 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1897 for (
unsigned I = 0, N = TopModule->
ConfigMacros.size();
I != N; ++
I) {
1902 LastModuleImportLoc = ImportLoc;
1904 return LastModuleImportResult;
1908 StringRef ModuleName,
1912 for (
auto &C : CleanModuleName)
1920 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1921 CleanModuleName,
"pcm", ModuleFileName)) {
1923 << ModuleFileName << EC.message();
1926 std::string ModuleMapFileName = (CleanModuleName +
".map").str();
1933 std::string NullTerminatedSource(Source.str());
1938 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
1939 ModuleMapFileName, NullTerminatedSource.size(), 0);
1940 Other.getSourceManager().overrideFileContents(
1942 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
1944 Other.BuiltModules = std::move(BuiltModules);
1945 Other.DeleteBuiltModules =
false;
1949 BuiltModules = std::move(Other.BuiltModules);
1954 ModuleFileName, PreBuildStep, PostBuildStep)) {
1955 BuiltModules[ModuleName] = ModuleFileName.str();
1956 llvm::sys::RemoveFileOnSignal(ModuleFileName);
1968 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
1973 if (
getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
1982 ModuleManager->loadGlobalIndex();
1987 llvm::sys::fs::create_directories(
1992 ModuleManager->resetForReload();
1993 ModuleManager->loadGlobalIndex();
1994 GlobalIndex = ModuleManager->getGlobalIndex();
1998 if (!HaveFullGlobalModuleIndex && GlobalIndex && !
buildingModule()) {
2000 bool RecreateIndex =
false;
2003 Module *TheModule =
I->second;
2007 Path.push_back(std::make_pair(
2009 std::reverse(Path.begin(), Path.end());
2012 RecreateIndex =
true;
2015 if (RecreateIndex) {
2019 ModuleManager->resetForReload();
2020 ModuleManager->loadGlobalIndex();
2021 GlobalIndex = ModuleManager->getGlobalIndex();
2023 HaveFullGlobalModuleIndex =
true;
2057 ExternalSemaSrc = std::move(ESS);
std::string OutputFile
The output file, if any.
unsigned IsAvailable
Whether this module is available in the current translation unit.
SourceManager & getSourceManager() const
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)
Defines the clang::ASTContext interface.
virtual bool isModelParsingAction() const
Is this action invoked on a model file?
LangOptions & getLangOpts()
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
bool hasFileManager() const
ASTContext & getASTContext() const
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred...
std::string Name
The name of this module.
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
DiagnosticConsumer * getClient()
module_iterator module_begin() const
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
SelectorTable & getSelectorTable()
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
bool hasASTConsumer() const
VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to c...
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
Implements support for file system lookup, file system caching, and directory search management...
virtual void adjust(LangOptions &Opts)
Set forced language options.
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...
vfs::FileSystem & getVirtualFileSystem() const
Defines the clang::FileManager interface and associated types.
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...
submodule_iterator submodule_begin()
static void writeTimestampFile(StringRef TimestampFile)
Write a new timestamp file with the given path.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Defines the SourceManager interface.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
MemoryBufferCache & getPCMCache() const
Abstract base class for actions which can be performed by the frontend.
DiagnosticOptions & getDiagnosticOpts()
std::string HeaderIncludeOutputFile
The file to write header include output to.
bool hasErrorOccurred() const
std::unique_ptr< llvm::MemoryBuffer > Buffer
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file...
void setAuxTarget(TargetInfo *Value)
Replace the current AuxTarget.
ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client a...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::shared_ptr< FailedModulesSet > FailedModules
The set of modules that failed to build.
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
TargetInfo & getTarget() const
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
SourceManager & getSourceManager() const
Return the current source manager.
Manage memory buffers across multiple users.
static PTHManager * Create(StringRef file, DiagnosticsEngine &Diags)
Create - This method creates PTHManager objects.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
DependencyOutputOptions & getDependencyOutputOpts()
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Builtin::Context & getBuiltinInfo()
void setPredefines(const char *P)
Set the predefines for this Preprocessor.
virtual void adjustTargetOptions(const CodeGenOptions &CGOpts, TargetOptions &TargetOpts) const
Adjust target options based on codegen options.
The client can handle an AST file that cannot load because it is missing.
void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)
std::string FindPchSource
If non-empty, search the pch input file as if it was a header included by this file.
The virtual file system interface.
One of these records is kept for each identifier that is lexed.
void setMainFileID(FileID FID)
Set the file ID for the main source file.
unsigned getNumWarnings() const
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)
void loadModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) override
Attempt to load the given module from the specified source buffer.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
void createFileManager()
Create the file manager and replace any existing one with it.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr< ModuleDependencyCollector > MDC)
A source location that has been parsed on the command line.
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
unsigned DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
CodeGenOptions & getCodeGenOpts()
bool buildingModule() const
Returns true if this instance is building a module.
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
ASTConsumer & getASTConsumer() const
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
Describes a module or submodule.
FileManager & getFileManager() const
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override
Make the given module visible.
bool SetCodeCompletionPoint(const FileEntry *File, unsigned Line, unsigned Column)
Specify the point at which code-completion will be performed.
std::error_code make_error_code(BuildPreambleError Error)
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
unsigned ShowStats
Show frontend performance metrics and statistics.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
FrontendOptions & getFrontendOpts()
IntrusiveRefCntPtr< vfs::FileSystem > getVirtualFileSystem() const
Visibility
Describes the different kinds of visibility that a declaration may have.
DiagnosticConsumer & getDiagnosticClient() const
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Concrete class used by the front-end to report problems and issues.
HeaderSearch & getHeaderSearchInfo() const
module_iterator module_end() const
Defines the Diagnostic-related interfaces.
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
StringRef getName() const
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value...
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
const FileEntry * getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
submodule_iterator submodule_end()
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
HeaderSearchOptions & getHeaderSearchOpts()
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
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...
The AST file itself appears corrupted.
detail::InMemoryDirectory::const_iterator I
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...
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
Builds a depdenency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
std::vector< Module * >::iterator submodule_iterator
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
bool hasVirtualFileSystem() const
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...
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, StringRef Path)
Write a global index into the given.
llvm::StringMap< Module * >::const_iterator module_iterator
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
static DependencyFileGenerator * CreateAndAttachToPreprocessor(Preprocessor &PP, const DependencyOutputOptions &Opts)
Sema - This implements semantic analysis and AST building for C.
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)
std::string CurrentModule
The name of the current module, of which the main source file is a part.
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
void setVirtualFileSystem(IntrusiveRefCntPtr< vfs::FileSystem > FS)
Replace the current virtual file system.
Describes the result of attempting to load a module.
std::string ShowIncludesPretendHeader
In /showIncludes mode, pretend the main TU is a header with this name.
std::vector< bool > & Stack
Exposes information about the current target.
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
A simple code-completion consumer that prints the results it receives in a simple format...
File is from a prebuilt module path.
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
std::string getSpecificModuleCachePath()
RAII object to temporarily add an AST callback listener.
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
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...
Defines version macros and version-related utility functions for Clang.
void finalizeCurrentBuffers()
Finalize the current buffers in the cache.
Defines the clang::Preprocessor interface.
bool hasDiagnostics() const
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
void createASTContext()
Create the AST context.
unsigned ShowHeaderIncludes
Show header inclusions (-H).
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
MemoryBufferCache & getPCMCache() const
static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts)
Determine the appropriate source input kind based on language options.
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
virtual void ExecuteAction()=0
Callback to run the program action, using the initialized compiler instance.
void addOutputFile(OutputFile &&OutFile)
addOutputFile - Add an output file onto the list of tracked output files.
static bool EnableCodeCompletion(Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column)
std::string AuxTriple
Auxiliary triple for CUDA compilation.
The client can't handle any AST loading failures.
std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
The AST file was missing.
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
Check global module index for missing imports.
std::unique_ptr< Sema > takeSema()
const DirectoryEntry * Directory
The build directory of this module.
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
bool hasSourceManager() const
FileSystemOptions & getFileSystemOpts()
bool isNamedPipe() const
Check whether the file is a named pipe (and thus can't be opened by the native FileManager methods)...
The control block was read successfully.
void ApplyHeaderSearchOptions(HeaderSearch &HS, const HeaderSearchOptions &HSOpts, const LangOptions &Lang, const llvm::Triple &triple)
Apply the header search options to get given HeaderSearch object.
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object...
File is a PCH file treated as the preamble.
void AttachToASTReader(ASTReader &R)
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
bool Execute()
Set the source manager's main input file, and run the action.
File is a PCH file treated as such.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
static LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool isValid() const
Return true if this is a valid SourceLocation object.
void collectVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Collect all pairs of <virtual path, real path> entries from the YAMLFilePath.
Options for controlling the compiler diagnostics engine.
std::vector< FrontendInputFile > Inputs
The input files and their types.
virtual void finish()
Callback to inform the diagnostic client that processing of all source files has ended.
All of the names in this module are hidden.
File is an implicitly-loaded module.
IdentifierTable & getIdentifierTable()
Cached information about one file (either on disk or in the virtual file system). ...
void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)
AttachDependencyGraphGen - Create a dependency graph generator, and attach it to the given preprocess...
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
std::unique_ptr< raw_pwrite_stream > createNullOutputFile()
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
const FileEntry * getVirtualFile(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...
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
FileID getMainFileID() const
Returns the FileID of the main source file.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
void resetNonModularOptions()
Reset any options that are not considered when building a module.
A global index for a set of module files, providing information about the identifiers within those mo...
The AST file was writtten with a different language/target configuration.
DiagnosticsEngine & getDiagnostics() const
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
TargetInfo * getAuxTarget() const
std::string OutputFile
The file to write dependency output to.
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Options controlling the behavior of code completion.
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
PreprocessorOptions & getPreprocessorOpts()
static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)
Reads an AST files chain containing the contents of a translation unit.
File is an explicitly-loaded module.
FileManager & getFileManager() const
Return the current file manager to the caller.
bool loadModuleFile(StringRef FileName)
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
StringRef getName() const
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
Used for handling and querying diagnostic IDs.
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Helper class for holding the data necessary to invoke the compiler.
static void pruneModuleCache(const HeaderSearchOptions &HSOpts)
Prune the module cache of modules that haven't been accessed in a long time.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
detail::InMemoryDirectory::const_iterator E
static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
FrontendOptions - Options for controlling the behavior of the frontend.
Abstract interface for a module loader.
Encapsulates the data about a macro definition (e.g.
std::string StatsFile
Filename to write statistics to.
SourceLocation DefinitionLoc
The location of the module definition.
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
void BuryPointer(const void *Ptr)
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Abstract interface for callback invocations by the ASTReader.
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
void setOverridenFilesKeepOriginalName(bool value)
Set true if the SourceManager should report the original file name for contents of files that were ov...
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
bool hasASTContext() const
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
void setTarget(TargetInfo *Value)
Replace the current Target.
Cached information about one directory (either on disk or in the virtual file system).
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
unsigned DisableFree
Disable memory freeing on exit.
virtual void Initialize(ASTContext &Context)
Initialize - This is called to initialize the consumer, providing the ASTContext. ...
void setInvocation(std::shared_ptr< CompilerInvocation > Value)
setInvocation - Replace the current invocation.
~CompilerInstance() override
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
void setModuleBuildStack(ModuleBuildStack stack)
Set the module build stack.
TranslationUnitKind
Describes the kind of translation unit being processed.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
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...
unsigned HasIncompatibleModuleFile
Whether we tried and failed to load a module file for this module.
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Defines the clang::TargetInfo interface.
The AST file is out-of-date relative to its input files, and needs to be regenerated.
A SourceLocation and its associated SourceManager.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
bool hasPreprocessor() const
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
unsigned getNumErrors() const
The AST file was written by a different version of Clang.
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
void createModuleManager()
}
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module.
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
A trivial tuple used to represent a source range.
unsigned PrintShowIncludes
Print cl.exe style /showIncludes info.
const DirectoryEntry * getDir() const
Return the directory the file lives in.
TargetOptions & getTargetOpts()
This class handles loading and caching of source files into memory.
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
void noSignedCharForObjCBool()
std::string DiagnosticLogFile
The file to log diagnostic output to.
std::string TokenCache
If given, a PTH cache file to use for speeding up header parsing.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
bool lookupIdentifier(StringRef Name, HitSet &Hits)
Look for all of the module files with information about the given identifier, e.g., a global function, variable, or type with that name.