1 //===--- CompilerInstance.cpp ---------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/Frontend/CompilerInstance.h"
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Basic/Diagnostic.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/MemoryBufferCache.h"
18 #include "clang/Basic/SourceManager.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Basic/Version.h"
21 #include "clang/Config/config.h"
22 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
23 #include "clang/Frontend/FrontendAction.h"
24 #include "clang/Frontend/FrontendActions.h"
25 #include "clang/Frontend/FrontendDiagnostic.h"
26 #include "clang/Frontend/LogDiagnosticPrinter.h"
27 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
28 #include "clang/Frontend/TextDiagnosticPrinter.h"
29 #include "clang/Frontend/Utils.h"
30 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
31 #include "clang/Lex/HeaderSearch.h"
32 #include "clang/Lex/PTHManager.h"
33 #include "clang/Lex/Preprocessor.h"
34 #include "clang/Lex/PreprocessorOptions.h"
35 #include "clang/Sema/CodeCompleteConsumer.h"
36 #include "clang/Sema/Sema.h"
37 #include "clang/Serialization/ASTReader.h"
38 #include "clang/Serialization/GlobalModuleIndex.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,
60 MemoryBufferCache *SharedPCMCache)
61 : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
62 Invocation(new CompilerInvocation()),
63 PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
64 ThePCHContainerOperations(std::move(PCHContainerOps)) {
65 // Don't allow this to invalidate buffers in use by others.
67 getPCMCache().finalizeCurrentBuffers();
70 CompilerInstance::~CompilerInstance() {
71 assert(OutputFiles.empty() && "Still output files in flight?");
74 void CompilerInstance::setInvocation(
75 std::shared_ptr<CompilerInvocation> Value) {
76 Invocation = std::move(Value);
79 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
80 return (BuildGlobalModuleIndex ||
81 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
82 getFrontendOpts().GenerateGlobalModuleIndex)) &&
86 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
90 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
91 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
93 void CompilerInstance::setFileManager(FileManager *Value) {
96 VirtualFileSystem = Value->getVirtualFileSystem();
98 VirtualFileSystem.reset();
101 void CompilerInstance::setSourceManager(SourceManager *Value) {
105 void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
106 PP = std::move(Value);
109 void CompilerInstance::setASTContext(ASTContext *Value) {
112 if (Context && Consumer)
113 getASTConsumer().Initialize(getASTContext());
116 void CompilerInstance::setSema(Sema *S) {
120 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
121 Consumer = std::move(Value);
123 if (Context && Consumer)
124 getASTConsumer().Initialize(getASTContext());
127 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
128 CompletionConsumer.reset(Value);
131 std::unique_ptr<Sema> CompilerInstance::takeSema() {
132 return std::move(TheSema);
135 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
136 return ModuleManager;
138 void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
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>
145 CompilerInstance::getModuleDepCollector() const {
146 return ModuleDepCollector;
149 void CompilerInstance::setModuleDepCollector(
150 std::shared_ptr<ModuleDependencyCollector> Collector) {
151 ModuleDepCollector = std::move(Collector);
154 static void collectHeaderMaps(const HeaderSearch &HS,
155 std::shared_ptr<ModuleDependencyCollector> MDC) {
156 SmallVector<std::string, 4> HeaderMapFileNames;
157 HS.getHeaderMapFileNames(HeaderMapFileNames);
158 for (auto &Name : HeaderMapFileNames)
162 static void collectIncludePCH(CompilerInstance &CI,
163 std::shared_ptr<ModuleDependencyCollector> MDC) {
164 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
165 if (PPOpts.ImplicitPCHInclude.empty())
168 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
169 FileManager &FileMgr = CI.getFileManager();
170 const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
172 MDC->addFile(PCHInclude);
177 SmallString<128> DirNative;
178 llvm::sys::path::native(PCHDir->getName(), DirNative);
179 vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
180 SimpleASTReaderListener Validator(CI.getPreprocessor());
181 for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
182 Dir != DirEnd && !EC; Dir.increment(EC)) {
183 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
184 // used here since we're not interested in validating the PCH at this time,
185 // but only to check whether this is a file containing an AST.
186 if (!ASTReader::readASTFileControlBlock(
187 Dir->getName(), FileMgr, CI.getPCHContainerReader(),
188 /*FindModuleFileExtensions=*/false, Validator,
189 /*ValidateDiagnosticOptions=*/false))
190 MDC->addFile(Dir->getName());
194 static void collectVFSEntries(CompilerInstance &CI,
195 std::shared_ptr<ModuleDependencyCollector> MDC) {
196 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
199 // Collect all VFS found.
200 SmallVector<vfs::YAMLVFSEntry, 16> VFSEntries;
201 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
202 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
203 llvm::MemoryBuffer::getFile(VFSFile);
206 vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr,
207 VFSFile, VFSEntries);
210 for (auto &E : VFSEntries)
211 MDC->addFile(E.VPath, E.RPath);
215 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
216 const CodeGenOptions *CodeGenOpts,
217 DiagnosticsEngine &Diags) {
219 std::unique_ptr<raw_ostream> StreamOwner;
220 raw_ostream *OS = &llvm::errs();
221 if (DiagOpts->DiagnosticLogFile != "-") {
222 // Create the output stream.
223 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
224 DiagOpts->DiagnosticLogFile, EC,
225 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
227 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
228 << DiagOpts->DiagnosticLogFile << EC.message();
230 FileOS->SetUnbuffered();
232 StreamOwner = std::move(FileOS);
236 // Chain in the diagnostic client which will log the diagnostics.
237 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
238 std::move(StreamOwner));
240 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
241 assert(Diags.ownsClient());
243 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
246 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
247 DiagnosticsEngine &Diags,
248 StringRef OutputFile) {
249 auto SerializedConsumer =
250 clang::serialized_diags::create(OutputFile, DiagOpts);
252 if (Diags.ownsClient()) {
253 Diags.setClient(new ChainedDiagnosticConsumer(
254 Diags.takeClient(), std::move(SerializedConsumer)));
256 Diags.setClient(new ChainedDiagnosticConsumer(
257 Diags.getClient(), std::move(SerializedConsumer)));
261 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
262 bool ShouldOwnClient) {
263 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
264 ShouldOwnClient, &getCodeGenOpts());
267 IntrusiveRefCntPtr<DiagnosticsEngine>
268 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
269 DiagnosticConsumer *Client,
270 bool ShouldOwnClient,
271 const CodeGenOptions *CodeGenOpts) {
272 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
273 IntrusiveRefCntPtr<DiagnosticsEngine>
274 Diags(new DiagnosticsEngine(DiagID, Opts));
276 // Create the diagnostic client for reporting errors or for
277 // implementing -verify.
279 Diags->setClient(Client, ShouldOwnClient);
281 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
283 // Chain in -verify checker, if requested.
284 if (Opts->VerifyDiagnostics)
285 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
287 // Chain in -diagnostic-log-file dumper, if requested.
288 if (!Opts->DiagnosticLogFile.empty())
289 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
291 if (!Opts->DiagnosticSerializationFile.empty())
292 SetupSerializedDiagnostics(Opts, *Diags,
293 Opts->DiagnosticSerializationFile);
295 // Configure our handling of diagnostics.
296 ProcessWarningOptions(*Diags, *Opts);
303 FileManager *CompilerInstance::createFileManager() {
304 if (!hasVirtualFileSystem()) {
305 if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
306 createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()))
307 setVirtualFileSystem(VFS);
311 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
312 return FileMgr.get();
317 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
318 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
321 // Initialize the remapping of files to alternative contents, e.g.,
322 // those specified through other files.
323 static void InitializeFileRemapping(DiagnosticsEngine &Diags,
324 SourceManager &SourceMgr,
325 FileManager &FileMgr,
326 const PreprocessorOptions &InitOpts) {
327 // Remap files in the source manager (with buffers).
328 for (const auto &RB : InitOpts.RemappedFileBuffers) {
329 // Create the file entry for the file that we're mapping from.
330 const FileEntry *FromFile =
331 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
333 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
334 if (!InitOpts.RetainRemappedFileBuffers)
339 // Override the contents of the "from" file with the contents of
341 SourceMgr.overrideFileContents(FromFile, RB.second,
342 InitOpts.RetainRemappedFileBuffers);
345 // Remap files in the source manager (with other files).
346 for (const auto &RF : InitOpts.RemappedFiles) {
347 // Find the file that we're mapping to.
348 const FileEntry *ToFile = FileMgr.getFile(RF.second);
350 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
354 // Create the file entry for the file that we're mapping from.
355 const FileEntry *FromFile =
356 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
358 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
362 // Override the contents of the "from" file with the contents of
364 SourceMgr.overrideFileContents(FromFile, ToFile);
367 SourceMgr.setOverridenFilesKeepOriginalName(
368 InitOpts.RemappedFilesKeepOriginalName);
373 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
374 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
376 // Create a PTH manager if we are using some form of a token cache.
377 PTHManager *PTHMgr = nullptr;
378 if (!PPOpts.TokenCache.empty())
379 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
381 // Create the Preprocessor.
382 HeaderSearch *HeaderInfo =
383 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
384 getDiagnostics(), getLangOpts(), &getTarget());
385 PP = std::make_shared<Preprocessor>(
386 Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
387 getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
388 /*OwnsHeaderSearch=*/true, TUKind);
389 getTarget().adjust(getLangOpts());
390 PP->Initialize(getTarget(), getAuxTarget());
392 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
393 // That argument is used as the IdentifierInfoLookup argument to
394 // IdentifierTable's ctor.
396 PTHMgr->setPreprocessor(&*PP);
397 PP->setPTHManager(PTHMgr);
400 if (PPOpts.DetailedRecord)
401 PP->createPreprocessingRecord();
403 // Apply remappings to the source manager.
404 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
405 PP->getFileManager(), PPOpts);
407 // Predefine macros and configure the preprocessor.
408 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
411 // Initialize the header search object. In CUDA compilations, we use the aux
412 // triple (the host triple) to initialize our header search, since we need to
413 // find the host headers in order to compile the CUDA code.
414 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
415 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
416 PP->getAuxTargetInfo())
417 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
419 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
420 PP->getLangOpts(), *HeaderSearchTriple);
422 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
424 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
425 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
427 // Handle generating dependencies, if requested.
428 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
429 if (!DepOpts.OutputFile.empty())
430 TheDependencyFileGenerator.reset(
431 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
432 if (!DepOpts.DOTOutputFile.empty())
433 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
434 getHeaderSearchOpts().Sysroot);
436 // If we don't have a collector, but we are collecting module dependencies,
437 // then we're the top level compiler instance and need to create one.
438 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
439 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
440 DepOpts.ModuleDependencyOutputDir);
443 // If there is a module dep collector, register with other dep collectors
444 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
445 if (ModuleDepCollector) {
446 addDependencyCollector(ModuleDepCollector);
447 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
448 collectIncludePCH(*this, ModuleDepCollector);
449 collectVFSEntries(*this, ModuleDepCollector);
452 for (auto &Listener : DependencyCollectors)
453 Listener->attachToPreprocessor(*PP);
455 // Handle generating header include information, if requested.
456 if (DepOpts.ShowHeaderIncludes)
457 AttachHeaderIncludeGen(*PP, DepOpts);
458 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
459 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
460 if (OutputPath == "-")
462 AttachHeaderIncludeGen(*PP, DepOpts,
463 /*ShowAllHeaders=*/true, OutputPath,
464 /*ShowDepth=*/false);
467 if (DepOpts.PrintShowIncludes) {
468 AttachHeaderIncludeGen(*PP, DepOpts,
469 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
470 /*ShowDepth=*/true, /*MSStyle=*/true);
474 std::string CompilerInstance::getSpecificModuleCachePath() {
475 // Set up the module path, including the hash for the
476 // module-creation options.
477 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
478 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
479 llvm::sys::path::append(SpecificModuleCache,
480 getInvocation().getModuleHash());
481 return SpecificModuleCache.str();
486 void CompilerInstance::createASTContext() {
487 Preprocessor &PP = getPreprocessor();
488 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
489 PP.getIdentifierTable(), PP.getSelectorTable(),
490 PP.getBuiltinInfo());
491 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
492 setASTContext(Context);
497 void CompilerInstance::createPCHExternalASTSource(
498 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
499 void *DeserializationListener, bool OwnDeserializationListener) {
500 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
501 ModuleManager = createPCHExternalASTSource(
502 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
503 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
504 getPCHContainerReader(),
505 getFrontendOpts().ModuleFileExtensions,
506 TheDependencyFileGenerator.get(),
507 DependencyCollectors,
508 DeserializationListener,
509 OwnDeserializationListener, Preamble,
510 getFrontendOpts().UseGlobalModuleIndex);
513 IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
514 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
515 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
516 const PCHContainerReader &PCHContainerRdr,
517 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
518 DependencyFileGenerator *DependencyFile,
519 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
520 void *DeserializationListener, bool OwnDeserializationListener,
521 bool Preamble, bool UseGlobalModuleIndex) {
522 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
524 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
525 PP, &Context, PCHContainerRdr, Extensions,
526 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
527 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
528 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
530 // We need the external source to be set up before we read the AST, because
531 // eagerly-deserialized declarations may use it.
532 Context.setExternalSource(Reader.get());
534 Reader->setDeserializationListener(
535 static_cast<ASTDeserializationListener *>(DeserializationListener),
536 /*TakeOwnership=*/OwnDeserializationListener);
539 DependencyFile->AttachToASTReader(*Reader);
540 for (auto &Listener : DependencyCollectors)
541 Listener->attachToASTReader(*Reader);
543 switch (Reader->ReadAST(Path,
544 Preamble ? serialization::MK_Preamble
545 : serialization::MK_PCH,
547 ASTReader::ARR_None)) {
548 case ASTReader::Success:
549 // Set the predefines buffer as suggested by the PCH reader. Typically, the
550 // predefines buffer will be empty.
551 PP.setPredefines(Reader->getSuggestedPredefines());
554 case ASTReader::Failure:
555 // Unrecoverable failure: don't even try to process the input file.
558 case ASTReader::Missing:
559 case ASTReader::OutOfDate:
560 case ASTReader::VersionMismatch:
561 case ASTReader::ConfigurationMismatch:
562 case ASTReader::HadErrors:
563 // No suitable PCH file could be found. Return an error.
567 Context.setExternalSource(nullptr);
573 static bool EnableCodeCompletion(Preprocessor &PP,
577 // Tell the source manager to chop off the given file at a specific
579 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
581 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
586 // Truncate the named file at the given line/column.
587 PP.SetCodeCompletionPoint(Entry, Line, Column);
591 void CompilerInstance::createCodeCompletionConsumer() {
592 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
593 if (!CompletionConsumer) {
594 setCodeCompletionConsumer(
595 createCodeCompletionConsumer(getPreprocessor(),
596 Loc.FileName, Loc.Line, Loc.Column,
597 getFrontendOpts().CodeCompleteOpts,
599 if (!CompletionConsumer)
601 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
602 Loc.Line, Loc.Column)) {
603 setCodeCompletionConsumer(nullptr);
607 if (CompletionConsumer->isOutputBinary() &&
608 llvm::sys::ChangeStdoutToBinary()) {
609 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
610 setCodeCompletionConsumer(nullptr);
614 void CompilerInstance::createFrontendTimer() {
615 FrontendTimerGroup.reset(
616 new llvm::TimerGroup("frontend", "Clang front-end time report"));
618 new llvm::Timer("frontend", "Clang front-end timer",
619 *FrontendTimerGroup));
622 CodeCompleteConsumer *
623 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
627 const CodeCompleteOptions &Opts,
629 if (EnableCodeCompletion(PP, Filename, Line, Column))
632 // Set up the creation routine for code-completion.
633 return new PrintingCodeCompleteConsumer(Opts, OS);
636 void CompilerInstance::createSema(TranslationUnitKind TUKind,
637 CodeCompleteConsumer *CompletionConsumer) {
638 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
639 TUKind, CompletionConsumer));
640 // Attach the external sema source if there is any.
641 if (ExternalSemaSrc) {
642 TheSema->addExternalSource(ExternalSemaSrc.get());
643 ExternalSemaSrc->InitializeSema(*TheSema);
649 void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
650 OutputFiles.push_back(std::move(OutFile));
653 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
654 for (OutputFile &OF : OutputFiles) {
655 if (!OF.TempFilename.empty()) {
657 llvm::sys::fs::remove(OF.TempFilename);
659 SmallString<128> NewOutFile(OF.Filename);
661 // If '-working-directory' was passed, the output filename should be
663 FileMgr->FixupRelativePath(NewOutFile);
664 if (std::error_code ec =
665 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
666 getDiagnostics().Report(diag::err_unable_to_rename_temp)
667 << OF.TempFilename << OF.Filename << ec.message();
669 llvm::sys::fs::remove(OF.TempFilename);
672 } else if (!OF.Filename.empty() && EraseFiles)
673 llvm::sys::fs::remove(OF.Filename);
676 if (DeleteBuiltModules) {
677 for (auto &Module : BuiltModules)
678 llvm::sys::fs::remove(Module.second);
679 BuiltModules.clear();
681 NonSeekStream.reset();
684 std::unique_ptr<raw_pwrite_stream>
685 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
686 StringRef Extension) {
687 return createOutputFile(getFrontendOpts().OutputFile, Binary,
688 /*RemoveFileOnSignal=*/true, InFile, Extension,
689 /*UseTemporary=*/true);
692 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
693 return llvm::make_unique<llvm::raw_null_ostream>();
696 std::unique_ptr<raw_pwrite_stream>
697 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
698 bool RemoveFileOnSignal, StringRef InFile,
699 StringRef Extension, bool UseTemporary,
700 bool CreateMissingDirectories) {
701 std::string OutputPathName, TempPathName;
703 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
704 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
705 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
707 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
712 // Add the output file -- but don't try to remove "-", since this means we are
715 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
720 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
721 StringRef OutputPath, std::error_code &Error, bool Binary,
722 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
723 bool UseTemporary, bool CreateMissingDirectories,
724 std::string *ResultPathName, std::string *TempPathName) {
725 assert((!CreateMissingDirectories || UseTemporary) &&
726 "CreateMissingDirectories is only allowed when using temporary files");
728 std::string OutFile, TempFile;
729 if (!OutputPath.empty()) {
730 OutFile = OutputPath;
731 } else if (InFile == "-") {
733 } else if (!Extension.empty()) {
734 SmallString<128> Path(InFile);
735 llvm::sys::path::replace_extension(Path, Extension);
736 OutFile = Path.str();
741 std::unique_ptr<llvm::raw_fd_ostream> OS;
746 UseTemporary = false;
748 llvm::sys::fs::file_status Status;
749 llvm::sys::fs::status(OutputPath, Status);
750 if (llvm::sys::fs::exists(Status)) {
751 // Fail early if we can't write to the final destination.
752 if (!llvm::sys::fs::can_write(OutputPath)) {
753 Error = make_error_code(llvm::errc::operation_not_permitted);
757 // Don't use a temporary if the output is a special file. This handles
758 // things like '-o /dev/null'
759 if (!llvm::sys::fs::is_regular_file(Status))
760 UseTemporary = false;
766 // Create a temporary file.
767 // Insert -%%%%%%%% before the extension (if any), and because some tools
768 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
769 // artifacts, also append .tmp.
770 StringRef OutputExtension = llvm::sys::path::extension(OutFile);
771 SmallString<128> TempPath =
772 StringRef(OutFile).drop_back(OutputExtension.size());
773 TempPath += "-%%%%%%%%";
774 TempPath += OutputExtension;
778 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
780 if (CreateMissingDirectories &&
781 EC == llvm::errc::no_such_file_or_directory) {
782 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
783 EC = llvm::sys::fs::create_directories(Parent);
785 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
790 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
791 OSFile = TempFile = TempPath.str();
793 // If we failed to create the temporary, fallback to writing to the file
794 // directly. This handles the corner case where we cannot write to the
795 // directory, but can write to the file.
800 OS.reset(new llvm::raw_fd_ostream(
802 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
807 // Make sure the out stream file gets removed if we crash.
808 if (RemoveFileOnSignal)
809 llvm::sys::RemoveFileOnSignal(OSFile);
812 *ResultPathName = OutFile;
814 *TempPathName = TempFile;
816 if (!Binary || OS->supportsSeeking())
817 return std::move(OS);
819 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
820 assert(!NonSeekStream);
821 NonSeekStream = std::move(OS);
825 // Initialization Utilities
827 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
828 return InitializeSourceManager(
829 Input, getDiagnostics(), getFileManager(), getSourceManager(),
830 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
831 getDependencyOutputOpts(), getFrontendOpts());
835 bool CompilerInstance::InitializeSourceManager(
836 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
837 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
838 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
839 SrcMgr::CharacteristicKind Kind =
840 Input.getKind().getFormat() == InputKind::ModuleMap
841 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
842 : SrcMgr::C_User_ModuleMap
843 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
845 if (Input.isBuffer()) {
846 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
847 Input.getBuffer(), Kind));
848 assert(SourceMgr.getMainFileID().isValid() &&
849 "Couldn't establish MainFileID!");
853 StringRef InputFile = Input.getFile();
855 // Figure out where to get and map in the main file.
856 if (InputFile != "-") {
857 const FileEntry *File;
858 if (Opts.FindPchSource.empty()) {
859 File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
861 // When building a pch file in clang-cl mode, the .h file is built as if
862 // it was included by a cc file. Since the driver doesn't know about
863 // all include search directories, the frontend must search the input
864 // file through HeaderSearch here, as if it had been included by the
865 // cc file at Opts.FindPchSource.
866 const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource);
868 Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
871 const DirectoryLookup *UnusedCurDir;
872 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
874 Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
875 File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
877 /*CurDir=*/UnusedCurDir, Includers,
878 /*SearchPath=*/nullptr,
879 /*RelativePath=*/nullptr,
880 /*RequestingModule=*/nullptr,
881 /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
883 // Also add the header to /showIncludes output.
885 DepOpts.ShowIncludesPretendHeader = File->getName();
888 Diags.Report(diag::err_fe_error_reading) << InputFile;
892 // The natural SourceManager infrastructure can't currently handle named
893 // pipes, but we would at least like to accept them for the main
894 // file. Detect them here, read them with the volatile flag so FileMgr will
895 // pick up the correct size, and simply override their contents as we do for
897 if (File->isNamedPipe()) {
898 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
900 // Create a new virtual file that will have the correct size.
901 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
902 SourceMgr.overrideFileContents(File, std::move(*MB));
904 Diags.Report(diag::err_cannot_open_file) << InputFile
905 << MB.getError().message();
910 SourceMgr.setMainFileID(
911 SourceMgr.createFileID(File, SourceLocation(), Kind));
913 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
914 llvm::MemoryBuffer::getSTDIN();
915 if (std::error_code EC = SBOrErr.getError()) {
916 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
919 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
921 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
922 SB->getBufferSize(), 0);
923 SourceMgr.setMainFileID(
924 SourceMgr.createFileID(File, SourceLocation(), Kind));
925 SourceMgr.overrideFileContents(File, std::move(SB));
928 assert(SourceMgr.getMainFileID().isValid() &&
929 "Couldn't establish MainFileID!");
933 // High-Level Operations
935 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
936 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
937 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
938 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
940 // FIXME: Take this as an argument, once all the APIs we used have moved to
941 // taking it as an input instead of hard-coding llvm::errs.
942 raw_ostream &OS = llvm::errs();
944 // Create the target instance.
945 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
946 getInvocation().TargetOpts));
950 // Create TargetInfo for the other side of CUDA and OpenMP compilation.
951 if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
952 !getFrontendOpts().AuxTriple.empty()) {
953 auto TO = std::make_shared<TargetOptions>();
954 TO->Triple = getFrontendOpts().AuxTriple;
955 TO->HostTriple = getTarget().getTriple().str();
956 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
959 // Inform the target of the language options.
961 // FIXME: We shouldn't need to do this, the target should be immutable once
962 // created. This complexity should be lifted elsewhere.
963 getTarget().adjust(getLangOpts());
965 // Adjust target options based on codegen options.
966 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
968 // rewriter project will change target built-in bool type from its default.
969 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
970 getTarget().noSignedCharForObjCBool();
972 // Validate/process some options.
973 if (getHeaderSearchOpts().Verbose)
974 OS << "clang -cc1 version " CLANG_VERSION_STRING
975 << " based upon " << BACKEND_PACKAGE_STRING
976 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
978 if (getFrontendOpts().ShowTimers)
979 createFrontendTimer();
981 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
982 llvm::EnableStatistics(false);
984 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
985 // Reset the ID tables if we are reusing the SourceManager and parsing
987 if (hasSourceManager() && !Act.isModelParsingAction())
988 getSourceManager().clearIDTables();
990 if (Act.BeginSourceFile(*this, FIF)) {
996 // Notify the diagnostic client that all files were processed.
997 getDiagnostics().getClient()->finish();
999 if (getDiagnosticOpts().ShowCarets) {
1000 // We can have multiple diagnostics sharing one diagnostic client.
1001 // Get the total number of warnings/errors from the client.
1002 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
1003 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
1006 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1007 if (NumWarnings && NumErrors)
1010 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1011 if (NumWarnings || NumErrors) {
1013 if (getLangOpts().CUDA) {
1014 if (!getLangOpts().CUDAIsDevice) {
1015 OS << " when compiling for host";
1017 OS << " when compiling for " << getTargetOpts().CPU;
1024 if (getFrontendOpts().ShowStats) {
1025 if (hasFileManager()) {
1026 getFileManager().PrintStats();
1029 llvm::PrintStatistics(OS);
1031 StringRef StatsFile = getFrontendOpts().StatsFile;
1032 if (!StatsFile.empty()) {
1034 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1035 llvm::sys::fs::F_Text);
1037 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1038 << StatsFile << EC.message();
1040 llvm::PrintStatisticsJSON(*StatS);
1044 return !getDiagnostics().getClient()->getNumErrors();
1047 /// \brief Determine the appropriate source input kind based on language
1049 static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
1050 if (LangOpts.OpenCL)
1051 return InputKind::OpenCL;
1053 return InputKind::CUDA;
1055 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1056 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1059 /// \brief Compile a module file for the given module, using the options
1060 /// provided by the importing compiler instance. Returns true if the module
1061 /// was built without errors.
1063 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1064 StringRef ModuleName, FrontendInputFile Input,
1065 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1066 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1067 [](CompilerInstance &) {},
1068 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1069 [](CompilerInstance &) {}) {
1070 // Construct a compiler invocation for creating this module.
1072 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1074 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1076 // For any options that aren't intended to affect how a module is built,
1077 // reset them to their default values.
1078 Invocation->getLangOpts()->resetNonModularOptions();
1079 PPOpts.resetNonModularOptions();
1081 // Remove any macro definitions that are explicitly ignored by the module.
1082 // They aren't supposed to affect how the module is built anyway.
1083 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1084 PPOpts.Macros.erase(
1085 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1086 [&HSOpts](const std::pair<std::string, bool> &def) {
1087 StringRef MacroDef = def.first;
1088 return HSOpts.ModulesIgnoreMacros.count(
1089 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1091 PPOpts.Macros.end());
1093 // Note the name of the module we're building.
1094 Invocation->getLangOpts()->CurrentModule = ModuleName;
1096 // Make sure that the failed-module structure has been allocated in
1097 // the importing instance, and propagate the pointer to the newly-created
1099 PreprocessorOptions &ImportingPPOpts
1100 = ImportingInstance.getInvocation().getPreprocessorOpts();
1101 if (!ImportingPPOpts.FailedModules)
1102 ImportingPPOpts.FailedModules =
1103 std::make_shared<PreprocessorOptions::FailedModulesSet>();
1104 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1106 // If there is a module map file, build the module using the module map.
1107 // Set up the inputs/outputs so that we build the module from its umbrella
1109 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1110 FrontendOpts.OutputFile = ModuleFileName.str();
1111 FrontendOpts.DisableFree = false;
1112 FrontendOpts.GenerateGlobalModuleIndex = false;
1113 FrontendOpts.BuildingImplicitModule = true;
1114 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1115 // Force implicitly-built modules to hash the content of the module file.
1116 HSOpts.ModulesHashContent = true;
1117 FrontendOpts.Inputs = {Input};
1119 // Don't free the remapped file buffers; they are owned by our caller.
1120 PPOpts.RetainRemappedFileBuffers = true;
1122 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1123 assert(ImportingInstance.getInvocation().getModuleHash() ==
1124 Invocation->getModuleHash() && "Module hash mismatch!");
1126 // Construct a compiler instance that will be used to actually create the
1127 // module. Since we're sharing a PCMCache,
1128 // CompilerInstance::CompilerInstance is responsible for finalizing the
1129 // buffers to prevent use-after-frees.
1130 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1131 &ImportingInstance.getPreprocessor().getPCMCache());
1132 auto &Inv = *Invocation;
1133 Instance.setInvocation(std::move(Invocation));
1135 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1136 ImportingInstance.getDiagnosticClient()),
1137 /*ShouldOwnClient=*/true);
1139 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1141 // Note that this module is part of the module build stack, so that we
1142 // can detect cycles in the module graph.
1143 Instance.setFileManager(&ImportingInstance.getFileManager());
1144 Instance.createSourceManager(Instance.getFileManager());
1145 SourceManager &SourceMgr = Instance.getSourceManager();
1146 SourceMgr.setModuleBuildStack(
1147 ImportingInstance.getSourceManager().getModuleBuildStack());
1148 SourceMgr.pushModuleBuildStack(ModuleName,
1149 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1151 // If we're collecting module dependencies, we need to share a collector
1152 // between all of the module CompilerInstances. Other than that, we don't
1153 // want to produce any dependency output from the module build.
1154 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1155 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1157 ImportingInstance.getDiagnostics().Report(ImportLoc,
1158 diag::remark_module_build)
1159 << ModuleName << ModuleFileName;
1161 PreBuildStep(Instance);
1163 // Execute the action to actually build the module in-place. Use a separate
1164 // thread so that we get a stack large enough.
1165 const unsigned ThreadStackSize = 8 << 20;
1166 llvm::CrashRecoveryContext CRC;
1167 CRC.RunSafelyOnThread(
1169 GenerateModuleFromModuleMapAction Action;
1170 Instance.ExecuteAction(Action);
1174 PostBuildStep(Instance);
1176 ImportingInstance.getDiagnostics().Report(ImportLoc,
1177 diag::remark_module_build_done)
1180 // Delete the temporary module map file.
1181 // FIXME: Even though we're executing under crash protection, it would still
1182 // be nice to do this with RemoveFileOnSignal when we can. However, that
1183 // doesn't make sense for all clients, so clean this up manually.
1184 Instance.clearOutputFiles(/*EraseFiles=*/true);
1186 return !Instance.getDiagnostics().hasErrorOccurred();
1189 /// \brief Compile a module file for the given module, using the options
1190 /// provided by the importing compiler instance. Returns true if the module
1191 /// was built without errors.
1192 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1193 SourceLocation ImportLoc,
1195 StringRef ModuleFileName) {
1196 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1197 InputKind::ModuleMap);
1199 // Get or create the module map that we'll use to build this module.
1201 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1203 if (const FileEntry *ModuleMapFile =
1204 ModMap.getContainingModuleMapFile(Module)) {
1205 // Use the module map where this module resides.
1206 Result = compileModuleImpl(
1207 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1208 FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1209 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1212 // FIXME: We only need to fake up an input file here as a way of
1213 // transporting the module's directory to the module map parser. We should
1214 // be able to do that more directly, and parse from a memory buffer without
1215 // inventing this file.
1216 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1217 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1219 std::string InferredModuleMapContent;
1220 llvm::raw_string_ostream OS(InferredModuleMapContent);
1224 Result = compileModuleImpl(
1225 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1226 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1227 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1229 [&](CompilerInstance &Instance) {
1230 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1231 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1232 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1233 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1234 Instance.getSourceManager().overrideFileContents(
1235 ModuleMapFile, std::move(ModuleMapBuffer));
1239 // We've rebuilt a module. If we're allowed to generate or update the global
1240 // module index, record that fact in the importing compiler instance.
1241 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1242 ImportingInstance.setBuildGlobalModuleIndex(true);
1248 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1249 SourceLocation ImportLoc,
1250 SourceLocation ModuleNameLoc, Module *Module,
1251 StringRef ModuleFileName) {
1252 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1254 auto diagnoseBuildFailure = [&] {
1255 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1256 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1259 // FIXME: have LockFileManager return an error_code so that we can
1260 // avoid the mkdir when the directory already exists.
1261 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1262 llvm::sys::fs::create_directories(Dir);
1265 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1266 llvm::LockFileManager Locked(ModuleFileName);
1268 case llvm::LockFileManager::LFS_Error:
1269 // PCMCache takes care of correctness and locks are only necessary for
1270 // performance. Fallback to building the module in case of any lock
1272 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1273 << Module->Name << Locked.getErrorMessage();
1274 // Clear out any potential leftover.
1275 Locked.unsafeRemoveLockFile();
1277 case llvm::LockFileManager::LFS_Owned:
1278 // We're responsible for building the module ourselves.
1279 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1281 diagnoseBuildFailure();
1286 case llvm::LockFileManager::LFS_Shared:
1287 // Someone else is responsible for building the module. Wait for them to
1289 switch (Locked.waitForUnlock()) {
1290 case llvm::LockFileManager::Res_Success:
1291 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1293 case llvm::LockFileManager::Res_OwnerDied:
1294 continue; // try again to get the lock.
1295 case llvm::LockFileManager::Res_Timeout:
1296 // Since PCMCache takes care of correctness, we try waiting for another
1297 // process to complete the build so clang does not do it done twice. If
1298 // case of timeout, build it ourselves.
1299 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1301 // Clear the lock file so that future invokations can make progress.
1302 Locked.unsafeRemoveLockFile();
1308 // Try to read the module file, now that we've compiled it.
1309 ASTReader::ASTReadResult ReadResult =
1310 ImportingInstance.getModuleManager()->ReadAST(
1311 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1312 ModuleLoadCapabilities);
1314 if (ReadResult == ASTReader::OutOfDate &&
1315 Locked == llvm::LockFileManager::LFS_Shared) {
1316 // The module may be out of date in the presence of file system races,
1317 // or if one of its imports depends on header search paths that are not
1318 // consistent with this ImportingInstance. Try again...
1320 } else if (ReadResult == ASTReader::Missing) {
1321 diagnoseBuildFailure();
1322 } else if (ReadResult != ASTReader::Success &&
1323 !Diags.hasErrorOccurred()) {
1324 // The ASTReader didn't diagnose the error, so conservatively report it.
1325 diagnoseBuildFailure();
1327 return ReadResult == ASTReader::Success;
1331 /// \brief Diagnose differences between the current definition of the given
1332 /// configuration macro and the definition provided on the command line.
1333 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1334 Module *Mod, SourceLocation ImportLoc) {
1335 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1336 SourceManager &SourceMgr = PP.getSourceManager();
1338 // If this identifier has never had a macro definition, then it could
1339 // not have changed.
1340 if (!Id->hadMacroDefinition())
1342 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1344 // Find the macro definition from the command line.
1345 MacroInfo *CmdLineDefinition = nullptr;
1346 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1347 // We only care about the predefines buffer.
1348 FileID FID = SourceMgr.getFileID(MD->getLocation());
1349 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1351 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1352 CmdLineDefinition = DMD->getMacroInfo();
1356 auto *CurrentDefinition = PP.getMacroInfo(Id);
1357 if (CurrentDefinition == CmdLineDefinition) {
1358 // Macro matches. Nothing to do.
1359 } else if (!CurrentDefinition) {
1360 // This macro was defined on the command line, then #undef'd later.
1362 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1363 << true << ConfigMacro << Mod->getFullModuleName();
1364 auto LatestDef = LatestLocalMD->getDefinition();
1365 assert(LatestDef.isUndefined() &&
1366 "predefined macro went away with no #undef?");
1367 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1370 } else if (!CmdLineDefinition) {
1371 // There was no definition for this macro in the predefines buffer,
1372 // but there was a local definition. Complain.
1373 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1374 << false << ConfigMacro << Mod->getFullModuleName();
1375 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1376 diag::note_module_def_undef_here)
1378 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1379 /*Syntactically=*/true)) {
1380 // The macro definitions differ.
1381 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1382 << false << ConfigMacro << Mod->getFullModuleName();
1383 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1384 diag::note_module_def_undef_here)
1389 /// \brief Write a new timestamp file with the given path.
1390 static void writeTimestampFile(StringRef TimestampFile) {
1392 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1395 /// \brief Prune the module cache of modules that haven't been accessed in
1397 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1398 struct stat StatBuf;
1399 llvm::SmallString<128> TimestampFile;
1400 TimestampFile = HSOpts.ModuleCachePath;
1401 assert(!TimestampFile.empty());
1402 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1404 // Try to stat() the timestamp file.
1405 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1406 // If the timestamp file wasn't there, create one now.
1407 if (errno == ENOENT) {
1408 writeTimestampFile(TimestampFile);
1413 // Check whether the time stamp is older than our pruning interval.
1414 // If not, do nothing.
1415 time_t TimeStampModTime = StatBuf.st_mtime;
1416 time_t CurrentTime = time(nullptr);
1417 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1420 // Write a new timestamp file so that nobody else attempts to prune.
1421 // There is a benign race condition here, if two Clang instances happen to
1422 // notice at the same time that the timestamp is out-of-date.
1423 writeTimestampFile(TimestampFile);
1425 // Walk the entire module cache, looking for unused module files and module
1428 SmallString<128> ModuleCachePathNative;
1429 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1430 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1431 Dir != DirEnd && !EC; Dir.increment(EC)) {
1432 // If we don't have a directory, there's nothing to look into.
1433 if (!llvm::sys::fs::is_directory(Dir->path()))
1436 // Walk all of the files within this directory.
1437 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1438 File != FileEnd && !EC; File.increment(EC)) {
1439 // We only care about module and global module index files.
1440 StringRef Extension = llvm::sys::path::extension(File->path());
1441 if (Extension != ".pcm" && Extension != ".timestamp" &&
1442 llvm::sys::path::filename(File->path()) != "modules.idx")
1445 // Look at this file. If we can't stat it, there's nothing interesting
1447 if (::stat(File->path().c_str(), &StatBuf))
1450 // If the file has been used recently enough, leave it there.
1451 time_t FileAccessTime = StatBuf.st_atime;
1452 if (CurrentTime - FileAccessTime <=
1453 time_t(HSOpts.ModuleCachePruneAfter)) {
1458 llvm::sys::fs::remove(File->path());
1460 // Remove the timestamp file.
1461 std::string TimpestampFilename = File->path() + ".timestamp";
1462 llvm::sys::fs::remove(TimpestampFilename);
1465 // If we removed all of the files in the directory, remove the directory
1467 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1468 llvm::sys::fs::directory_iterator() && !EC)
1469 llvm::sys::fs::remove(Dir->path());
1473 void CompilerInstance::createModuleManager() {
1474 if (!ModuleManager) {
1475 if (!hasASTContext())
1478 // If we're implicitly building modules but not currently recursively
1479 // building a module, check whether we need to prune the module cache.
1480 if (getSourceManager().getModuleBuildStack().empty() &&
1481 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1482 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1483 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1484 pruneModuleCache(getHeaderSearchOpts());
1487 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1488 std::string Sysroot = HSOpts.Sysroot;
1489 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1490 std::unique_ptr<llvm::Timer> ReadTimer;
1491 if (FrontendTimerGroup)
1492 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1494 *FrontendTimerGroup);
1495 ModuleManager = new ASTReader(
1496 getPreprocessor(), &getASTContext(), getPCHContainerReader(),
1497 getFrontendOpts().ModuleFileExtensions,
1498 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1499 /*AllowASTWithCompilerErrors=*/false,
1500 /*AllowConfigurationMismatch=*/false,
1501 HSOpts.ModulesValidateSystemHeaders,
1502 getFrontendOpts().UseGlobalModuleIndex,
1503 std::move(ReadTimer));
1504 if (hasASTConsumer()) {
1505 ModuleManager->setDeserializationListener(
1506 getASTConsumer().GetASTDeserializationListener());
1507 getASTContext().setASTMutationListener(
1508 getASTConsumer().GetASTMutationListener());
1510 getASTContext().setExternalSource(ModuleManager);
1512 ModuleManager->InitializeSema(getSema());
1513 if (hasASTConsumer())
1514 ModuleManager->StartTranslationUnit(&getASTConsumer());
1516 if (TheDependencyFileGenerator)
1517 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1518 for (auto &Listener : DependencyCollectors)
1519 Listener->attachToASTReader(*ModuleManager);
1523 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1525 if (FrontendTimerGroup)
1526 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1527 *FrontendTimerGroup);
1528 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1530 // Helper to recursively read the module names for all modules we're adding.
1531 // We mark these as known and redirect any attempt to load that module to
1532 // the files we were handed.
1533 struct ReadModuleNames : ASTReaderListener {
1534 CompilerInstance &CI;
1535 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
1537 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1539 void ReadModuleName(StringRef ModuleName) override {
1540 LoadedModules.push_back(
1541 CI.getPreprocessor().getIdentifierInfo(ModuleName));
1544 void registerAll() {
1545 for (auto *II : LoadedModules) {
1546 CI.KnownModules[II] = CI.getPreprocessor()
1547 .getHeaderSearchInfo()
1549 .findModule(II->getName());
1551 LoadedModules.clear();
1554 void markAllUnavailable() {
1555 for (auto *II : LoadedModules) {
1556 if (Module *M = CI.getPreprocessor()
1557 .getHeaderSearchInfo()
1559 .findModule(II->getName())) {
1560 M->HasIncompatibleModuleFile = true;
1562 // Mark module as available if the only reason it was unavailable
1563 // was missing headers.
1564 SmallVector<Module *, 2> Stack;
1566 while (!Stack.empty()) {
1567 Module *Current = Stack.pop_back_val();
1568 if (Current->IsMissingRequirement) continue;
1569 Current->IsAvailable = true;
1570 Stack.insert(Stack.end(),
1571 Current->submodule_begin(), Current->submodule_end());
1575 LoadedModules.clear();
1579 // If we don't already have an ASTReader, create one now.
1581 createModuleManager();
1583 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1584 auto &ListenerRef = *Listener;
1585 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1586 std::move(Listener));
1588 // Try to load the module file.
1589 switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1591 ASTReader::ARR_ConfigurationMismatch)) {
1592 case ASTReader::Success:
1593 // We successfully loaded the module file; remember the set of provided
1594 // modules so that we don't try to load implicit modules for them.
1595 ListenerRef.registerAll();
1598 case ASTReader::ConfigurationMismatch:
1599 // Ignore unusable module files.
1600 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1602 // All modules provided by any files we tried and failed to load are now
1603 // unavailable; includes of those modules should now be handled textually.
1604 ListenerRef.markAllUnavailable();
1613 CompilerInstance::loadModule(SourceLocation ImportLoc,
1615 Module::NameVisibilityKind Visibility,
1616 bool IsInclusionDirective) {
1617 // Determine what file we're searching from.
1618 // FIXME: Should we be deciding whether this is a submodule (here and
1619 // below) based on -fmodules-ts or should we pass a flag and make the
1621 std::string ModuleName;
1622 if (getLangOpts().ModulesTS) {
1623 // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a
1624 // better place/way to do this.
1625 for (auto &Piece : Path) {
1626 if (!ModuleName.empty())
1628 ModuleName += Piece.first->getName();
1632 ModuleName = Path[0].first->getName();
1634 SourceLocation ModuleNameLoc = Path[0].second;
1636 // If we've already handled this import, just return the cached result.
1637 // This one-element cache is important to eliminate redundant diagnostics
1638 // when both the preprocessor and parser see the same import declaration.
1639 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1640 // Make the named module visible.
1641 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1642 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1644 return LastModuleImportResult;
1647 clang::Module *Module = nullptr;
1649 // If we don't already have information on this module, load the module now.
1650 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1651 = KnownModules.find(Path[0].first);
1652 if (Known != KnownModules.end()) {
1653 // Retrieve the cached top-level module.
1654 Module = Known->second;
1655 } else if (ModuleName == getLangOpts().CurrentModule) {
1656 // This is the module we're building.
1657 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1658 /// FIXME: perhaps we should (a) look for a module using the module name
1659 // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1660 //if (Module == nullptr) {
1661 // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1663 // ModuleBuildFailed = true;
1664 // return ModuleLoadResult();
1666 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1668 // Search for a module with the given name.
1669 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1670 HeaderSearchOptions &HSOpts =
1671 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1673 std::string ModuleFileName;
1675 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1676 } Source = ModuleNotFound;
1678 // Check to see if the module has been built as part of this compilation
1679 // via a module build pragma.
1680 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1681 if (BuiltModuleIt != BuiltModules.end()) {
1682 ModuleFileName = BuiltModuleIt->second;
1683 Source = ModuleBuildPragma;
1686 // Try to load the module from the prebuilt module path.
1687 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1688 !HSOpts.PrebuiltModulePaths.empty())) {
1690 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1691 if (!ModuleFileName.empty())
1692 Source = PrebuiltModulePath;
1695 // Try to load the module from the module cache.
1696 if (Source == ModuleNotFound && Module) {
1697 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1698 Source = ModuleCache;
1701 if (Source == ModuleNotFound) {
1702 // We can't find a module, error out here.
1703 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1704 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1705 ModuleBuildFailed = true;
1706 return ModuleLoadResult();
1709 if (ModuleFileName.empty()) {
1710 if (Module && Module->HasIncompatibleModuleFile) {
1711 // We tried and failed to load a module file for this module. Fall
1712 // back to textual inclusion for its headers.
1713 return ModuleLoadResult::ConfigMismatch;
1716 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1718 ModuleBuildFailed = true;
1719 return ModuleLoadResult();
1722 // If we don't already have an ASTReader, create one now.
1724 createModuleManager();
1727 if (FrontendTimerGroup)
1728 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1729 *FrontendTimerGroup);
1730 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1732 // Try to load the module file. If we are not trying to load from the
1733 // module cache, we don't know how to rebuild modules.
1734 unsigned ARRFlags = Source == ModuleCache ?
1735 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing :
1736 ASTReader::ARR_ConfigurationMismatch;
1737 switch (ModuleManager->ReadAST(ModuleFileName,
1738 Source == PrebuiltModulePath
1739 ? serialization::MK_PrebuiltModule
1740 : Source == ModuleBuildPragma
1741 ? serialization::MK_ExplicitModule
1742 : serialization::MK_ImplicitModule,
1743 ImportLoc, ARRFlags)) {
1744 case ASTReader::Success: {
1745 if (Source != ModuleCache && !Module) {
1746 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1747 if (!Module || !Module->getASTFile() ||
1748 FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1749 // Error out if Module does not refer to the file in the prebuilt
1751 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1753 ModuleBuildFailed = true;
1754 KnownModules[Path[0].first] = nullptr;
1755 return ModuleLoadResult();
1761 case ASTReader::OutOfDate:
1762 case ASTReader::Missing: {
1763 if (Source != ModuleCache) {
1764 // We don't know the desired configuration for this module and don't
1765 // necessarily even have a module map. Since ReadAST already produces
1766 // diagnostics for these two cases, we simply error out here.
1767 ModuleBuildFailed = true;
1768 KnownModules[Path[0].first] = nullptr;
1769 return ModuleLoadResult();
1772 // The module file is missing or out-of-date. Build it.
1773 assert(Module && "missing module file");
1774 // Check whether there is a cycle in the module graph.
1775 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1776 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1777 for (; Pos != PosEnd; ++Pos) {
1778 if (Pos->first == ModuleName)
1782 if (Pos != PosEnd) {
1783 SmallString<256> CyclePath;
1784 for (; Pos != PosEnd; ++Pos) {
1785 CyclePath += Pos->first;
1786 CyclePath += " -> ";
1788 CyclePath += ModuleName;
1790 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1791 << ModuleName << CyclePath;
1792 return ModuleLoadResult();
1795 // Check whether we have already attempted to build this module (but
1797 if (getPreprocessorOpts().FailedModules &&
1798 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1799 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1801 << SourceRange(ImportLoc, ModuleNameLoc);
1802 ModuleBuildFailed = true;
1803 return ModuleLoadResult();
1806 // Try to compile and then load the module.
1807 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1809 assert(getDiagnostics().hasErrorOccurred() &&
1810 "undiagnosed error in compileAndLoadModule");
1811 if (getPreprocessorOpts().FailedModules)
1812 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1813 KnownModules[Path[0].first] = nullptr;
1814 ModuleBuildFailed = true;
1815 return ModuleLoadResult();
1818 // Okay, we've rebuilt and now loaded the module.
1822 case ASTReader::ConfigurationMismatch:
1823 if (Source == PrebuiltModulePath)
1824 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1825 // produce a warning here!
1826 getDiagnostics().Report(SourceLocation(),
1827 diag::warn_module_config_mismatch)
1829 // Fall through to error out.
1831 case ASTReader::VersionMismatch:
1832 case ASTReader::HadErrors:
1833 ModuleLoader::HadFatalFailure = true;
1834 // FIXME: The ASTReader will already have complained, but can we shoehorn
1835 // that diagnostic information into a more useful form?
1836 KnownModules[Path[0].first] = nullptr;
1837 return ModuleLoadResult();
1839 case ASTReader::Failure:
1840 ModuleLoader::HadFatalFailure = true;
1841 // Already complained, but note now that we failed.
1842 KnownModules[Path[0].first] = nullptr;
1843 ModuleBuildFailed = true;
1844 return ModuleLoadResult();
1847 // Cache the result of this top-level module lookup for later.
1848 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1851 // If we never found the module, fail.
1853 return ModuleLoadResult();
1855 // Verify that the rest of the module path actually corresponds to
1857 bool MapPrivateSubModToTopLevel = false;
1858 if (!getLangOpts().ModulesTS && Path.size() > 1) {
1859 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1860 StringRef Name = Path[I].first->getName();
1861 clang::Module *Sub = Module->findSubmodule(Name);
1864 // Attempt to perform typo correction to find a module name that works.
1865 SmallVector<StringRef, 2> Best;
1866 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1868 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1869 JEnd = Module->submodule_end();
1871 unsigned ED = Name.edit_distance((*J)->Name,
1872 /*AllowReplacements=*/true,
1874 if (ED <= BestEditDistance) {
1875 if (ED < BestEditDistance) {
1877 BestEditDistance = ED;
1880 Best.push_back((*J)->Name);
1884 // If there was a clear winner, user it.
1885 if (Best.size() == 1) {
1886 getDiagnostics().Report(Path[I].second,
1887 diag::err_no_submodule_suggest)
1888 << Path[I].first << Module->getFullModuleName() << Best[0]
1889 << SourceRange(Path[0].second, Path[I-1].second)
1890 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1893 Sub = Module->findSubmodule(Best[0]);
1897 // If the user is requesting Foo.Private and it doesn't exist, try to
1898 // match Foo_Private and emit a warning asking for the user to write
1899 // @import Foo_Private instead. FIXME: remove this when existing clients
1900 // migrate off of Foo.Private syntax.
1901 if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1902 Module == Module->getTopLevelModule()) {
1903 SmallString<128> PrivateModule(Module->Name);
1904 PrivateModule.append("_Private");
1906 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
1907 auto &II = PP->getIdentifierTable().get(
1908 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1909 PrivPath.push_back(std::make_pair(&II, Path[0].second));
1911 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule))
1913 loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1915 MapPrivateSubModToTopLevel = true;
1916 if (!getDiagnostics().isIgnored(
1917 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1918 getDiagnostics().Report(Path[I].second,
1919 diag::warn_no_priv_submodule_use_toplevel)
1920 << Path[I].first << Module->getFullModuleName() << PrivateModule
1921 << SourceRange(Path[0].second, Path[I].second)
1922 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1924 getDiagnostics().Report(Sub->DefinitionLoc,
1925 diag::note_private_top_level_defined);
1931 // No submodule by this name. Complain, and don't look for further
1933 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1934 << Path[I].first << Module->getFullModuleName()
1935 << SourceRange(Path[0].second, Path[I-1].second);
1943 // Make the named module visible, if it's not already part of the module
1945 if (ModuleName != getLangOpts().CurrentModule) {
1946 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1947 // We have an umbrella header or directory that doesn't actually include
1948 // all of the headers within the directory it covers. Complain about
1949 // this missing submodule and recover by forgetting that we ever saw
1951 // FIXME: Should we detect this at module load time? It seems fairly
1952 // expensive (and rare).
1953 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1954 << Module->getFullModuleName()
1955 << SourceRange(Path.front().second, Path.back().second);
1957 return ModuleLoadResult::MissingExpected;
1960 // Check whether this module is available.
1961 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1962 getDiagnostics(), Module)) {
1963 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1964 << SourceRange(Path.front().second, Path.back().second);
1965 LastModuleImportLoc = ImportLoc;
1966 LastModuleImportResult = ModuleLoadResult();
1967 return ModuleLoadResult();
1970 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1973 // Check for any configuration macros that have changed.
1974 clang::Module *TopModule = Module->getTopLevelModule();
1975 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1976 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1980 LastModuleImportLoc = ImportLoc;
1981 LastModuleImportResult = ModuleLoadResult(Module);
1982 return LastModuleImportResult;
1985 void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1986 StringRef ModuleName,
1988 // Avoid creating filenames with special characters.
1989 SmallString<128> CleanModuleName(ModuleName);
1990 for (auto &C : CleanModuleName)
1991 if (!isAlphanumeric(C))
1994 // FIXME: Using a randomized filename here means that our intermediate .pcm
1995 // output is nondeterministic (as .pcm files refer to each other by name).
1996 // Can this affect the output in any way?
1997 SmallString<128> ModuleFileName;
1998 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1999 CleanModuleName, "pcm", ModuleFileName)) {
2000 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2001 << ModuleFileName << EC.message();
2004 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2006 FrontendInputFile Input(
2008 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2009 InputKind::ModuleMap, /*Preprocessed*/true));
2011 std::string NullTerminatedSource(Source.str());
2013 auto PreBuildStep = [&](CompilerInstance &Other) {
2014 // Create a virtual file containing our desired source.
2015 // FIXME: We shouldn't need to do this.
2016 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2017 ModuleMapFileName, NullTerminatedSource.size(), 0);
2018 Other.getSourceManager().overrideFileContents(
2020 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2022 Other.BuiltModules = std::move(BuiltModules);
2023 Other.DeleteBuiltModules = false;
2026 auto PostBuildStep = [this](CompilerInstance &Other) {
2027 BuiltModules = std::move(Other.BuiltModules);
2030 // Build the module, inheriting any modules that we've built locally.
2031 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2032 ModuleFileName, PreBuildStep, PostBuildStep)) {
2033 BuiltModules[ModuleName] = ModuleFileName.str();
2034 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2038 void CompilerInstance::makeModuleVisible(Module *Mod,
2039 Module::NameVisibilityKind Visibility,
2040 SourceLocation ImportLoc) {
2042 createModuleManager();
2046 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2049 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2050 SourceLocation TriggerLoc) {
2051 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2054 createModuleManager();
2055 // Can't do anything if we don't have the module manager.
2058 // Get an existing global index. This loads it if not already
2060 ModuleManager->loadGlobalIndex();
2061 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2062 // If the global index doesn't exist, create it.
2063 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2064 hasPreprocessor()) {
2065 llvm::sys::fs::create_directories(
2066 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2067 GlobalModuleIndex::writeIndex(
2068 getFileManager(), getPCHContainerReader(),
2069 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2070 ModuleManager->resetForReload();
2071 ModuleManager->loadGlobalIndex();
2072 GlobalIndex = ModuleManager->getGlobalIndex();
2074 // For finding modules needing to be imported for fixit messages,
2075 // we need to make the global index cover all modules, so we do that here.
2076 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2077 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2078 bool RecreateIndex = false;
2079 for (ModuleMap::module_iterator I = MMap.module_begin(),
2080 E = MMap.module_end(); I != E; ++I) {
2081 Module *TheModule = I->second;
2082 const FileEntry *Entry = TheModule->getASTFile();
2084 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2085 Path.push_back(std::make_pair(
2086 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2087 std::reverse(Path.begin(), Path.end());
2088 // Load a module as hidden. This also adds it to the global index.
2089 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2090 RecreateIndex = true;
2093 if (RecreateIndex) {
2094 GlobalModuleIndex::writeIndex(
2095 getFileManager(), getPCHContainerReader(),
2096 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2097 ModuleManager->resetForReload();
2098 ModuleManager->loadGlobalIndex();
2099 GlobalIndex = ModuleManager->getGlobalIndex();
2101 HaveFullGlobalModuleIndex = true;
2106 // Check global module index for missing imports.
2108 CompilerInstance::lookupMissingImports(StringRef Name,
2109 SourceLocation TriggerLoc) {
2110 // Look for the symbol in non-imported modules, but only if an error
2111 // actually occurred.
2112 if (!buildingModule()) {
2113 // Load global module index, or retrieve a previously loaded one.
2114 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2117 // Only if we have a global index.
2119 GlobalModuleIndex::HitSet FoundModules;
2121 // Find the modules that reference the identifier.
2122 // Note that this only finds top-level modules.
2123 // We'll let diagnoseTypo find the actual declaration module.
2124 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2131 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
2133 void CompilerInstance::setExternalSemaSource(
2134 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2135 ExternalSemaSrc = std::move(ESS);