Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CompilerInstance.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Frontend -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp
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?")(static_cast <bool> (OutputFiles.empty() && "Still output files in flight?"
) ? void (0) : __assert_fail ("OutputFiles.empty() && \"Still output files in flight?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 71, __extension__ __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() &&(static_cast <bool> (PCMCache.get() == &Reader->
getModuleManager().getPCMCache() && "Expected ASTReader to use the same PCM cache"
) ? void (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 140, __extension__ __PRETTY_FUNCTION__))
140 "Expected ASTReader to use the same PCM cache")(static_cast <bool> (PCMCache.get() == &Reader->
getModuleManager().getPCMCache() && "Expected ASTReader to use the same PCM cache"
) ? void (0) : __assert_fail ("PCMCache.get() == &Reader->getModuleManager().getPCMCache() && \"Expected ASTReader to use the same PCM cache\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 140, __extension__ __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())(static_cast <bool> (Diags.ownsClient()) ? void (0) : __assert_fail
("Diags.ownsClient()", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 241, __extension__ __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 IntrusiveRefCntPtr<vfs::FileSystem> VFS =
306 createVFSFromCompilerInvocation(getInvocation(), getDiagnostics());
307 setVirtualFileSystem(VFS);
308 }
309 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
310 return FileMgr.get();
311}
312
313// Source Manager
314
315void CompilerInstance::createSourceManager(FileManager &FileMgr) {
316 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
317}
318
319// Initialize the remapping of files to alternative contents, e.g.,
320// those specified through other files.
321static void InitializeFileRemapping(DiagnosticsEngine &Diags,
322 SourceManager &SourceMgr,
323 FileManager &FileMgr,
324 const PreprocessorOptions &InitOpts) {
325 // Remap files in the source manager (with buffers).
326 for (const auto &RB : InitOpts.RemappedFileBuffers) {
327 // Create the file entry for the file that we're mapping from.
328 const FileEntry *FromFile =
329 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
330 if (!FromFile) {
331 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
332 if (!InitOpts.RetainRemappedFileBuffers)
333 delete RB.second;
334 continue;
335 }
336
337 // Override the contents of the "from" file with the contents of
338 // the "to" file.
339 SourceMgr.overrideFileContents(FromFile, RB.second,
340 InitOpts.RetainRemappedFileBuffers);
341 }
342
343 // Remap files in the source manager (with other files).
344 for (const auto &RF : InitOpts.RemappedFiles) {
345 // Find the file that we're mapping to.
346 const FileEntry *ToFile = FileMgr.getFile(RF.second);
347 if (!ToFile) {
348 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
349 continue;
350 }
351
352 // Create the file entry for the file that we're mapping from.
353 const FileEntry *FromFile =
354 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
355 if (!FromFile) {
356 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
357 continue;
358 }
359
360 // Override the contents of the "from" file with the contents of
361 // the "to" file.
362 SourceMgr.overrideFileContents(FromFile, ToFile);
363 }
364
365 SourceMgr.setOverridenFilesKeepOriginalName(
366 InitOpts.RemappedFilesKeepOriginalName);
367}
368
369// Preprocessor
370
371void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
372 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
373
374 // Create a PTH manager if we are using some form of a token cache.
375 PTHManager *PTHMgr = nullptr;
376 if (!PPOpts.TokenCache.empty())
377 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
378
379 // Create the Preprocessor.
380 HeaderSearch *HeaderInfo =
381 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
382 getDiagnostics(), getLangOpts(), &getTarget());
383 PP = std::make_shared<Preprocessor>(
384 Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
385 getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
386 /*OwnsHeaderSearch=*/true, TUKind);
387 getTarget().adjust(getLangOpts());
388 PP->Initialize(getTarget(), getAuxTarget());
389
390 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
391 // That argument is used as the IdentifierInfoLookup argument to
392 // IdentifierTable's ctor.
393 if (PTHMgr) {
394 PTHMgr->setPreprocessor(&*PP);
395 PP->setPTHManager(PTHMgr);
396 }
397
398 if (PPOpts.DetailedRecord)
399 PP->createPreprocessingRecord();
400
401 // Apply remappings to the source manager.
402 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
403 PP->getFileManager(), PPOpts);
404
405 // Predefine macros and configure the preprocessor.
406 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
407 getFrontendOpts());
408
409 // Initialize the header search object. In CUDA compilations, we use the aux
410 // triple (the host triple) to initialize our header search, since we need to
411 // find the host headers in order to compile the CUDA code.
412 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
413 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
414 PP->getAuxTargetInfo())
415 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
416
417 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
418 PP->getLangOpts(), *HeaderSearchTriple);
419
420 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
421
422 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
423 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
424
425 // Handle generating dependencies, if requested.
426 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
427 if (!DepOpts.OutputFile.empty())
428 TheDependencyFileGenerator.reset(
429 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
430 if (!DepOpts.DOTOutputFile.empty())
431 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
432 getHeaderSearchOpts().Sysroot);
433
434 // If we don't have a collector, but we are collecting module dependencies,
435 // then we're the top level compiler instance and need to create one.
436 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
437 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
438 DepOpts.ModuleDependencyOutputDir);
439 }
440
441 // If there is a module dep collector, register with other dep collectors
442 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
443 if (ModuleDepCollector) {
444 addDependencyCollector(ModuleDepCollector);
445 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
446 collectIncludePCH(*this, ModuleDepCollector);
447 collectVFSEntries(*this, ModuleDepCollector);
448 }
449
450 for (auto &Listener : DependencyCollectors)
451 Listener->attachToPreprocessor(*PP);
452
453 // Handle generating header include information, if requested.
454 if (DepOpts.ShowHeaderIncludes)
455 AttachHeaderIncludeGen(*PP, DepOpts);
456 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
457 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
458 if (OutputPath == "-")
459 OutputPath = "";
460 AttachHeaderIncludeGen(*PP, DepOpts,
461 /*ShowAllHeaders=*/true, OutputPath,
462 /*ShowDepth=*/false);
463 }
464
465 if (DepOpts.PrintShowIncludes) {
466 AttachHeaderIncludeGen(*PP, DepOpts,
467 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
468 /*ShowDepth=*/true, /*MSStyle=*/true);
469 }
470}
471
472std::string CompilerInstance::getSpecificModuleCachePath() {
473 // Set up the module path, including the hash for the
474 // module-creation options.
475 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
476 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
477 llvm::sys::path::append(SpecificModuleCache,
478 getInvocation().getModuleHash());
479 return SpecificModuleCache.str();
480}
481
482// ASTContext
483
484void CompilerInstance::createASTContext() {
485 Preprocessor &PP = getPreprocessor();
486 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
487 PP.getIdentifierTable(), PP.getSelectorTable(),
488 PP.getBuiltinInfo());
489 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
490 setASTContext(Context);
491}
492
493// ExternalASTSource
494
495void CompilerInstance::createPCHExternalASTSource(
496 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
497 void *DeserializationListener, bool OwnDeserializationListener) {
498 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
499 ModuleManager = createPCHExternalASTSource(
500 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
501 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
502 getPCHContainerReader(),
503 getFrontendOpts().ModuleFileExtensions,
504 TheDependencyFileGenerator.get(),
505 DependencyCollectors,
506 DeserializationListener,
507 OwnDeserializationListener, Preamble,
508 getFrontendOpts().UseGlobalModuleIndex);
509}
510
511IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
512 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
513 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
514 const PCHContainerReader &PCHContainerRdr,
515 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
516 DependencyFileGenerator *DependencyFile,
517 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
518 void *DeserializationListener, bool OwnDeserializationListener,
519 bool Preamble, bool UseGlobalModuleIndex) {
520 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
521
522 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
523 PP, &Context, PCHContainerRdr, Extensions,
524 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
525 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
526 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
527
528 // We need the external source to be set up before we read the AST, because
529 // eagerly-deserialized declarations may use it.
530 Context.setExternalSource(Reader.get());
531
532 Reader->setDeserializationListener(
533 static_cast<ASTDeserializationListener *>(DeserializationListener),
534 /*TakeOwnership=*/OwnDeserializationListener);
535
536 if (DependencyFile)
537 DependencyFile->AttachToASTReader(*Reader);
538 for (auto &Listener : DependencyCollectors)
539 Listener->attachToASTReader(*Reader);
540
541 switch (Reader->ReadAST(Path,
542 Preamble ? serialization::MK_Preamble
543 : serialization::MK_PCH,
544 SourceLocation(),
545 ASTReader::ARR_None)) {
546 case ASTReader::Success:
547 // Set the predefines buffer as suggested by the PCH reader. Typically, the
548 // predefines buffer will be empty.
549 PP.setPredefines(Reader->getSuggestedPredefines());
550 return Reader;
551
552 case ASTReader::Failure:
553 // Unrecoverable failure: don't even try to process the input file.
554 break;
555
556 case ASTReader::Missing:
557 case ASTReader::OutOfDate:
558 case ASTReader::VersionMismatch:
559 case ASTReader::ConfigurationMismatch:
560 case ASTReader::HadErrors:
561 // No suitable PCH file could be found. Return an error.
562 break;
563 }
564
565 Context.setExternalSource(nullptr);
566 return nullptr;
567}
568
569// Code Completion
570
571static bool EnableCodeCompletion(Preprocessor &PP,
572 StringRef Filename,
573 unsigned Line,
574 unsigned Column) {
575 // Tell the source manager to chop off the given file at a specific
576 // line and column.
577 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
578 if (!Entry) {
579 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
580 << Filename;
581 return true;
582 }
583
584 // Truncate the named file at the given line/column.
585 PP.SetCodeCompletionPoint(Entry, Line, Column);
586 return false;
587}
588
589void CompilerInstance::createCodeCompletionConsumer() {
590 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
591 if (!CompletionConsumer) {
592 setCodeCompletionConsumer(
593 createCodeCompletionConsumer(getPreprocessor(),
594 Loc.FileName, Loc.Line, Loc.Column,
595 getFrontendOpts().CodeCompleteOpts,
596 llvm::outs()));
597 if (!CompletionConsumer)
598 return;
599 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
600 Loc.Line, Loc.Column)) {
601 setCodeCompletionConsumer(nullptr);
602 return;
603 }
604
605 if (CompletionConsumer->isOutputBinary() &&
606 llvm::sys::ChangeStdoutToBinary()) {
607 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
608 setCodeCompletionConsumer(nullptr);
609 }
610}
611
612void CompilerInstance::createFrontendTimer() {
613 FrontendTimerGroup.reset(
614 new llvm::TimerGroup("frontend", "Clang front-end time report"));
615 FrontendTimer.reset(
616 new llvm::Timer("frontend", "Clang front-end timer",
617 *FrontendTimerGroup));
618}
619
620CodeCompleteConsumer *
621CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
622 StringRef Filename,
623 unsigned Line,
624 unsigned Column,
625 const CodeCompleteOptions &Opts,
626 raw_ostream &OS) {
627 if (EnableCodeCompletion(PP, Filename, Line, Column))
628 return nullptr;
629
630 // Set up the creation routine for code-completion.
631 return new PrintingCodeCompleteConsumer(Opts, OS);
632}
633
634void CompilerInstance::createSema(TranslationUnitKind TUKind,
635 CodeCompleteConsumer *CompletionConsumer) {
636 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
637 TUKind, CompletionConsumer));
638 // Attach the external sema source if there is any.
639 if (ExternalSemaSrc) {
640 TheSema->addExternalSource(ExternalSemaSrc.get());
641 ExternalSemaSrc->InitializeSema(*TheSema);
642 }
643}
644
645// Output Files
646
647void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
648 OutputFiles.push_back(std::move(OutFile));
649}
650
651void CompilerInstance::clearOutputFiles(bool EraseFiles) {
652 for (OutputFile &OF : OutputFiles) {
653 if (!OF.TempFilename.empty()) {
654 if (EraseFiles) {
655 llvm::sys::fs::remove(OF.TempFilename);
656 } else {
657 SmallString<128> NewOutFile(OF.Filename);
658
659 // If '-working-directory' was passed, the output filename should be
660 // relative to that.
661 FileMgr->FixupRelativePath(NewOutFile);
662 if (std::error_code ec =
663 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
664 getDiagnostics().Report(diag::err_unable_to_rename_temp)
665 << OF.TempFilename << OF.Filename << ec.message();
666
667 llvm::sys::fs::remove(OF.TempFilename);
668 }
669 }
670 } else if (!OF.Filename.empty() && EraseFiles)
671 llvm::sys::fs::remove(OF.Filename);
672 }
673 OutputFiles.clear();
674 if (DeleteBuiltModules) {
675 for (auto &Module : BuiltModules)
676 llvm::sys::fs::remove(Module.second);
677 BuiltModules.clear();
678 }
679 NonSeekStream.reset();
680}
681
682std::unique_ptr<raw_pwrite_stream>
683CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
684 StringRef Extension) {
685 return createOutputFile(getFrontendOpts().OutputFile, Binary,
686 /*RemoveFileOnSignal=*/true, InFile, Extension,
687 /*UseTemporary=*/true);
688}
689
690std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
691 return llvm::make_unique<llvm::raw_null_ostream>();
692}
693
694std::unique_ptr<raw_pwrite_stream>
695CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
696 bool RemoveFileOnSignal, StringRef InFile,
697 StringRef Extension, bool UseTemporary,
698 bool CreateMissingDirectories) {
699 std::string OutputPathName, TempPathName;
700 std::error_code EC;
701 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
702 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
703 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
704 if (!OS) {
705 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
706 << EC.message();
707 return nullptr;
708 }
709
710 // Add the output file -- but don't try to remove "-", since this means we are
711 // using stdin.
712 addOutputFile(
713 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
714
715 return OS;
716}
717
718std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
719 StringRef OutputPath, std::error_code &Error, bool Binary,
720 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
721 bool UseTemporary, bool CreateMissingDirectories,
722 std::string *ResultPathName, std::string *TempPathName) {
723 assert((!CreateMissingDirectories || UseTemporary) &&(static_cast <bool> ((!CreateMissingDirectories || UseTemporary
) && "CreateMissingDirectories is only allowed when using temporary files"
) ? void (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 724, __extension__ __PRETTY_FUNCTION__))
724 "CreateMissingDirectories is only allowed when using temporary files")(static_cast <bool> ((!CreateMissingDirectories || UseTemporary
) && "CreateMissingDirectories is only allowed when using temporary files"
) ? void (0) : __assert_fail ("(!CreateMissingDirectories || UseTemporary) && \"CreateMissingDirectories is only allowed when using temporary files\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 724, __extension__ __PRETTY_FUNCTION__))
;
725
726 std::string OutFile, TempFile;
727 if (!OutputPath.empty()) {
728 OutFile = OutputPath;
729 } else if (InFile == "-") {
730 OutFile = "-";
731 } else if (!Extension.empty()) {
732 SmallString<128> Path(InFile);
733 llvm::sys::path::replace_extension(Path, Extension);
734 OutFile = Path.str();
735 } else {
736 OutFile = "-";
737 }
738
739 std::unique_ptr<llvm::raw_fd_ostream> OS;
740 std::string OSFile;
741
742 if (UseTemporary) {
743 if (OutFile == "-")
744 UseTemporary = false;
745 else {
746 llvm::sys::fs::file_status Status;
747 llvm::sys::fs::status(OutputPath, Status);
748 if (llvm::sys::fs::exists(Status)) {
749 // Fail early if we can't write to the final destination.
750 if (!llvm::sys::fs::can_write(OutputPath)) {
751 Error = make_error_code(llvm::errc::operation_not_permitted);
752 return nullptr;
753 }
754
755 // Don't use a temporary if the output is a special file. This handles
756 // things like '-o /dev/null'
757 if (!llvm::sys::fs::is_regular_file(Status))
758 UseTemporary = false;
759 }
760 }
761 }
762
763 if (UseTemporary) {
764 // Create a temporary file.
765 // Insert -%%%%%%%% before the extension (if any), and because some tools
766 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
767 // artifacts, also append .tmp.
768 StringRef OutputExtension = llvm::sys::path::extension(OutFile);
769 SmallString<128> TempPath =
770 StringRef(OutFile).drop_back(OutputExtension.size());
771 TempPath += "-%%%%%%%%";
772 TempPath += OutputExtension;
773 TempPath += ".tmp";
774 int fd;
775 std::error_code EC =
776 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
777
778 if (CreateMissingDirectories &&
779 EC == llvm::errc::no_such_file_or_directory) {
780 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
781 EC = llvm::sys::fs::create_directories(Parent);
782 if (!EC) {
783 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
784 }
785 }
786
787 if (!EC) {
788 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
789 OSFile = TempFile = TempPath.str();
790 }
791 // If we failed to create the temporary, fallback to writing to the file
792 // directly. This handles the corner case where we cannot write to the
793 // directory, but can write to the file.
794 }
795
796 if (!OS) {
797 OSFile = OutFile;
798 OS.reset(new llvm::raw_fd_ostream(
799 OSFile, Error,
800 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
801 if (Error)
802 return nullptr;
803 }
804
805 // Make sure the out stream file gets removed if we crash.
806 if (RemoveFileOnSignal)
807 llvm::sys::RemoveFileOnSignal(OSFile);
808
809 if (ResultPathName)
810 *ResultPathName = OutFile;
811 if (TempPathName)
812 *TempPathName = TempFile;
813
814 if (!Binary || OS->supportsSeeking())
815 return std::move(OS);
816
817 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
818 assert(!NonSeekStream)(static_cast <bool> (!NonSeekStream) ? void (0) : __assert_fail
("!NonSeekStream", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 818, __extension__ __PRETTY_FUNCTION__))
;
819 NonSeekStream = std::move(OS);
820 return std::move(B);
821}
822
823// Initialization Utilities
824
825bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
826 return InitializeSourceManager(
3
Calling 'CompilerInstance::InitializeSourceManager'
827 Input, getDiagnostics(), getFileManager(), getSourceManager(),
828 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
1
'?' condition is false
2
Passing null pointer value via 5th parameter 'HS'
829 getDependencyOutputOpts(), getFrontendOpts());
830}
831
832// static
833bool CompilerInstance::InitializeSourceManager(
834 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
835 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
836 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
837 SrcMgr::CharacteristicKind Kind =
838 Input.getKind().getFormat() == InputKind::ModuleMap
4
Assuming the condition is false
5
'?' condition is false
839 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
840 : SrcMgr::C_User_ModuleMap
841 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
6
Assuming the condition is false
7
'?' condition is false
842
843 if (Input.isBuffer()) {
8
Taking false branch
844 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
845 Input.getBuffer(), Kind));
846 assert(SourceMgr.getMainFileID().isValid() &&(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 847, __extension__ __PRETTY_FUNCTION__))
847 "Couldn't establish MainFileID!")(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 847, __extension__ __PRETTY_FUNCTION__))
;
848 return true;
849 }
850
851 StringRef InputFile = Input.getFile();
852
853 // Figure out where to get and map in the main file.
854 if (InputFile != "-") {
9
Taking true branch
855 const FileEntry *File;
856 if (Opts.FindPchSource.empty()) {
10
Assuming the condition is false
11
Taking false branch
857 File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
858 } else {
859 // When building a pch file in clang-cl mode, the .h file is built as if
860 // it was included by a cc file. Since the driver doesn't know about
861 // all include search directories, the frontend must search the input
862 // file through HeaderSearch here, as if it had been included by the
863 // cc file at Opts.FindPchSource.
864 const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource);
865 if (!FindFile) {
12
Assuming 'FindFile' is non-null
13
Taking false branch
866 Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
867 return false;
868 }
869 const DirectoryLookup *UnusedCurDir;
870 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
871 Includers;
872 Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
873 File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
14
Called C++ object pointer is null
874 /*FromDir=*/nullptr,
875 /*CurDir=*/UnusedCurDir, Includers,
876 /*SearchPath=*/nullptr,
877 /*RelativePath=*/nullptr,
878 /*RequestingModule=*/nullptr,
879 /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
880 /*SkipCache=*/true);
881 // Also add the header to /showIncludes output.
882 if (File)
883 DepOpts.ShowIncludesPretendHeader = File->getName();
884 }
885 if (!File) {
886 Diags.Report(diag::err_fe_error_reading) << InputFile;
887 return false;
888 }
889
890 // The natural SourceManager infrastructure can't currently handle named
891 // pipes, but we would at least like to accept them for the main
892 // file. Detect them here, read them with the volatile flag so FileMgr will
893 // pick up the correct size, and simply override their contents as we do for
894 // STDIN.
895 if (File->isNamedPipe()) {
896 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
897 if (MB) {
898 // Create a new virtual file that will have the correct size.
899 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
900 SourceMgr.overrideFileContents(File, std::move(*MB));
901 } else {
902 Diags.Report(diag::err_cannot_open_file) << InputFile
903 << MB.getError().message();
904 return false;
905 }
906 }
907
908 SourceMgr.setMainFileID(
909 SourceMgr.createFileID(File, SourceLocation(), Kind));
910 } else {
911 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
912 llvm::MemoryBuffer::getSTDIN();
913 if (std::error_code EC = SBOrErr.getError()) {
914 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
915 return false;
916 }
917 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
918
919 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
920 SB->getBufferSize(), 0);
921 SourceMgr.setMainFileID(
922 SourceMgr.createFileID(File, SourceLocation(), Kind));
923 SourceMgr.overrideFileContents(File, std::move(SB));
924 }
925
926 assert(SourceMgr.getMainFileID().isValid() &&(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 927, __extension__ __PRETTY_FUNCTION__))
927 "Couldn't establish MainFileID!")(static_cast <bool> (SourceMgr.getMainFileID().isValid(
) && "Couldn't establish MainFileID!") ? void (0) : __assert_fail
("SourceMgr.getMainFileID().isValid() && \"Couldn't establish MainFileID!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 927, __extension__ __PRETTY_FUNCTION__))
;
928 return true;
929}
930
931// High-Level Operations
932
933bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
934 assert(hasDiagnostics() && "Diagnostics engine is not initialized!")(static_cast <bool> (hasDiagnostics() && "Diagnostics engine is not initialized!"
) ? void (0) : __assert_fail ("hasDiagnostics() && \"Diagnostics engine is not initialized!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 934, __extension__ __PRETTY_FUNCTION__))
;
935 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!")(static_cast <bool> (!getFrontendOpts().ShowHelp &&
"Client must handle '-help'!") ? void (0) : __assert_fail ("!getFrontendOpts().ShowHelp && \"Client must handle '-help'!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 935, __extension__ __PRETTY_FUNCTION__))
;
936 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!")(static_cast <bool> (!getFrontendOpts().ShowVersion &&
"Client must handle '-version'!") ? void (0) : __assert_fail
("!getFrontendOpts().ShowVersion && \"Client must handle '-version'!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 936, __extension__ __PRETTY_FUNCTION__))
;
937
938 // FIXME: Take this as an argument, once all the APIs we used have moved to
939 // taking it as an input instead of hard-coding llvm::errs.
940 raw_ostream &OS = llvm::errs();
941
942 // Create the target instance.
943 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
944 getInvocation().TargetOpts));
945 if (!hasTarget())
946 return false;
947
948 // Create TargetInfo for the other side of CUDA and OpenMP compilation.
949 if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
950 !getFrontendOpts().AuxTriple.empty()) {
951 auto TO = std::make_shared<TargetOptions>();
952 TO->Triple = getFrontendOpts().AuxTriple;
953 TO->HostTriple = getTarget().getTriple().str();
954 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
955 }
956
957 // Inform the target of the language options.
958 //
959 // FIXME: We shouldn't need to do this, the target should be immutable once
960 // created. This complexity should be lifted elsewhere.
961 getTarget().adjust(getLangOpts());
962
963 // Adjust target options based on codegen options.
964 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
965
966 // rewriter project will change target built-in bool type from its default.
967 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
968 getTarget().noSignedCharForObjCBool();
969
970 // Validate/process some options.
971 if (getHeaderSearchOpts().Verbose)
972 OS << "clang -cc1 version " CLANG_VERSION_STRING"7.0.0"
973 << " based upon " << BACKEND_PACKAGE_STRING"LLVM 7.0.0"
974 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
975
976 if (getFrontendOpts().ShowTimers)
977 createFrontendTimer();
978
979 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
980 llvm::EnableStatistics(false);
981
982 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
983 // Reset the ID tables if we are reusing the SourceManager and parsing
984 // regular files.
985 if (hasSourceManager() && !Act.isModelParsingAction())
986 getSourceManager().clearIDTables();
987
988 if (Act.BeginSourceFile(*this, FIF)) {
989 Act.Execute();
990 Act.EndSourceFile();
991 }
992 }
993
994 // Notify the diagnostic client that all files were processed.
995 getDiagnostics().getClient()->finish();
996
997 if (getDiagnosticOpts().ShowCarets) {
998 // We can have multiple diagnostics sharing one diagnostic client.
999 // Get the total number of warnings/errors from the client.
1000 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
1001 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
1002
1003 if (NumWarnings)
1004 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1005 if (NumWarnings && NumErrors)
1006 OS << " and ";
1007 if (NumErrors)
1008 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1009 if (NumWarnings || NumErrors) {
1010 OS << " generated";
1011 if (getLangOpts().CUDA) {
1012 if (!getLangOpts().CUDAIsDevice) {
1013 OS << " when compiling for host";
1014 } else {
1015 OS << " when compiling for " << getTargetOpts().CPU;
1016 }
1017 }
1018 OS << ".\n";
1019 }
1020 }
1021
1022 if (getFrontendOpts().ShowStats) {
1023 if (hasFileManager()) {
1024 getFileManager().PrintStats();
1025 OS << '\n';
1026 }
1027 llvm::PrintStatistics(OS);
1028 }
1029 StringRef StatsFile = getFrontendOpts().StatsFile;
1030 if (!StatsFile.empty()) {
1031 std::error_code EC;
1032 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1033 llvm::sys::fs::F_Text);
1034 if (EC) {
1035 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1036 << StatsFile << EC.message();
1037 } else {
1038 llvm::PrintStatisticsJSON(*StatS);
1039 }
1040 }
1041
1042 return !getDiagnostics().getClient()->getNumErrors();
1043}
1044
1045/// \brief Determine the appropriate source input kind based on language
1046/// options.
1047static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
1048 if (LangOpts.OpenCL)
1049 return InputKind::OpenCL;
1050 if (LangOpts.CUDA)
1051 return InputKind::CUDA;
1052 if (LangOpts.ObjC1)
1053 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1054 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1055}
1056
1057/// \brief Compile a module file for the given module, using the options
1058/// provided by the importing compiler instance. Returns true if the module
1059/// was built without errors.
1060static bool
1061compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1062 StringRef ModuleName, FrontendInputFile Input,
1063 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1064 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1065 [](CompilerInstance &) {},
1066 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1067 [](CompilerInstance &) {}) {
1068 // Construct a compiler invocation for creating this module.
1069 auto Invocation =
1070 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1071
1072 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1073
1074 // For any options that aren't intended to affect how a module is built,
1075 // reset them to their default values.
1076 Invocation->getLangOpts()->resetNonModularOptions();
1077 PPOpts.resetNonModularOptions();
1078
1079 // Remove any macro definitions that are explicitly ignored by the module.
1080 // They aren't supposed to affect how the module is built anyway.
1081 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1082 PPOpts.Macros.erase(
1083 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1084 [&HSOpts](const std::pair<std::string, bool> &def) {
1085 StringRef MacroDef = def.first;
1086 return HSOpts.ModulesIgnoreMacros.count(
1087 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1088 }),
1089 PPOpts.Macros.end());
1090
1091 // If the original compiler invocation had -fmodule-name, pass it through.
1092 Invocation->getLangOpts()->ModuleName =
1093 ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1094
1095 // Note the name of the module we're building.
1096 Invocation->getLangOpts()->CurrentModule = ModuleName;
1097
1098 // Make sure that the failed-module structure has been allocated in
1099 // the importing instance, and propagate the pointer to the newly-created
1100 // instance.
1101 PreprocessorOptions &ImportingPPOpts
1102 = ImportingInstance.getInvocation().getPreprocessorOpts();
1103 if (!ImportingPPOpts.FailedModules)
1104 ImportingPPOpts.FailedModules =
1105 std::make_shared<PreprocessorOptions::FailedModulesSet>();
1106 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1107
1108 // If there is a module map file, build the module using the module map.
1109 // Set up the inputs/outputs so that we build the module from its umbrella
1110 // header.
1111 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1112 FrontendOpts.OutputFile = ModuleFileName.str();
1113 FrontendOpts.DisableFree = false;
1114 FrontendOpts.GenerateGlobalModuleIndex = false;
1115 FrontendOpts.BuildingImplicitModule = true;
1116 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1117 // Force implicitly-built modules to hash the content of the module file.
1118 HSOpts.ModulesHashContent = true;
1119 FrontendOpts.Inputs = {Input};
1120
1121 // Don't free the remapped file buffers; they are owned by our caller.
1122 PPOpts.RetainRemappedFileBuffers = true;
1123
1124 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1125 assert(ImportingInstance.getInvocation().getModuleHash() ==(static_cast <bool> (ImportingInstance.getInvocation().
getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"
) ? void (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1126, __extension__ __PRETTY_FUNCTION__))
1126 Invocation->getModuleHash() && "Module hash mismatch!")(static_cast <bool> (ImportingInstance.getInvocation().
getModuleHash() == Invocation->getModuleHash() && "Module hash mismatch!"
) ? void (0) : __assert_fail ("ImportingInstance.getInvocation().getModuleHash() == Invocation->getModuleHash() && \"Module hash mismatch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1126, __extension__ __PRETTY_FUNCTION__))
;
1127
1128 // Construct a compiler instance that will be used to actually create the
1129 // module. Since we're sharing a PCMCache,
1130 // CompilerInstance::CompilerInstance is responsible for finalizing the
1131 // buffers to prevent use-after-frees.
1132 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1133 &ImportingInstance.getPreprocessor().getPCMCache());
1134 auto &Inv = *Invocation;
1135 Instance.setInvocation(std::move(Invocation));
1136
1137 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1138 ImportingInstance.getDiagnosticClient()),
1139 /*ShouldOwnClient=*/true);
1140
1141 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1142
1143 // Note that this module is part of the module build stack, so that we
1144 // can detect cycles in the module graph.
1145 Instance.setFileManager(&ImportingInstance.getFileManager());
1146 Instance.createSourceManager(Instance.getFileManager());
1147 SourceManager &SourceMgr = Instance.getSourceManager();
1148 SourceMgr.setModuleBuildStack(
1149 ImportingInstance.getSourceManager().getModuleBuildStack());
1150 SourceMgr.pushModuleBuildStack(ModuleName,
1151 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1152
1153 // If we're collecting module dependencies, we need to share a collector
1154 // between all of the module CompilerInstances. Other than that, we don't
1155 // want to produce any dependency output from the module build.
1156 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1157 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1158
1159 ImportingInstance.getDiagnostics().Report(ImportLoc,
1160 diag::remark_module_build)
1161 << ModuleName << ModuleFileName;
1162
1163 PreBuildStep(Instance);
1164
1165 // Execute the action to actually build the module in-place. Use a separate
1166 // thread so that we get a stack large enough.
1167 const unsigned ThreadStackSize = 8 << 20;
1168 llvm::CrashRecoveryContext CRC;
1169 CRC.RunSafelyOnThread(
1170 [&]() {
1171 GenerateModuleFromModuleMapAction Action;
1172 Instance.ExecuteAction(Action);
1173 },
1174 ThreadStackSize);
1175
1176 PostBuildStep(Instance);
1177
1178 ImportingInstance.getDiagnostics().Report(ImportLoc,
1179 diag::remark_module_build_done)
1180 << ModuleName;
1181
1182 // Delete the temporary module map file.
1183 // FIXME: Even though we're executing under crash protection, it would still
1184 // be nice to do this with RemoveFileOnSignal when we can. However, that
1185 // doesn't make sense for all clients, so clean this up manually.
1186 Instance.clearOutputFiles(/*EraseFiles=*/true);
1187
1188 return !Instance.getDiagnostics().hasErrorOccurred();
1189}
1190
1191/// \brief Compile a module file for the given module, using the options
1192/// provided by the importing compiler instance. Returns true if the module
1193/// was built without errors.
1194static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1195 SourceLocation ImportLoc,
1196 Module *Module,
1197 StringRef ModuleFileName) {
1198 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1199 InputKind::ModuleMap);
1200
1201 // Get or create the module map that we'll use to build this module.
1202 ModuleMap &ModMap
1203 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1204 bool Result;
1205 if (const FileEntry *ModuleMapFile =
1206 ModMap.getContainingModuleMapFile(Module)) {
1207 // Use the module map where this module resides.
1208 Result = compileModuleImpl(
1209 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1210 FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1211 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1212 ModuleFileName);
1213 } else {
1214 // FIXME: We only need to fake up an input file here as a way of
1215 // transporting the module's directory to the module map parser. We should
1216 // be able to do that more directly, and parse from a memory buffer without
1217 // inventing this file.
1218 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1219 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1220
1221 std::string InferredModuleMapContent;
1222 llvm::raw_string_ostream OS(InferredModuleMapContent);
1223 Module->print(OS);
1224 OS.flush();
1225
1226 Result = compileModuleImpl(
1227 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1228 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1229 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1230 ModuleFileName,
1231 [&](CompilerInstance &Instance) {
1232 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1233 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1234 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1235 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1236 Instance.getSourceManager().overrideFileContents(
1237 ModuleMapFile, std::move(ModuleMapBuffer));
1238 });
1239 }
1240
1241 // We've rebuilt a module. If we're allowed to generate or update the global
1242 // module index, record that fact in the importing compiler instance.
1243 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1244 ImportingInstance.setBuildGlobalModuleIndex(true);
1245 }
1246
1247 return Result;
1248}
1249
1250static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1251 SourceLocation ImportLoc,
1252 SourceLocation ModuleNameLoc, Module *Module,
1253 StringRef ModuleFileName) {
1254 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1255
1256 auto diagnoseBuildFailure = [&] {
1257 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1258 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1259 };
1260
1261 // FIXME: have LockFileManager return an error_code so that we can
1262 // avoid the mkdir when the directory already exists.
1263 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1264 llvm::sys::fs::create_directories(Dir);
1265
1266 while (1) {
1267 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1268 llvm::LockFileManager Locked(ModuleFileName);
1269 switch (Locked) {
1270 case llvm::LockFileManager::LFS_Error:
1271 // PCMCache takes care of correctness and locks are only necessary for
1272 // performance. Fallback to building the module in case of any lock
1273 // related errors.
1274 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1275 << Module->Name << Locked.getErrorMessage();
1276 // Clear out any potential leftover.
1277 Locked.unsafeRemoveLockFile();
1278 // FALLTHROUGH
1279 case llvm::LockFileManager::LFS_Owned:
1280 // We're responsible for building the module ourselves.
1281 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1282 ModuleFileName)) {
1283 diagnoseBuildFailure();
1284 return false;
1285 }
1286 break;
1287
1288 case llvm::LockFileManager::LFS_Shared:
1289 // Someone else is responsible for building the module. Wait for them to
1290 // finish.
1291 switch (Locked.waitForUnlock()) {
1292 case llvm::LockFileManager::Res_Success:
1293 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1294 break;
1295 case llvm::LockFileManager::Res_OwnerDied:
1296 continue; // try again to get the lock.
1297 case llvm::LockFileManager::Res_Timeout:
1298 // Since PCMCache takes care of correctness, we try waiting for another
1299 // process to complete the build so clang does not do it done twice. If
1300 // case of timeout, build it ourselves.
1301 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1302 << Module->Name;
1303 // Clear the lock file so that future invocations can make progress.
1304 Locked.unsafeRemoveLockFile();
1305 continue;
1306 }
1307 break;
1308 }
1309
1310 // Try to read the module file, now that we've compiled it.
1311 ASTReader::ASTReadResult ReadResult =
1312 ImportingInstance.getModuleManager()->ReadAST(
1313 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1314 ModuleLoadCapabilities);
1315
1316 if (ReadResult == ASTReader::OutOfDate &&
1317 Locked == llvm::LockFileManager::LFS_Shared) {
1318 // The module may be out of date in the presence of file system races,
1319 // or if one of its imports depends on header search paths that are not
1320 // consistent with this ImportingInstance. Try again...
1321 continue;
1322 } else if (ReadResult == ASTReader::Missing) {
1323 diagnoseBuildFailure();
1324 } else if (ReadResult != ASTReader::Success &&
1325 !Diags.hasErrorOccurred()) {
1326 // The ASTReader didn't diagnose the error, so conservatively report it.
1327 diagnoseBuildFailure();
1328 }
1329 return ReadResult == ASTReader::Success;
1330 }
1331}
1332
1333/// \brief Diagnose differences between the current definition of the given
1334/// configuration macro and the definition provided on the command line.
1335static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1336 Module *Mod, SourceLocation ImportLoc) {
1337 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1338 SourceManager &SourceMgr = PP.getSourceManager();
1339
1340 // If this identifier has never had a macro definition, then it could
1341 // not have changed.
1342 if (!Id->hadMacroDefinition())
1343 return;
1344 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1345
1346 // Find the macro definition from the command line.
1347 MacroInfo *CmdLineDefinition = nullptr;
1348 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1349 // We only care about the predefines buffer.
1350 FileID FID = SourceMgr.getFileID(MD->getLocation());
1351 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1352 continue;
1353 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1354 CmdLineDefinition = DMD->getMacroInfo();
1355 break;
1356 }
1357
1358 auto *CurrentDefinition = PP.getMacroInfo(Id);
1359 if (CurrentDefinition == CmdLineDefinition) {
1360 // Macro matches. Nothing to do.
1361 } else if (!CurrentDefinition) {
1362 // This macro was defined on the command line, then #undef'd later.
1363 // Complain.
1364 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1365 << true << ConfigMacro << Mod->getFullModuleName();
1366 auto LatestDef = LatestLocalMD->getDefinition();
1367 assert(LatestDef.isUndefined() &&(static_cast <bool> (LatestDef.isUndefined() &&
"predefined macro went away with no #undef?") ? void (0) : __assert_fail
("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1368, __extension__ __PRETTY_FUNCTION__))
1368 "predefined macro went away with no #undef?")(static_cast <bool> (LatestDef.isUndefined() &&
"predefined macro went away with no #undef?") ? void (0) : __assert_fail
("LatestDef.isUndefined() && \"predefined macro went away with no #undef?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1368, __extension__ __PRETTY_FUNCTION__))
;
1369 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1370 << true;
1371 return;
1372 } else if (!CmdLineDefinition) {
1373 // There was no definition for this macro in the predefines buffer,
1374 // but there was a local definition. Complain.
1375 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1376 << false << ConfigMacro << Mod->getFullModuleName();
1377 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1378 diag::note_module_def_undef_here)
1379 << false;
1380 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1381 /*Syntactically=*/true)) {
1382 // The macro definitions differ.
1383 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1384 << false << ConfigMacro << Mod->getFullModuleName();
1385 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1386 diag::note_module_def_undef_here)
1387 << false;
1388 }
1389}
1390
1391/// \brief Write a new timestamp file with the given path.
1392static void writeTimestampFile(StringRef TimestampFile) {
1393 std::error_code EC;
1394 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1395}
1396
1397/// \brief Prune the module cache of modules that haven't been accessed in
1398/// a long time.
1399static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1400 struct stat StatBuf;
1401 llvm::SmallString<128> TimestampFile;
1402 TimestampFile = HSOpts.ModuleCachePath;
1403 assert(!TimestampFile.empty())(static_cast <bool> (!TimestampFile.empty()) ? void (0)
: __assert_fail ("!TimestampFile.empty()", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1403, __extension__ __PRETTY_FUNCTION__))
;
1404 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1405
1406 // Try to stat() the timestamp file.
1407 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1408 // If the timestamp file wasn't there, create one now.
1409 if (errno(*__errno_location ()) == ENOENT2) {
1410 writeTimestampFile(TimestampFile);
1411 }
1412 return;
1413 }
1414
1415 // Check whether the time stamp is older than our pruning interval.
1416 // If not, do nothing.
1417 time_t TimeStampModTime = StatBuf.st_mtimest_mtim.tv_sec;
1418 time_t CurrentTime = time(nullptr);
1419 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1420 return;
1421
1422 // Write a new timestamp file so that nobody else attempts to prune.
1423 // There is a benign race condition here, if two Clang instances happen to
1424 // notice at the same time that the timestamp is out-of-date.
1425 writeTimestampFile(TimestampFile);
1426
1427 // Walk the entire module cache, looking for unused module files and module
1428 // indices.
1429 std::error_code EC;
1430 SmallString<128> ModuleCachePathNative;
1431 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1432 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1433 Dir != DirEnd && !EC; Dir.increment(EC)) {
1434 // If we don't have a directory, there's nothing to look into.
1435 if (!llvm::sys::fs::is_directory(Dir->path()))
1436 continue;
1437
1438 // Walk all of the files within this directory.
1439 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1440 File != FileEnd && !EC; File.increment(EC)) {
1441 // We only care about module and global module index files.
1442 StringRef Extension = llvm::sys::path::extension(File->path());
1443 if (Extension != ".pcm" && Extension != ".timestamp" &&
1444 llvm::sys::path::filename(File->path()) != "modules.idx")
1445 continue;
1446
1447 // Look at this file. If we can't stat it, there's nothing interesting
1448 // there.
1449 if (::stat(File->path().c_str(), &StatBuf))
1450 continue;
1451
1452 // If the file has been used recently enough, leave it there.
1453 time_t FileAccessTime = StatBuf.st_atimest_atim.tv_sec;
1454 if (CurrentTime - FileAccessTime <=
1455 time_t(HSOpts.ModuleCachePruneAfter)) {
1456 continue;
1457 }
1458
1459 // Remove the file.
1460 llvm::sys::fs::remove(File->path());
1461
1462 // Remove the timestamp file.
1463 std::string TimpestampFilename = File->path() + ".timestamp";
1464 llvm::sys::fs::remove(TimpestampFilename);
1465 }
1466
1467 // If we removed all of the files in the directory, remove the directory
1468 // itself.
1469 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1470 llvm::sys::fs::directory_iterator() && !EC)
1471 llvm::sys::fs::remove(Dir->path());
1472 }
1473}
1474
1475void CompilerInstance::createModuleManager() {
1476 if (!ModuleManager) {
1477 if (!hasASTContext())
1478 createASTContext();
1479
1480 // If we're implicitly building modules but not currently recursively
1481 // building a module, check whether we need to prune the module cache.
1482 if (getSourceManager().getModuleBuildStack().empty() &&
1483 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1484 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1485 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1486 pruneModuleCache(getHeaderSearchOpts());
1487 }
1488
1489 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1490 std::string Sysroot = HSOpts.Sysroot;
1491 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1492 std::unique_ptr<llvm::Timer> ReadTimer;
1493 if (FrontendTimerGroup)
1494 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1495 "Reading modules",
1496 *FrontendTimerGroup);
1497 ModuleManager = new ASTReader(
1498 getPreprocessor(), &getASTContext(), getPCHContainerReader(),
1499 getFrontendOpts().ModuleFileExtensions,
1500 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1501 /*AllowASTWithCompilerErrors=*/false,
1502 /*AllowConfigurationMismatch=*/false,
1503 HSOpts.ModulesValidateSystemHeaders,
1504 getFrontendOpts().UseGlobalModuleIndex,
1505 std::move(ReadTimer));
1506 if (hasASTConsumer()) {
1507 ModuleManager->setDeserializationListener(
1508 getASTConsumer().GetASTDeserializationListener());
1509 getASTContext().setASTMutationListener(
1510 getASTConsumer().GetASTMutationListener());
1511 }
1512 getASTContext().setExternalSource(ModuleManager);
1513 if (hasSema())
1514 ModuleManager->InitializeSema(getSema());
1515 if (hasASTConsumer())
1516 ModuleManager->StartTranslationUnit(&getASTConsumer());
1517
1518 if (TheDependencyFileGenerator)
1519 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1520 for (auto &Listener : DependencyCollectors)
1521 Listener->attachToASTReader(*ModuleManager);
1522 }
1523}
1524
1525bool CompilerInstance::loadModuleFile(StringRef FileName) {
1526 llvm::Timer Timer;
1527 if (FrontendTimerGroup)
1528 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1529 *FrontendTimerGroup);
1530 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1531
1532 // Helper to recursively read the module names for all modules we're adding.
1533 // We mark these as known and redirect any attempt to load that module to
1534 // the files we were handed.
1535 struct ReadModuleNames : ASTReaderListener {
1536 CompilerInstance &CI;
1537 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
1538
1539 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1540
1541 void ReadModuleName(StringRef ModuleName) override {
1542 LoadedModules.push_back(
1543 CI.getPreprocessor().getIdentifierInfo(ModuleName));
1544 }
1545
1546 void registerAll() {
1547 for (auto *II : LoadedModules) {
1548 CI.KnownModules[II] = CI.getPreprocessor()
1549 .getHeaderSearchInfo()
1550 .getModuleMap()
1551 .findModule(II->getName());
1552 }
1553 LoadedModules.clear();
1554 }
1555
1556 void markAllUnavailable() {
1557 for (auto *II : LoadedModules) {
1558 if (Module *M = CI.getPreprocessor()
1559 .getHeaderSearchInfo()
1560 .getModuleMap()
1561 .findModule(II->getName())) {
1562 M->HasIncompatibleModuleFile = true;
1563
1564 // Mark module as available if the only reason it was unavailable
1565 // was missing headers.
1566 SmallVector<Module *, 2> Stack;
1567 Stack.push_back(M);
1568 while (!Stack.empty()) {
1569 Module *Current = Stack.pop_back_val();
1570 if (Current->IsMissingRequirement) continue;
1571 Current->IsAvailable = true;
1572 Stack.insert(Stack.end(),
1573 Current->submodule_begin(), Current->submodule_end());
1574 }
1575 }
1576 }
1577 LoadedModules.clear();
1578 }
1579 };
1580
1581 // If we don't already have an ASTReader, create one now.
1582 if (!ModuleManager)
1583 createModuleManager();
1584
1585 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1586 auto &ListenerRef = *Listener;
1587 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1588 std::move(Listener));
1589
1590 // Try to load the module file.
1591 switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1592 SourceLocation(),
1593 ASTReader::ARR_ConfigurationMismatch)) {
1594 case ASTReader::Success:
1595 // We successfully loaded the module file; remember the set of provided
1596 // modules so that we don't try to load implicit modules for them.
1597 ListenerRef.registerAll();
1598 return true;
1599
1600 case ASTReader::ConfigurationMismatch:
1601 // Ignore unusable module files.
1602 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1603 << FileName;
1604 // All modules provided by any files we tried and failed to load are now
1605 // unavailable; includes of those modules should now be handled textually.
1606 ListenerRef.markAllUnavailable();
1607 return true;
1608
1609 default:
1610 return false;
1611 }
1612}
1613
1614ModuleLoadResult
1615CompilerInstance::loadModule(SourceLocation ImportLoc,
1616 ModuleIdPath Path,
1617 Module::NameVisibilityKind Visibility,
1618 bool IsInclusionDirective) {
1619 // Determine what file we're searching from.
1620 // FIXME: Should we be deciding whether this is a submodule (here and
1621 // below) based on -fmodules-ts or should we pass a flag and make the
1622 // caller decide?
1623 std::string ModuleName;
1624 if (getLangOpts().ModulesTS) {
1625 // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a
1626 // better place/way to do this.
1627 for (auto &Piece : Path) {
1628 if (!ModuleName.empty())
1629 ModuleName += ".";
1630 ModuleName += Piece.first->getName();
1631 }
1632 }
1633 else
1634 ModuleName = Path[0].first->getName();
1635
1636 SourceLocation ModuleNameLoc = Path[0].second;
1637
1638 // If we've already handled this import, just return the cached result.
1639 // This one-element cache is important to eliminate redundant diagnostics
1640 // when both the preprocessor and parser see the same import declaration.
1641 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1642 // Make the named module visible.
1643 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1644 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1645 ImportLoc);
1646 return LastModuleImportResult;
1647 }
1648
1649 clang::Module *Module = nullptr;
1650
1651 // If we don't already have information on this module, load the module now.
1652 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1653 = KnownModules.find(Path[0].first);
1654 if (Known != KnownModules.end()) {
1655 // Retrieve the cached top-level module.
1656 Module = Known->second;
1657 } else if (ModuleName == getLangOpts().CurrentModule) {
1658 // This is the module we're building.
1659 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1660 /// FIXME: perhaps we should (a) look for a module using the module name
1661 // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1662 //if (Module == nullptr) {
1663 // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1664 // << ModuleName;
1665 // ModuleBuildFailed = true;
1666 // return ModuleLoadResult();
1667 //}
1668 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1669 } else {
1670 // Search for a module with the given name.
1671 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1672 HeaderSearchOptions &HSOpts =
1673 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1674
1675 std::string ModuleFileName;
1676 enum ModuleSource {
1677 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1678 } Source = ModuleNotFound;
1679
1680 // Check to see if the module has been built as part of this compilation
1681 // via a module build pragma.
1682 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1683 if (BuiltModuleIt != BuiltModules.end()) {
1684 ModuleFileName = BuiltModuleIt->second;
1685 Source = ModuleBuildPragma;
1686 }
1687
1688 // Try to load the module from the prebuilt module path.
1689 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1690 !HSOpts.PrebuiltModulePaths.empty())) {
1691 ModuleFileName =
1692 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1693 if (!ModuleFileName.empty())
1694 Source = PrebuiltModulePath;
1695 }
1696
1697 // Try to load the module from the module cache.
1698 if (Source == ModuleNotFound && Module) {
1699 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1700 Source = ModuleCache;
1701 }
1702
1703 if (Source == ModuleNotFound) {
1704 // We can't find a module, error out here.
1705 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1706 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1707 ModuleBuildFailed = true;
1708 return ModuleLoadResult();
1709 }
1710
1711 if (ModuleFileName.empty()) {
1712 if (Module && Module->HasIncompatibleModuleFile) {
1713 // We tried and failed to load a module file for this module. Fall
1714 // back to textual inclusion for its headers.
1715 return ModuleLoadResult::ConfigMismatch;
1716 }
1717
1718 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1719 << ModuleName;
1720 ModuleBuildFailed = true;
1721 return ModuleLoadResult();
1722 }
1723
1724 // If we don't already have an ASTReader, create one now.
1725 if (!ModuleManager)
1726 createModuleManager();
1727
1728 llvm::Timer Timer;
1729 if (FrontendTimerGroup)
1730 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1731 *FrontendTimerGroup);
1732 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1733
1734 // Try to load the module file. If we are not trying to load from the
1735 // module cache, we don't know how to rebuild modules.
1736 unsigned ARRFlags = Source == ModuleCache ?
1737 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing :
1738 ASTReader::ARR_ConfigurationMismatch;
1739 switch (ModuleManager->ReadAST(ModuleFileName,
1740 Source == PrebuiltModulePath
1741 ? serialization::MK_PrebuiltModule
1742 : Source == ModuleBuildPragma
1743 ? serialization::MK_ExplicitModule
1744 : serialization::MK_ImplicitModule,
1745 ImportLoc, ARRFlags)) {
1746 case ASTReader::Success: {
1747 if (Source != ModuleCache && !Module) {
1748 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1749 if (!Module || !Module->getASTFile() ||
1750 FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1751 // Error out if Module does not refer to the file in the prebuilt
1752 // module path.
1753 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1754 << ModuleName;
1755 ModuleBuildFailed = true;
1756 KnownModules[Path[0].first] = nullptr;
1757 return ModuleLoadResult();
1758 }
1759 }
1760 break;
1761 }
1762
1763 case ASTReader::OutOfDate:
1764 case ASTReader::Missing: {
1765 if (Source != ModuleCache) {
1766 // We don't know the desired configuration for this module and don't
1767 // necessarily even have a module map. Since ReadAST already produces
1768 // diagnostics for these two cases, we simply error out here.
1769 ModuleBuildFailed = true;
1770 KnownModules[Path[0].first] = nullptr;
1771 return ModuleLoadResult();
1772 }
1773
1774 // The module file is missing or out-of-date. Build it.
1775 assert(Module && "missing module file")(static_cast <bool> (Module && "missing module file"
) ? void (0) : __assert_fail ("Module && \"missing module file\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1775, __extension__ __PRETTY_FUNCTION__))
;
1776 // Check whether there is a cycle in the module graph.
1777 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1778 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1779 for (; Pos != PosEnd; ++Pos) {
1780 if (Pos->first == ModuleName)
1781 break;
1782 }
1783
1784 if (Pos != PosEnd) {
1785 SmallString<256> CyclePath;
1786 for (; Pos != PosEnd; ++Pos) {
1787 CyclePath += Pos->first;
1788 CyclePath += " -> ";
1789 }
1790 CyclePath += ModuleName;
1791
1792 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1793 << ModuleName << CyclePath;
1794 return ModuleLoadResult();
1795 }
1796
1797 // Check whether we have already attempted to build this module (but
1798 // failed).
1799 if (getPreprocessorOpts().FailedModules &&
1800 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1801 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1802 << ModuleName
1803 << SourceRange(ImportLoc, ModuleNameLoc);
1804 ModuleBuildFailed = true;
1805 return ModuleLoadResult();
1806 }
1807
1808 // Try to compile and then load the module.
1809 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1810 ModuleFileName)) {
1811 assert(getDiagnostics().hasErrorOccurred() &&(static_cast <bool> (getDiagnostics().hasErrorOccurred(
) && "undiagnosed error in compileAndLoadModule") ? void
(0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1812, __extension__ __PRETTY_FUNCTION__))
1812 "undiagnosed error in compileAndLoadModule")(static_cast <bool> (getDiagnostics().hasErrorOccurred(
) && "undiagnosed error in compileAndLoadModule") ? void
(0) : __assert_fail ("getDiagnostics().hasErrorOccurred() && \"undiagnosed error in compileAndLoadModule\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Frontend/CompilerInstance.cpp"
, 1812, __extension__ __PRETTY_FUNCTION__))
;
1813 if (getPreprocessorOpts().FailedModules)
1814 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1815 KnownModules[Path[0].first] = nullptr;
1816 ModuleBuildFailed = true;
1817 return ModuleLoadResult();
1818 }
1819
1820 // Okay, we've rebuilt and now loaded the module.
1821 break;
1822 }
1823
1824 case ASTReader::ConfigurationMismatch:
1825 if (Source == PrebuiltModulePath)
1826 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1827 // produce a warning here!
1828 getDiagnostics().Report(SourceLocation(),
1829 diag::warn_module_config_mismatch)
1830 << ModuleFileName;
1831 // Fall through to error out.
1832 LLVM_FALLTHROUGH[[clang::fallthrough]];
1833 case ASTReader::VersionMismatch:
1834 case ASTReader::HadErrors:
1835 ModuleLoader::HadFatalFailure = true;
1836 // FIXME: The ASTReader will already have complained, but can we shoehorn
1837 // that diagnostic information into a more useful form?
1838 KnownModules[Path[0].first] = nullptr;
1839 return ModuleLoadResult();
1840
1841 case ASTReader::Failure:
1842 ModuleLoader::HadFatalFailure = true;
1843 // Already complained, but note now that we failed.
1844 KnownModules[Path[0].first] = nullptr;
1845 ModuleBuildFailed = true;
1846 return ModuleLoadResult();
1847 }
1848
1849 // Cache the result of this top-level module lookup for later.
1850 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1851 }
1852
1853 // If we never found the module, fail.
1854 if (!Module)
1855 return ModuleLoadResult();
1856
1857 // Verify that the rest of the module path actually corresponds to
1858 // a submodule.
1859 bool MapPrivateSubModToTopLevel = false;
1860 if (!getLangOpts().ModulesTS && Path.size() > 1) {
1861 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1862 StringRef Name = Path[I].first->getName();
1863 clang::Module *Sub = Module->findSubmodule(Name);
1864
1865 // If the user is requesting Foo.Private and it doesn't exist, try to
1866 // match Foo_Private and emit a warning asking for the user to write
1867 // @import Foo_Private instead. FIXME: remove this when existing clients
1868 // migrate off of Foo.Private syntax.
1869 if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1870 Module == Module->getTopLevelModule()) {
1871 SmallString<128> PrivateModule(Module->Name);
1872 PrivateModule.append("_Private");
1873
1874 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
1875 auto &II = PP->getIdentifierTable().get(
1876 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1877 PrivPath.push_back(std::make_pair(&II, Path[0].second));
1878
1879 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule))
1880 Sub =
1881 loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1882 if (Sub) {
1883 MapPrivateSubModToTopLevel = true;
1884 if (!getDiagnostics().isIgnored(
1885 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1886 getDiagnostics().Report(Path[I].second,
1887 diag::warn_no_priv_submodule_use_toplevel)
1888 << Path[I].first << Module->getFullModuleName() << PrivateModule
1889 << SourceRange(Path[0].second, Path[I].second)
1890 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1891 PrivateModule);
1892 getDiagnostics().Report(Sub->DefinitionLoc,
1893 diag::note_private_top_level_defined);
1894 }
1895 }
1896 }
1897
1898 if (!Sub) {
1899 // Attempt to perform typo correction to find a module name that works.
1900 SmallVector<StringRef, 2> Best;
1901 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1902
1903 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1904 JEnd = Module->submodule_end();
1905 J != JEnd; ++J) {
1906 unsigned ED = Name.edit_distance((*J)->Name,
1907 /*AllowReplacements=*/true,
1908 BestEditDistance);
1909 if (ED <= BestEditDistance) {
1910 if (ED < BestEditDistance) {
1911 Best.clear();
1912 BestEditDistance = ED;
1913 }
1914
1915 Best.push_back((*J)->Name);
1916 }
1917 }
1918
1919 // If there was a clear winner, user it.
1920 if (Best.size() == 1) {
1921 getDiagnostics().Report(Path[I].second,
1922 diag::err_no_submodule_suggest)
1923 << Path[I].first << Module->getFullModuleName() << Best[0]
1924 << SourceRange(Path[0].second, Path[I-1].second)
1925 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1926 Best[0]);
1927
1928 Sub = Module->findSubmodule(Best[0]);
1929 }
1930 }
1931
1932 if (!Sub) {
1933 // No submodule by this name. Complain, and don't look for further
1934 // submodules.
1935 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1936 << Path[I].first << Module->getFullModuleName()
1937 << SourceRange(Path[0].second, Path[I-1].second);
1938 break;
1939 }
1940
1941 Module = Sub;
1942 }
1943 }
1944
1945 // Make the named module visible, if it's not already part of the module
1946 // we are parsing.
1947 if (ModuleName != getLangOpts().CurrentModule) {
1948 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1949 // We have an umbrella header or directory that doesn't actually include
1950 // all of the headers within the directory it covers. Complain about
1951 // this missing submodule and recover by forgetting that we ever saw
1952 // this submodule.
1953 // FIXME: Should we detect this at module load time? It seems fairly
1954 // expensive (and rare).
1955 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1956 << Module->getFullModuleName()
1957 << SourceRange(Path.front().second, Path.back().second);
1958
1959 return ModuleLoadResult::MissingExpected;
1960 }
1961
1962 // Check whether this module is available.
1963 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1964 getDiagnostics(), Module)) {
1965 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1966 << SourceRange(Path.front().second, Path.back().second);
1967 LastModuleImportLoc = ImportLoc;
1968 LastModuleImportResult = ModuleLoadResult();
1969 return ModuleLoadResult();
1970 }
1971
1972 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1973 }
1974
1975 // Check for any configuration macros that have changed.
1976 clang::Module *TopModule = Module->getTopLevelModule();
1977 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1978 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1979 Module, ImportLoc);
1980 }
1981
1982 LastModuleImportLoc = ImportLoc;
1983 LastModuleImportResult = ModuleLoadResult(Module);
1984 return LastModuleImportResult;
1985}
1986
1987void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1988 StringRef ModuleName,
1989 StringRef Source) {
1990 // Avoid creating filenames with special characters.
1991 SmallString<128> CleanModuleName(ModuleName);
1992 for (auto &C : CleanModuleName)
1993 if (!isAlphanumeric(C))
1994 C = '_';
1995
1996 // FIXME: Using a randomized filename here means that our intermediate .pcm
1997 // output is nondeterministic (as .pcm files refer to each other by name).
1998 // Can this affect the output in any way?
1999 SmallString<128> ModuleFileName;
2000 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2001 CleanModuleName, "pcm", ModuleFileName)) {
2002 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2003 << ModuleFileName << EC.message();
2004 return;
2005 }
2006 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2007
2008 FrontendInputFile Input(
2009 ModuleMapFileName,
2010 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2011 InputKind::ModuleMap, /*Preprocessed*/true));
2012
2013 std::string NullTerminatedSource(Source.str());
2014
2015 auto PreBuildStep = [&](CompilerInstance &Other) {
2016 // Create a virtual file containing our desired source.
2017 // FIXME: We shouldn't need to do this.
2018 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2019 ModuleMapFileName, NullTerminatedSource.size(), 0);
2020 Other.getSourceManager().overrideFileContents(
2021 ModuleMapFile,
2022 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2023
2024 Other.BuiltModules = std::move(BuiltModules);
2025 Other.DeleteBuiltModules = false;
2026 };
2027
2028 auto PostBuildStep = [this](CompilerInstance &Other) {
2029 BuiltModules = std::move(Other.BuiltModules);
2030 };
2031
2032 // Build the module, inheriting any modules that we've built locally.
2033 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2034 ModuleFileName, PreBuildStep, PostBuildStep)) {
2035 BuiltModules[ModuleName] = ModuleFileName.str();
2036 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2037 }
2038}
2039
2040void CompilerInstance::makeModuleVisible(Module *Mod,
2041 Module::NameVisibilityKind Visibility,
2042 SourceLocation ImportLoc) {
2043 if (!ModuleManager)
2044 createModuleManager();
2045 if (!ModuleManager)
2046 return;
2047
2048 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2049}
2050
2051GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2052 SourceLocation TriggerLoc) {
2053 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2054 return nullptr;
2055 if (!ModuleManager)
2056 createModuleManager();
2057 // Can't do anything if we don't have the module manager.
2058 if (!ModuleManager)
2059 return nullptr;
2060 // Get an existing global index. This loads it if not already
2061 // loaded.
2062 ModuleManager->loadGlobalIndex();
2063 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2064 // If the global index doesn't exist, create it.
2065 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2066 hasPreprocessor()) {
2067 llvm::sys::fs::create_directories(
2068 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2069 GlobalModuleIndex::writeIndex(
2070 getFileManager(), getPCHContainerReader(),
2071 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2072 ModuleManager->resetForReload();
2073 ModuleManager->loadGlobalIndex();
2074 GlobalIndex = ModuleManager->getGlobalIndex();
2075 }
2076 // For finding modules needing to be imported for fixit messages,
2077 // we need to make the global index cover all modules, so we do that here.
2078 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2079 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2080 bool RecreateIndex = false;
2081 for (ModuleMap::module_iterator I = MMap.module_begin(),
2082 E = MMap.module_end(); I != E; ++I) {
2083 Module *TheModule = I->second;
2084 const FileEntry *Entry = TheModule->getASTFile();
2085 if (!Entry) {
2086 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2087 Path.push_back(std::make_pair(
2088 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2089 std::reverse(Path.begin(), Path.end());
2090 // Load a module as hidden. This also adds it to the global index.
2091 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2092 RecreateIndex = true;
2093 }
2094 }
2095 if (RecreateIndex) {
2096 GlobalModuleIndex::writeIndex(
2097 getFileManager(), getPCHContainerReader(),
2098 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2099 ModuleManager->resetForReload();
2100 ModuleManager->loadGlobalIndex();
2101 GlobalIndex = ModuleManager->getGlobalIndex();
2102 }
2103 HaveFullGlobalModuleIndex = true;
2104 }
2105 return GlobalIndex;
2106}
2107
2108// Check global module index for missing imports.
2109bool
2110CompilerInstance::lookupMissingImports(StringRef Name,
2111 SourceLocation TriggerLoc) {
2112 // Look for the symbol in non-imported modules, but only if an error
2113 // actually occurred.
2114 if (!buildingModule()) {
2115 // Load global module index, or retrieve a previously loaded one.
2116 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2117 TriggerLoc);
2118
2119 // Only if we have a global index.
2120 if (GlobalIndex) {
2121 GlobalModuleIndex::HitSet FoundModules;
2122
2123 // Find the modules that reference the identifier.
2124 // Note that this only finds top-level modules.
2125 // We'll let diagnoseTypo find the actual declaration module.
2126 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2127 return true;
2128 }
2129 }
2130
2131 return false;
2132}
2133void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
2134
2135void CompilerInstance::setExternalSemaSource(
2136 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2137 ExternalSemaSrc = std::move(ESS);
2138}