Bug Summary

File:tools/clang/lib/Frontend/CompilerInstance.cpp
Warning:line 875, column 14
Called C++ object pointer is null

Annotated Source Code

1//===--- CompilerInstance.cpp ---------------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
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"
51#include <sys/stat.h>
52#include <system_error>
53#include <time.h>
54#include <utility>
55
56using namespace clang;
57
58CompilerInstance::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.
66 if (SharedPCMCache)
67 getPCMCache().finalizeCurrentBuffers();
68}
69
70CompilerInstance::~CompilerInstance() {
71 assert(OutputFiles.empty() && "Still output files in flight?")((OutputFiles.empty() && "Still output files in flight?"
) ? static_cast<void> (0) : __assert_fail ("OutputFiles.empty() && \"Still output files in flight?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 71, __PRETTY_FUNCTION__))
;
72}
73
74void CompilerInstance::setInvocation(
75 std::shared_ptr<CompilerInvocation> Value) {
76 Invocation = std::move(Value);
77}
78
79bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
80 return (BuildGlobalModuleIndex ||
81 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
82 getFrontendOpts().GenerateGlobalModuleIndex)) &&
83 !ModuleBuildFailed;
84}
85
86void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
87 Diagnostics = Value;
88}
89
90void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
91void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
92
93void CompilerInstance::setFileManager(FileManager *Value) {
94 FileMgr = Value;
95 if (Value)
96 VirtualFileSystem = Value->getVirtualFileSystem();
97 else
98 VirtualFileSystem.reset();
99}
100
101void CompilerInstance::setSourceManager(SourceManager *Value) {
102 SourceMgr = Value;
103}
104
105void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
106 PP = std::move(Value);
107}
108
109void CompilerInstance::setASTContext(ASTContext *Value) {
110 Context = Value;
111
112 if (Context && Consumer)
113 getASTConsumer().Initialize(getASTContext());
114}
115
116void CompilerInstance::setSema(Sema *S) {
117 TheSema.reset(S);
118}
119
120void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
121 Consumer = std::move(Value);
122
123 if (Context && Consumer)
124 getASTConsumer().Initialize(getASTContext());
125}
126
127void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
128 CompletionConsumer.reset(Value);
129}
130
131std::unique_ptr<Sema> CompilerInstance::takeSema() {
132 return std::move(TheSema);
133}
134
135IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
136 return ModuleManager;
137}
138void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
139 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&((PCMCache.get() == &Reader->getModuleManager().getPCMCache
() && "Expected ASTReader to use the same PCM cache")
? static_cast<void> (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 140, __PRETTY_FUNCTION__))
140 "Expected ASTReader to use the same PCM cache")((PCMCache.get() == &Reader->getModuleManager().getPCMCache
() && "Expected ASTReader to use the same PCM cache")
? static_cast<void> (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 140, __PRETTY_FUNCTION__))
;
141 ModuleManager = std::move(Reader);
142}
143
144std::shared_ptr<ModuleDependencyCollector>
145CompilerInstance::getModuleDepCollector() const {
146 return ModuleDepCollector;
147}
148
149void CompilerInstance::setModuleDepCollector(
150 std::shared_ptr<ModuleDependencyCollector> Collector) {
151 ModuleDepCollector = std::move(Collector);
152}
153
154static 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)
159 MDC->addFile(Name);
160}
161
162static void collectIncludePCH(CompilerInstance &CI,
163 std::shared_ptr<ModuleDependencyCollector> MDC) {
164 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
165 if (PPOpts.ImplicitPCHInclude.empty())
166 return;
167
168 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
169 FileManager &FileMgr = CI.getFileManager();
170 const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
171 if (!PCHDir) {
172 MDC->addFile(PCHInclude);
173 return;
174 }
175
176 std::error_code EC;
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());
191 }
192}
193
194static void collectVFSEntries(CompilerInstance &CI,
195 std::shared_ptr<ModuleDependencyCollector> MDC) {
196 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
197 return;
198
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);
204 if (!Buffer)
205 return;
206 vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr,
207 VFSFile, VFSEntries);
208 }
209
210 for (auto &E : VFSEntries)
211 MDC->addFile(E.VPath, E.RPath);
212}
213
214// Diagnostics
215static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
216 const CodeGenOptions *CodeGenOpts,
217 DiagnosticsEngine &Diags) {
218 std::error_code EC;
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);
226 if (EC) {
227 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
228 << DiagOpts->DiagnosticLogFile << EC.message();
229 } else {
230 FileOS->SetUnbuffered();
231 OS = FileOS.get();
232 StreamOwner = std::move(FileOS);
233 }
234 }
235
236 // Chain in the diagnostic client which will log the diagnostics.
237 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
238 std::move(StreamOwner));
239 if (CodeGenOpts)
240 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
241 assert(Diags.ownsClient())((Diags.ownsClient()) ? static_cast<void> (0) : __assert_fail
("Diags.ownsClient()", "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 241, __PRETTY_FUNCTION__))
;
242 Diags.setClient(
243 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
244}
245
246static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
247 DiagnosticsEngine &Diags,
248 StringRef OutputFile) {
249 auto SerializedConsumer =
250 clang::serialized_diags::create(OutputFile, DiagOpts);
251
252 if (Diags.ownsClient()) {
253 Diags.setClient(new ChainedDiagnosticConsumer(
254 Diags.takeClient(), std::move(SerializedConsumer)));
255 } else {
256 Diags.setClient(new ChainedDiagnosticConsumer(
257 Diags.getClient(), std::move(SerializedConsumer)));
258 }
259}
260
261void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
262 bool ShouldOwnClient) {
263 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
264 ShouldOwnClient, &getCodeGenOpts());
265}
266
267IntrusiveRefCntPtr<DiagnosticsEngine>
268CompilerInstance::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));
275
276 // Create the diagnostic client for reporting errors or for
277 // implementing -verify.
278 if (Client) {
279 Diags->setClient(Client, ShouldOwnClient);
280 } else
281 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
282
283 // Chain in -verify checker, if requested.
284 if (Opts->VerifyDiagnostics)
285 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
286
287 // Chain in -diagnostic-log-file dumper, if requested.
288 if (!Opts->DiagnosticLogFile.empty())
289 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
290
291 if (!Opts->DiagnosticSerializationFile.empty())
292 SetupSerializedDiagnostics(Opts, *Diags,
293 Opts->DiagnosticSerializationFile);
294
295 // Configure our handling of diagnostics.
296 ProcessWarningOptions(*Diags, *Opts);
297
298 return Diags;
299}
300
301// File Manager
302
303FileManager *CompilerInstance::createFileManager() {
304 if (!hasVirtualFileSystem()) {
305 if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
306 createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()))
307 setVirtualFileSystem(VFS);
308 else
309 return nullptr;
310 }
311 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
312 return FileMgr.get();
313}
314
315// Source Manager
316
317void CompilerInstance::createSourceManager(FileManager &FileMgr) {
318 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
319}
320
321// Initialize the remapping of files to alternative contents, e.g.,
322// those specified through other files.
323static 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);
332 if (!FromFile) {
333 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
334 if (!InitOpts.RetainRemappedFileBuffers)
335 delete RB.second;
336 continue;
337 }
338
339 // Override the contents of the "from" file with the contents of
340 // the "to" file.
341 SourceMgr.overrideFileContents(FromFile, RB.second,
342 InitOpts.RetainRemappedFileBuffers);
343 }
344
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);
349 if (!ToFile) {
350 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
351 continue;
352 }
353
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);
357 if (!FromFile) {
358 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
359 continue;
360 }
361
362 // Override the contents of the "from" file with the contents of
363 // the "to" file.
364 SourceMgr.overrideFileContents(FromFile, ToFile);
365 }
366
367 SourceMgr.setOverridenFilesKeepOriginalName(
368 InitOpts.RemappedFilesKeepOriginalName);
369}
370
371// Preprocessor
372
373void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
374 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
375
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());
380
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());
391
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.
395 if (PTHMgr) {
396 PTHMgr->setPreprocessor(&*PP);
397 PP->setPTHManager(PTHMgr);
398 }
399
400 if (PPOpts.DetailedRecord)
401 PP->createPreprocessingRecord();
402
403 // Apply remappings to the source manager.
404 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
405 PP->getFileManager(), PPOpts);
406
407 // Predefine macros and configure the preprocessor.
408 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
409 getFrontendOpts());
410
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();
418
419 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
420 PP->getLangOpts(), *HeaderSearchTriple);
421
422 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
423
424 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
425 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
426
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);
435
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);
441 }
442
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);
450 }
451
452 for (auto &Listener : DependencyCollectors)
453 Listener->attachToPreprocessor(*PP);
454
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 == "-")
461 OutputPath = "";
462 AttachHeaderIncludeGen(*PP, DepOpts,
463 /*ShowAllHeaders=*/true, OutputPath,
464 /*ShowDepth=*/false);
465 }
466
467 if (DepOpts.PrintShowIncludes) {
468 AttachHeaderIncludeGen(*PP, DepOpts,
469 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
470 /*ShowDepth=*/true, /*MSStyle=*/true);
471 }
472}
473
474std::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();
482}
483
484// ASTContext
485
486void 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);
493}
494
495// ExternalASTSource
496
497void 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);
511}
512
513IntrusiveRefCntPtr<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();
523
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));
529
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());
533
534 Reader->setDeserializationListener(
535 static_cast<ASTDeserializationListener *>(DeserializationListener),
536 /*TakeOwnership=*/OwnDeserializationListener);
537
538 if (DependencyFile)
539 DependencyFile->AttachToASTReader(*Reader);
540 for (auto &Listener : DependencyCollectors)
541 Listener->attachToASTReader(*Reader);
542
543 switch (Reader->ReadAST(Path,
544 Preamble ? serialization::MK_Preamble
545 : serialization::MK_PCH,
546 SourceLocation(),
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());
552 return Reader;
553
554 case ASTReader::Failure:
555 // Unrecoverable failure: don't even try to process the input file.
556 break;
557
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.
564 break;
565 }
566
567 Context.setExternalSource(nullptr);
568 return nullptr;
569}
570
571// Code Completion
572
573static bool EnableCodeCompletion(Preprocessor &PP,
574 StringRef Filename,
575 unsigned Line,
576 unsigned Column) {
577 // Tell the source manager to chop off the given file at a specific
578 // line and column.
579 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
580 if (!Entry) {
581 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
582 << Filename;
583 return true;
584 }
585
586 // Truncate the named file at the given line/column.
587 PP.SetCodeCompletionPoint(Entry, Line, Column);
588 return false;
589}
590
591void 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,
598 llvm::outs()));
599 if (!CompletionConsumer)
600 return;
601 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
602 Loc.Line, Loc.Column)) {
603 setCodeCompletionConsumer(nullptr);
604 return;
605 }
606
607 if (CompletionConsumer->isOutputBinary() &&
608 llvm::sys::ChangeStdoutToBinary()) {
609 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
610 setCodeCompletionConsumer(nullptr);
611 }
612}
613
614void CompilerInstance::createFrontendTimer() {
615 FrontendTimerGroup.reset(
616 new llvm::TimerGroup("frontend", "Clang front-end time report"));
617 FrontendTimer.reset(
618 new llvm::Timer("frontend", "Clang front-end timer",
619 *FrontendTimerGroup));
620}
621
622CodeCompleteConsumer *
623CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
624 StringRef Filename,
625 unsigned Line,
626 unsigned Column,
627 const CodeCompleteOptions &Opts,
628 raw_ostream &OS) {
629 if (EnableCodeCompletion(PP, Filename, Line, Column))
630 return nullptr;
631
632 // Set up the creation routine for code-completion.
633 return new PrintingCodeCompleteConsumer(Opts, OS);
634}
635
636void 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);
644 }
645}
646
647// Output Files
648
649void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
650 OutputFiles.push_back(std::move(OutFile));
651}
652
653void CompilerInstance::clearOutputFiles(bool EraseFiles) {
654 for (OutputFile &OF : OutputFiles) {
655 if (!OF.TempFilename.empty()) {
656 if (EraseFiles) {
657 llvm::sys::fs::remove(OF.TempFilename);
658 } else {
659 SmallString<128> NewOutFile(OF.Filename);
660
661 // If '-working-directory' was passed, the output filename should be
662 // relative to that.
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();
668
669 llvm::sys::fs::remove(OF.TempFilename);
670 }
671 }
672 } else if (!OF.Filename.empty() && EraseFiles)
673 llvm::sys::fs::remove(OF.Filename);
674 }
675 OutputFiles.clear();
676 if (DeleteBuiltModules) {
677 for (auto &Module : BuiltModules)
678 llvm::sys::fs::remove(Module.second);
679 BuiltModules.clear();
680 }
681 NonSeekStream.reset();
682}
683
684std::unique_ptr<raw_pwrite_stream>
685CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
686 StringRef Extension) {
687 return createOutputFile(getFrontendOpts().OutputFile, Binary,
688 /*RemoveFileOnSignal=*/true, InFile, Extension,
689 /*UseTemporary=*/true);
690}
691
692std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
693 return llvm::make_unique<llvm::raw_null_ostream>();
694}
695
696std::unique_ptr<raw_pwrite_stream>
697CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
698 bool RemoveFileOnSignal, StringRef InFile,
699 StringRef Extension, bool UseTemporary,
700 bool CreateMissingDirectories) {
701 std::string OutputPathName, TempPathName;
702 std::error_code EC;
703 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
704 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
705 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
706 if (!OS) {
707 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
708 << EC.message();
709 return nullptr;
710 }
711
712 // Add the output file -- but don't try to remove "-", since this means we are
713 // using stdin.
714 addOutputFile(
715 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
716
717 return OS;
718}
719
720std::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) &&(((!CreateMissingDirectories || UseTemporary) && "CreateMissingDirectories is only allowed when using temporary files"
) ? static_cast<void> (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 726, __PRETTY_FUNCTION__))
726 "CreateMissingDirectories is only allowed when using temporary files")(((!CreateMissingDirectories || UseTemporary) && "CreateMissingDirectories is only allowed when using temporary files"
) ? static_cast<void> (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 726, __PRETTY_FUNCTION__))
;
727
728 std::string OutFile, TempFile;
729 if (!OutputPath.empty()) {
730 OutFile = OutputPath;
731 } else if (InFile == "-") {
732 OutFile = "-";
733 } else if (!Extension.empty()) {
734 SmallString<128> Path(InFile);
735 llvm::sys::path::replace_extension(Path, Extension);
736 OutFile = Path.str();
737 } else {
738 OutFile = "-";
739 }
740
741 std::unique_ptr<llvm::raw_fd_ostream> OS;
742 std::string OSFile;
743
744 if (UseTemporary) {
745 if (OutFile == "-")
746 UseTemporary = false;
747 else {
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);
754 return nullptr;
755 }
756
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;
761 }
762 }
763 }
764
765 if (UseTemporary) {
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;
775 TempPath += ".tmp";
776 int fd;
777 std::error_code EC =
778 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
779
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);
784 if (!EC) {
785 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
786 }
787 }
788
789 if (!EC) {
790 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
791 OSFile = TempFile = TempPath.str();
792 }
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.
796 }
797
798 if (!OS) {
799 OSFile = OutFile;
800 OS.reset(new llvm::raw_fd_ostream(
801 OSFile, Error,
802 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
803 if (Error)
804 return nullptr;
805 }
806
807 // Make sure the out stream file gets removed if we crash.
808 if (RemoveFileOnSignal)
809 llvm::sys::RemoveFileOnSignal(OSFile);
810
811 if (ResultPathName)
812 *ResultPathName = OutFile;
813 if (TempPathName)
814 *TempPathName = TempFile;
815
816 if (!Binary || OS->supportsSeeking())
817 return std::move(OS);
818
819 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
820 assert(!NonSeekStream)((!NonSeekStream) ? static_cast<void> (0) : __assert_fail
("!NonSeekStream", "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 820, __PRETTY_FUNCTION__))
;
821 NonSeekStream = std::move(OS);
822 return std::move(B);
823}
824
825// Initialization Utilities
826
827bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
828 return InitializeSourceManager(
3
Calling 'CompilerInstance::InitializeSourceManager'
829 Input, getDiagnostics(), getFileManager(), getSourceManager(),
830 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
1
'?' condition is false
2
Passing null pointer value via 5th parameter 'HS'
831 getDependencyOutputOpts(), getFrontendOpts());
832}
833
834// static
835bool 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
4
Assuming the condition is false
5
'?' condition is false
841 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
842 : SrcMgr::C_User_ModuleMap
843 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
6
Assuming the condition is false
7
'?' condition is false
844
845 if (Input.isBuffer()) {
8
Taking false branch
846 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
847 Input.getBuffer(), Kind));
848 assert(SourceMgr.getMainFileID().isValid() &&((SourceMgr.getMainFileID().isValid() && "Couldn't establish MainFileID!"
) ? static_cast<void> (0) : __assert_fail ("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 849, __PRETTY_FUNCTION__))
849 "Couldn't establish MainFileID!")((SourceMgr.getMainFileID().isValid() && "Couldn't establish MainFileID!"
) ? static_cast<void> (0) : __assert_fail ("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 849, __PRETTY_FUNCTION__))
;
850 return true;
851 }
852
853 StringRef InputFile = Input.getFile();
854
855 // Figure out where to get and map in the main file.
856 if (InputFile != "-") {
9
Taking true branch
857 const FileEntry *File;
858 if (Opts.FindPchSource.empty()) {
10
Assuming the condition is false
11
Taking false branch
859 File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
860 } else {
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);
867 if (!FindFile) {
12
Assuming 'FindFile' is non-null
13
Taking false branch
868 Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
869 return false;
870 }
871 const DirectoryLookup *UnusedCurDir;
872 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
873 Includers;
874 Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
875 File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
14
Called C++ object pointer is null
876 /*FromDir=*/nullptr,
877 /*CurDir=*/UnusedCurDir, Includers,
878 /*SearchPath=*/nullptr,
879 /*RelativePath=*/nullptr,
880 /*RequestingModule=*/nullptr,
881 /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
882 /*SkipCache=*/true);
883 // Also add the header to /showIncludes output.
884 if (File)
885 DepOpts.ShowIncludesPretendHeader = File->getName();
886 }
887 if (!File) {
888 Diags.Report(diag::err_fe_error_reading) << InputFile;
889 return false;
890 }
891
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
896 // STDIN.
897 if (File->isNamedPipe()) {
898 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
899 if (MB) {
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));
903 } else {
904 Diags.Report(diag::err_cannot_open_file) << InputFile
905 << MB.getError().message();
906 return false;
907 }
908 }
909
910 SourceMgr.setMainFileID(
911 SourceMgr.createFileID(File, SourceLocation(), Kind));
912 } else {
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();
917 return false;
918 }
919 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
920
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));
926 }
927
928 assert(SourceMgr.getMainFileID().isValid() &&((SourceMgr.getMainFileID().isValid() && "Couldn't establish MainFileID!"
) ? static_cast<void> (0) : __assert_fail ("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 929, __PRETTY_FUNCTION__))
929 "Couldn't establish MainFileID!")((SourceMgr.getMainFileID().isValid() && "Couldn't establish MainFileID!"
) ? static_cast<void> (0) : __assert_fail ("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 929, __PRETTY_FUNCTION__))
;
930 return true;
931}
932
933// High-Level Operations
934
935bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
936 assert(hasDiagnostics() && "Diagnostics engine is not initialized!")((hasDiagnostics() && "Diagnostics engine is not initialized!"
) ? static_cast<void> (0) : __assert_fail ("hasDiagnostics() && \"Diagnostics engine is not initialized!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 936, __PRETTY_FUNCTION__))
;
937 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!")((!getFrontendOpts().ShowHelp && "Client must handle '-help'!"
) ? static_cast<void> (0) : __assert_fail ("!getFrontendOpts().ShowHelp && \"Client must handle '-help'!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 937, __PRETTY_FUNCTION__))
;
938 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!")((!getFrontendOpts().ShowVersion && "Client must handle '-version'!"
) ? static_cast<void> (0) : __assert_fail ("!getFrontendOpts().ShowVersion && \"Client must handle '-version'!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 938, __PRETTY_FUNCTION__))
;
939
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();
943
944 // Create the target instance.
945 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
946 getInvocation().TargetOpts));
947 if (!hasTarget())
948 return false;
949
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));
957 }
958
959 // Inform the target of the language options.
960 //
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());
964
965 // Adjust target options based on codegen options.
966 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
967
968 // rewriter project will change target built-in bool type from its default.
969 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
970 getTarget().noSignedCharForObjCBool();
971
972 // Validate/process some options.
973 if (getHeaderSearchOpts().Verbose)
974 OS << "clang -cc1 version " CLANG_VERSION_STRING"6.0.0"
975 << " based upon " << BACKEND_PACKAGE_STRING"LLVM 6.0.0"
976 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
977
978 if (getFrontendOpts().ShowTimers)
979 createFrontendTimer();
980
981 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
982 llvm::EnableStatistics(false);
983
984 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
985 // Reset the ID tables if we are reusing the SourceManager and parsing
986 // regular files.
987 if (hasSourceManager() && !Act.isModelParsingAction())
988 getSourceManager().clearIDTables();
989
990 if (Act.BeginSourceFile(*this, FIF)) {
991 Act.Execute();
992 Act.EndSourceFile();
993 }
994 }
995
996 // Notify the diagnostic client that all files were processed.
997 getDiagnostics().getClient()->finish();
998
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();
1004
1005 if (NumWarnings)
1006 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1007 if (NumWarnings && NumErrors)
1008 OS << " and ";
1009 if (NumErrors)
1010 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1011 if (NumWarnings || NumErrors) {
1012 OS << " generated";
1013 if (getLangOpts().CUDA) {
1014 if (!getLangOpts().CUDAIsDevice) {
1015 OS << " when compiling for host";
1016 } else {
1017 OS << " when compiling for " << getTargetOpts().CPU;
1018 }
1019 }
1020 OS << ".\n";
1021 }
1022 }
1023
1024 if (getFrontendOpts().ShowStats) {
1025 if (hasFileManager()) {
1026 getFileManager().PrintStats();
1027 OS << '\n';
1028 }
1029 llvm::PrintStatistics(OS);
1030 }
1031 StringRef StatsFile = getFrontendOpts().StatsFile;
1032 if (!StatsFile.empty()) {
1033 std::error_code EC;
1034 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1035 llvm::sys::fs::F_Text);
1036 if (EC) {
1037 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1038 << StatsFile << EC.message();
1039 } else {
1040 llvm::PrintStatisticsJSON(*StatS);
1041 }
1042 }
1043
1044 return !getDiagnostics().getClient()->getNumErrors();
1045}
1046
1047/// \brief Determine the appropriate source input kind based on language
1048/// options.
1049static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
1050 if (LangOpts.OpenCL)
1051 return InputKind::OpenCL;
1052 if (LangOpts.CUDA)
1053 return InputKind::CUDA;
1054 if (LangOpts.ObjC1)
1055 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1056 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1057}
1058
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.
1062static bool
1063compileModuleImpl(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.
1071 auto Invocation =
1072 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1073
1074 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1075
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();
1080
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;
1090 }),
1091 PPOpts.Macros.end());
1092
1093 // Note the name of the module we're building.
1094 Invocation->getLangOpts()->CurrentModule = ModuleName;
1095
1096 // Make sure that the failed-module structure has been allocated in
1097 // the importing instance, and propagate the pointer to the newly-created
1098 // instance.
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;
1105
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
1108 // header.
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};
1118
1119 // Don't free the remapped file buffers; they are owned by our caller.
1120 PPOpts.RetainRemappedFileBuffers = true;
1121
1122 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1123 assert(ImportingInstance.getInvocation().getModuleHash() ==((ImportingInstance.getInvocation().getModuleHash() == Invocation
->getModuleHash() && "Module hash mismatch!") ? static_cast
<void> (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1124, __PRETTY_FUNCTION__))
1124 Invocation->getModuleHash() && "Module hash mismatch!")((ImportingInstance.getInvocation().getModuleHash() == Invocation
->getModuleHash() && "Module hash mismatch!") ? static_cast
<void> (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1124, __PRETTY_FUNCTION__))
;
1125
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));
1134
1135 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1136 ImportingInstance.getDiagnosticClient()),
1137 /*ShouldOwnClient=*/true);
1138
1139 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1140
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()));
1150
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();
1156
1157 ImportingInstance.getDiagnostics().Report(ImportLoc,
1158 diag::remark_module_build)
1159 << ModuleName << ModuleFileName;
1160
1161 PreBuildStep(Instance);
1162
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(
1168 [&]() {
1169 GenerateModuleFromModuleMapAction Action;
1170 Instance.ExecuteAction(Action);
1171 },
1172 ThreadStackSize);
1173
1174 PostBuildStep(Instance);
1175
1176 ImportingInstance.getDiagnostics().Report(ImportLoc,
1177 diag::remark_module_build_done)
1178 << ModuleName;
1179
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);
1185
1186 return !Instance.getDiagnostics().hasErrorOccurred();
1187}
1188
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.
1192static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1193 SourceLocation ImportLoc,
1194 Module *Module,
1195 StringRef ModuleFileName) {
1196 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1197 InputKind::ModuleMap);
1198
1199 // Get or create the module map that we'll use to build this module.
1200 ModuleMap &ModMap
1201 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1202 bool Result;
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(),
1210 ModuleFileName);
1211 } else {
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");
1218
1219 std::string InferredModuleMapContent;
1220 llvm::raw_string_ostream OS(InferredModuleMapContent);
1221 Module->print(OS);
1222 OS.flush();
1223
1224 Result = compileModuleImpl(
1225 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1226 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1227 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1228 ModuleFileName,
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));
1236 });
1237 }
1238
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);
1243 }
1244
1245 return Result;
1246}
1247
1248static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1249 SourceLocation ImportLoc,
1250 SourceLocation ModuleNameLoc, Module *Module,
1251 StringRef ModuleFileName) {
1252 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1253
1254 auto diagnoseBuildFailure = [&] {
1255 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1256 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1257 };
1258
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);
1263
1264 while (1) {
1265 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1266 llvm::LockFileManager Locked(ModuleFileName);
1267 switch (Locked) {
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
1271 // related errors.
1272 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1273 << Module->Name << Locked.getErrorMessage();
1274 // Clear out any potential leftover.
1275 Locked.unsafeRemoveLockFile();
1276 // FALLTHROUGH
1277 case llvm::LockFileManager::LFS_Owned:
1278 // We're responsible for building the module ourselves.
1279 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1280 ModuleFileName)) {
1281 diagnoseBuildFailure();
1282 return false;
1283 }
1284 break;
1285
1286 case llvm::LockFileManager::LFS_Shared:
1287 // Someone else is responsible for building the module. Wait for them to
1288 // finish.
1289 switch (Locked.waitForUnlock()) {
1290 case llvm::LockFileManager::Res_Success:
1291 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1292 break;
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)
1300 << Module->Name;
1301 // Clear the lock file so that future invokations can make progress.
1302 Locked.unsafeRemoveLockFile();
1303 continue;
1304 }
1305 break;
1306 }
1307
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);
1313
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...
1319 continue;
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();
1326 }
1327 return ReadResult == ASTReader::Success;
1328 }
1329}
1330
1331/// \brief Diagnose differences between the current definition of the given
1332/// configuration macro and the definition provided on the command line.
1333static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1334 Module *Mod, SourceLocation ImportLoc) {
1335 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1336 SourceManager &SourceMgr = PP.getSourceManager();
1337
1338 // If this identifier has never had a macro definition, then it could
1339 // not have changed.
1340 if (!Id->hadMacroDefinition())
1341 return;
1342 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1343
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())
1350 continue;
1351 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1352 CmdLineDefinition = DMD->getMacroInfo();
1353 break;
1354 }
1355
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.
1361 // Complain.
1362 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1363 << true << ConfigMacro << Mod->getFullModuleName();
1364 auto LatestDef = LatestLocalMD->getDefinition();
1365 assert(LatestDef.isUndefined() &&((LatestDef.isUndefined() && "predefined macro went away with no #undef?"
) ? static_cast<void> (0) : __assert_fail ("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1366, __PRETTY_FUNCTION__))
1366 "predefined macro went away with no #undef?")((LatestDef.isUndefined() && "predefined macro went away with no #undef?"
) ? static_cast<void> (0) : __assert_fail ("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1366, __PRETTY_FUNCTION__))
;
1367 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1368 << true;
1369 return;
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)
1377 << false;
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)
1385 << false;
1386 }
1387}
1388
1389/// \brief Write a new timestamp file with the given path.
1390static void writeTimestampFile(StringRef TimestampFile) {
1391 std::error_code EC;
1392 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1393}
1394
1395/// \brief Prune the module cache of modules that haven't been accessed in
1396/// a long time.
1397static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1398 struct stat StatBuf;
1399 llvm::SmallString<128> TimestampFile;
1400 TimestampFile = HSOpts.ModuleCachePath;
1401 assert(!TimestampFile.empty())((!TimestampFile.empty()) ? static_cast<void> (0) : __assert_fail
("!TimestampFile.empty()", "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1401, __PRETTY_FUNCTION__))
;
1402 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1403
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(*__errno_location ()) == ENOENT2) {
1408 writeTimestampFile(TimestampFile);
1409 }
1410 return;
1411 }
1412
1413 // Check whether the time stamp is older than our pruning interval.
1414 // If not, do nothing.
1415 time_t TimeStampModTime = StatBuf.st_mtimest_mtim.tv_sec;
1416 time_t CurrentTime = time(nullptr);
1417 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1418 return;
1419
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);
1424
1425 // Walk the entire module cache, looking for unused module files and module
1426 // indices.
1427 std::error_code EC;
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()))
1434 continue;
1435
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")
1443 continue;
1444
1445 // Look at this file. If we can't stat it, there's nothing interesting
1446 // there.
1447 if (::stat(File->path().c_str(), &StatBuf))
1448 continue;
1449
1450 // If the file has been used recently enough, leave it there.
1451 time_t FileAccessTime = StatBuf.st_atimest_atim.tv_sec;
1452 if (CurrentTime - FileAccessTime <=
1453 time_t(HSOpts.ModuleCachePruneAfter)) {
1454 continue;
1455 }
1456
1457 // Remove the file.
1458 llvm::sys::fs::remove(File->path());
1459
1460 // Remove the timestamp file.
1461 std::string TimpestampFilename = File->path() + ".timestamp";
1462 llvm::sys::fs::remove(TimpestampFilename);
1463 }
1464
1465 // If we removed all of the files in the directory, remove the directory
1466 // itself.
1467 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1468 llvm::sys::fs::directory_iterator() && !EC)
1469 llvm::sys::fs::remove(Dir->path());
1470 }
1471}
1472
1473void CompilerInstance::createModuleManager() {
1474 if (!ModuleManager) {
1475 if (!hasASTContext())
1476 createASTContext();
1477
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());
1485 }
1486
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",
1493 "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());
1509 }
1510 getASTContext().setExternalSource(ModuleManager);
1511 if (hasSema())
1512 ModuleManager->InitializeSema(getSema());
1513 if (hasASTConsumer())
1514 ModuleManager->StartTranslationUnit(&getASTConsumer());
1515
1516 if (TheDependencyFileGenerator)
1517 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1518 for (auto &Listener : DependencyCollectors)
1519 Listener->attachToASTReader(*ModuleManager);
1520 }
1521}
1522
1523bool CompilerInstance::loadModuleFile(StringRef FileName) {
1524 llvm::Timer Timer;
1525 if (FrontendTimerGroup)
1526 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1527 *FrontendTimerGroup);
1528 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1529
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;
1536
1537 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1538
1539 void ReadModuleName(StringRef ModuleName) override {
1540 LoadedModules.push_back(
1541 CI.getPreprocessor().getIdentifierInfo(ModuleName));
1542 }
1543
1544 void registerAll() {
1545 for (auto *II : LoadedModules) {
1546 CI.KnownModules[II] = CI.getPreprocessor()
1547 .getHeaderSearchInfo()
1548 .getModuleMap()
1549 .findModule(II->getName());
1550 }
1551 LoadedModules.clear();
1552 }
1553
1554 void markAllUnavailable() {
1555 for (auto *II : LoadedModules) {
1556 if (Module *M = CI.getPreprocessor()
1557 .getHeaderSearchInfo()
1558 .getModuleMap()
1559 .findModule(II->getName())) {
1560 M->HasIncompatibleModuleFile = true;
1561
1562 // Mark module as available if the only reason it was unavailable
1563 // was missing headers.
1564 SmallVector<Module *, 2> Stack;
1565 Stack.push_back(M);
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());
1572 }
1573 }
1574 }
1575 LoadedModules.clear();
1576 }
1577 };
1578
1579 // If we don't already have an ASTReader, create one now.
1580 if (!ModuleManager)
1581 createModuleManager();
1582
1583 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1584 auto &ListenerRef = *Listener;
1585 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1586 std::move(Listener));
1587
1588 // Try to load the module file.
1589 switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1590 SourceLocation(),
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();
1596 return true;
1597
1598 case ASTReader::ConfigurationMismatch:
1599 // Ignore unusable module files.
1600 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1601 << FileName;
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();
1605 return true;
1606
1607 default:
1608 return false;
1609 }
1610}
1611
1612ModuleLoadResult
1613CompilerInstance::loadModule(SourceLocation ImportLoc,
1614 ModuleIdPath Path,
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
1620 // caller decide?
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())
1627 ModuleName += ".";
1628 ModuleName += Piece.first->getName();
1629 }
1630 }
1631 else
1632 ModuleName = Path[0].first->getName();
1633
1634 SourceLocation ModuleNameLoc = Path[0].second;
1635
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,
1643 ImportLoc);
1644 return LastModuleImportResult;
1645 }
1646
1647 clang::Module *Module = nullptr;
1648
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)
1662 // << ModuleName;
1663 // ModuleBuildFailed = true;
1664 // return ModuleLoadResult();
1665 //}
1666 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1667 } else {
1668 // Search for a module with the given name.
1669 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1670 HeaderSearchOptions &HSOpts =
1671 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1672
1673 std::string ModuleFileName;
1674 enum ModuleSource {
1675 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1676 } Source = ModuleNotFound;
1677
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;
1684 }
1685
1686 // Try to load the module from the prebuilt module path.
1687 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1688 !HSOpts.PrebuiltModulePaths.empty())) {
1689 ModuleFileName =
1690 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1691 if (!ModuleFileName.empty())
1692 Source = PrebuiltModulePath;
1693 }
1694
1695 // Try to load the module from the module cache.
1696 if (Source == ModuleNotFound && Module) {
1697 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1698 Source = ModuleCache;
1699 }
1700
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();
1707 }
1708
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;
1714 }
1715
1716 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1717 << ModuleName;
1718 ModuleBuildFailed = true;
1719 return ModuleLoadResult();
1720 }
1721
1722 // If we don't already have an ASTReader, create one now.
1723 if (!ModuleManager)
1724 createModuleManager();
1725
1726 llvm::Timer Timer;
1727 if (FrontendTimerGroup)
1728 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1729 *FrontendTimerGroup);
1730 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1731
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
1750 // module path.
1751 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1752 << ModuleName;
1753 ModuleBuildFailed = true;
1754 KnownModules[Path[0].first] = nullptr;
1755 return ModuleLoadResult();
1756 }
1757 }
1758 break;
1759 }
1760
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();
1770 }
1771
1772 // The module file is missing or out-of-date. Build it.
1773 assert(Module && "missing module file")((Module && "missing module file") ? static_cast<void
> (0) : __assert_fail ("Module && \"missing module file\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1773, __PRETTY_FUNCTION__))
;
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)
1779 break;
1780 }
1781
1782 if (Pos != PosEnd) {
1783 SmallString<256> CyclePath;
1784 for (; Pos != PosEnd; ++Pos) {
1785 CyclePath += Pos->first;
1786 CyclePath += " -> ";
1787 }
1788 CyclePath += ModuleName;
1789
1790 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1791 << ModuleName << CyclePath;
1792 return ModuleLoadResult();
1793 }
1794
1795 // Check whether we have already attempted to build this module (but
1796 // failed).
1797 if (getPreprocessorOpts().FailedModules &&
1798 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1799 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1800 << ModuleName
1801 << SourceRange(ImportLoc, ModuleNameLoc);
1802 ModuleBuildFailed = true;
1803 return ModuleLoadResult();
1804 }
1805
1806 // Try to compile and then load the module.
1807 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1808 ModuleFileName)) {
1809 assert(getDiagnostics().hasErrorOccurred() &&((getDiagnostics().hasErrorOccurred() && "undiagnosed error in compileAndLoadModule"
) ? static_cast<void> (0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1810, __PRETTY_FUNCTION__))
1810 "undiagnosed error in compileAndLoadModule")((getDiagnostics().hasErrorOccurred() && "undiagnosed error in compileAndLoadModule"
) ? static_cast<void> (0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-6.0~svn318211/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1810, __PRETTY_FUNCTION__))
;
1811 if (getPreprocessorOpts().FailedModules)
1812 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1813 KnownModules[Path[0].first] = nullptr;
1814 ModuleBuildFailed = true;
1815 return ModuleLoadResult();
1816 }
1817
1818 // Okay, we've rebuilt and now loaded the module.
1819 break;
1820 }
1821
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)
1828 << ModuleFileName;
1829 // Fall through to error out.
1830 LLVM_FALLTHROUGH[[clang::fallthrough]];
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();
1838
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();
1845 }
1846
1847 // Cache the result of this top-level module lookup for later.
1848 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1849 }
1850
1851 // If we never found the module, fail.
1852 if (!Module)
1853 return ModuleLoadResult();
1854
1855 // Verify that the rest of the module path actually corresponds to
1856 // a submodule.
1857 if (!getLangOpts().ModulesTS && Path.size() > 1) {
1858 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1859 StringRef Name = Path[I].first->getName();
1860 clang::Module *Sub = Module->findSubmodule(Name);
1861
1862 if (!Sub) {
1863 // Attempt to perform typo correction to find a module name that works.
1864 SmallVector<StringRef, 2> Best;
1865 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1866
1867 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1868 JEnd = Module->submodule_end();
1869 J != JEnd; ++J) {
1870 unsigned ED = Name.edit_distance((*J)->Name,
1871 /*AllowReplacements=*/true,
1872 BestEditDistance);
1873 if (ED <= BestEditDistance) {
1874 if (ED < BestEditDistance) {
1875 Best.clear();
1876 BestEditDistance = ED;
1877 }
1878
1879 Best.push_back((*J)->Name);
1880 }
1881 }
1882
1883 // If there was a clear winner, user it.
1884 if (Best.size() == 1) {
1885 getDiagnostics().Report(Path[I].second,
1886 diag::err_no_submodule_suggest)
1887 << Path[I].first << Module->getFullModuleName() << Best[0]
1888 << SourceRange(Path[0].second, Path[I-1].second)
1889 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1890 Best[0]);
1891
1892 Sub = Module->findSubmodule(Best[0]);
1893 }
1894 }
1895
1896 if (!Sub) {
1897 // No submodule by this name. Complain, and don't look for further
1898 // submodules.
1899 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1900 << Path[I].first << Module->getFullModuleName()
1901 << SourceRange(Path[0].second, Path[I-1].second);
1902 break;
1903 }
1904
1905 Module = Sub;
1906 }
1907 }
1908
1909 // Make the named module visible, if it's not already part of the module
1910 // we are parsing.
1911 if (ModuleName != getLangOpts().CurrentModule) {
1912 if (!Module->IsFromModuleFile) {
1913 // We have an umbrella header or directory that doesn't actually include
1914 // all of the headers within the directory it covers. Complain about
1915 // this missing submodule and recover by forgetting that we ever saw
1916 // this submodule.
1917 // FIXME: Should we detect this at module load time? It seems fairly
1918 // expensive (and rare).
1919 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1920 << Module->getFullModuleName()
1921 << SourceRange(Path.front().second, Path.back().second);
1922
1923 return ModuleLoadResult::MissingExpected;
1924 }
1925
1926 // Check whether this module is available.
1927 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1928 getDiagnostics(), Module)) {
1929 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1930 << SourceRange(Path.front().second, Path.back().second);
1931 LastModuleImportLoc = ImportLoc;
1932 LastModuleImportResult = ModuleLoadResult();
1933 return ModuleLoadResult();
1934 }
1935
1936 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1937 }
1938
1939 // Check for any configuration macros that have changed.
1940 clang::Module *TopModule = Module->getTopLevelModule();
1941 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1942 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1943 Module, ImportLoc);
1944 }
1945
1946 LastModuleImportLoc = ImportLoc;
1947 LastModuleImportResult = ModuleLoadResult(Module);
1948 return LastModuleImportResult;
1949}
1950
1951void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1952 StringRef ModuleName,
1953 StringRef Source) {
1954 // Avoid creating filenames with special characters.
1955 SmallString<128> CleanModuleName(ModuleName);
1956 for (auto &C : CleanModuleName)
1957 if (!isAlphanumeric(C))
1958 C = '_';
1959
1960 // FIXME: Using a randomized filename here means that our intermediate .pcm
1961 // output is nondeterministic (as .pcm files refer to each other by name).
1962 // Can this affect the output in any way?
1963 SmallString<128> ModuleFileName;
1964 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1965 CleanModuleName, "pcm", ModuleFileName)) {
1966 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
1967 << ModuleFileName << EC.message();
1968 return;
1969 }
1970 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
1971
1972 FrontendInputFile Input(
1973 ModuleMapFileName,
1974 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
1975 InputKind::ModuleMap, /*Preprocessed*/true));
1976
1977 std::string NullTerminatedSource(Source.str());
1978
1979 auto PreBuildStep = [&](CompilerInstance &Other) {
1980 // Create a virtual file containing our desired source.
1981 // FIXME: We shouldn't need to do this.
1982 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
1983 ModuleMapFileName, NullTerminatedSource.size(), 0);
1984 Other.getSourceManager().overrideFileContents(
1985 ModuleMapFile,
1986 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
1987
1988 Other.BuiltModules = std::move(BuiltModules);
1989 Other.DeleteBuiltModules = false;
1990 };
1991
1992 auto PostBuildStep = [this](CompilerInstance &Other) {
1993 BuiltModules = std::move(Other.BuiltModules);
1994 };
1995
1996 // Build the module, inheriting any modules that we've built locally.
1997 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
1998 ModuleFileName, PreBuildStep, PostBuildStep)) {
1999 BuiltModules[ModuleName] = ModuleFileName.str();
2000 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2001 }
2002}
2003
2004void CompilerInstance::makeModuleVisible(Module *Mod,
2005 Module::NameVisibilityKind Visibility,
2006 SourceLocation ImportLoc) {
2007 if (!ModuleManager)
2008 createModuleManager();
2009 if (!ModuleManager)
2010 return;
2011
2012 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2013}
2014
2015GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2016 SourceLocation TriggerLoc) {
2017 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2018 return nullptr;
2019 if (!ModuleManager)
2020 createModuleManager();
2021 // Can't do anything if we don't have the module manager.
2022 if (!ModuleManager)
2023 return nullptr;
2024 // Get an existing global index. This loads it if not already
2025 // loaded.
2026 ModuleManager->loadGlobalIndex();
2027 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2028 // If the global index doesn't exist, create it.
2029 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2030 hasPreprocessor()) {
2031 llvm::sys::fs::create_directories(
2032 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2033 GlobalModuleIndex::writeIndex(
2034 getFileManager(), getPCHContainerReader(),
2035 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2036 ModuleManager->resetForReload();
2037 ModuleManager->loadGlobalIndex();
2038 GlobalIndex = ModuleManager->getGlobalIndex();
2039 }
2040 // For finding modules needing to be imported for fixit messages,
2041 // we need to make the global index cover all modules, so we do that here.
2042 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2043 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2044 bool RecreateIndex = false;
2045 for (ModuleMap::module_iterator I = MMap.module_begin(),
2046 E = MMap.module_end(); I != E; ++I) {
2047 Module *TheModule = I->second;
2048 const FileEntry *Entry = TheModule->getASTFile();
2049 if (!Entry) {
2050 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2051 Path.push_back(std::make_pair(
2052 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2053 std::reverse(Path.begin(), Path.end());
2054 // Load a module as hidden. This also adds it to the global index.
2055 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2056 RecreateIndex = true;
2057 }
2058 }
2059 if (RecreateIndex) {
2060 GlobalModuleIndex::writeIndex(
2061 getFileManager(), getPCHContainerReader(),
2062 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2063 ModuleManager->resetForReload();
2064 ModuleManager->loadGlobalIndex();
2065 GlobalIndex = ModuleManager->getGlobalIndex();
2066 }
2067 HaveFullGlobalModuleIndex = true;
2068 }
2069 return GlobalIndex;
2070}
2071
2072// Check global module index for missing imports.
2073bool
2074CompilerInstance::lookupMissingImports(StringRef Name,
2075 SourceLocation TriggerLoc) {
2076 // Look for the symbol in non-imported modules, but only if an error
2077 // actually occurred.
2078 if (!buildingModule()) {
2079 // Load global module index, or retrieve a previously loaded one.
2080 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2081 TriggerLoc);
2082
2083 // Only if we have a global index.
2084 if (GlobalIndex) {
2085 GlobalModuleIndex::HitSet FoundModules;
2086
2087 // Find the modules that reference the identifier.
2088 // Note that this only finds top-level modules.
2089 // We'll let diagnoseTypo find the actual declaration module.
2090 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2091 return true;
2092 }
2093 }
2094
2095 return false;
2096}
2097void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
2098
2099void CompilerInstance::setExternalSemaSource(
2100 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2101 ExternalSemaSrc = std::move(ESS);
2102}