clang 8.0.0

CompilerInstance.cpp
Go to the documentation of this file.
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/Stack.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Basic/Version.h"
22 #include "clang/Config/config.h"
23 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
24 #include "clang/Frontend/FrontendAction.h"
25 #include "clang/Frontend/FrontendActions.h"
26 #include "clang/Frontend/FrontendDiagnostic.h"
27 #include "clang/Frontend/LogDiagnosticPrinter.h"
28 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
29 #include "clang/Frontend/TextDiagnosticPrinter.h"
30 #include "clang/Frontend/Utils.h"
31 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
32 #include "clang/Lex/HeaderSearch.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/BuryPointer.h"
41 #include "llvm/Support/CrashRecoveryContext.h"
42 #include "llvm/Support/Errc.h"
43 #include "llvm/Support/FileSystem.h"
44 #include "llvm/Support/Host.h"
45 #include "llvm/Support/LockFileManager.h"
46 #include "llvm/Support/MemoryBuffer.h"
47 #include "llvm/Support/Path.h"
48 #include "llvm/Support/Program.h"
49 #include "llvm/Support/Signals.h"
50 #include "llvm/Support/Timer.h"
51 #include "llvm/Support/raw_ostream.h"
52 #include <sys/stat.h>
53 #include <system_error>
54 #include <time.h>
55 #include <utility>
56
57 using namespace clang;
58
59 CompilerInstance::CompilerInstance(
60 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
61 MemoryBufferCache *SharedPCMCache)
62 : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
63 Invocation(new CompilerInvocation()),
64 PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
65 ThePCHContainerOperations(std::move(PCHContainerOps)) {
66 // Don't allow this to invalidate buffers in use by others.
67 if (SharedPCMCache)
68 getPCMCache().finalizeCurrentBuffers();
69 }
70
71 CompilerInstance::~CompilerInstance() {
72 assert(OutputFiles.empty() && "Still output files in flight?");
73 }
74
75 void CompilerInstance::setInvocation(
76 std::shared_ptr<CompilerInvocation> Value) {
77 Invocation = std::move(Value);
78 }
79
80 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
81 return (BuildGlobalModuleIndex ||
82 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
83 getFrontendOpts().GenerateGlobalModuleIndex)) &&
84 !ModuleBuildFailed;
85 }
86
87 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
88 Diagnostics = Value;
89 }
90
91 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
92 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
93
94 void CompilerInstance::setFileManager(FileManager *Value) {
95 FileMgr = Value;
96 if (Value)
97 VirtualFileSystem = Value->getVirtualFileSystem();
98 else
99 VirtualFileSystem.reset();
100 }
101
102 void CompilerInstance::setSourceManager(SourceManager *Value) {
103 SourceMgr = Value;
104 }
105
106 void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
107 PP = std::move(Value);
108 }
109
110 void CompilerInstance::setASTContext(ASTContext *Value) {
111 Context = Value;
112
113 if (Context && Consumer)
114 getASTConsumer().Initialize(getASTContext());
115 }
116
117 void CompilerInstance::setSema(Sema *S) {
118 TheSema.reset(S);
119 }
120
121 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
122 Consumer = std::move(Value);
123
124 if (Context && Consumer)
125 getASTConsumer().Initialize(getASTContext());
126 }
127
128 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
129 CompletionConsumer.reset(Value);
130 }
131
132 std::unique_ptr<Sema> CompilerInstance::takeSema() {
133 return std::move(TheSema);
134 }
135
136 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
137 return ModuleManager;
138 }
139 void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
140 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&
141 "Expected ASTReader to use the same PCM cache");
142 ModuleManager = std::move(Reader);
143 }
144
145 std::shared_ptr<ModuleDependencyCollector>
146 CompilerInstance::getModuleDepCollector() const {
147 return ModuleDepCollector;
148 }
149
150 void CompilerInstance::setModuleDepCollector(
151 std::shared_ptr<ModuleDependencyCollector> Collector) {
152 ModuleDepCollector = std::move(Collector);
153 }
154
155 static void collectHeaderMaps(const HeaderSearch &HS,
156 std::shared_ptr<ModuleDependencyCollector> MDC) {
157 SmallVector<std::string, 4> HeaderMapFileNames;
158 HS.getHeaderMapFileNames(HeaderMapFileNames);
159 for (auto &Name : HeaderMapFileNames)
160 MDC->addFile(Name);
161 }
162
163 static void collectIncludePCH(CompilerInstance &CI,
164 std::shared_ptr<ModuleDependencyCollector> MDC) {
165 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
166 if (PPOpts.ImplicitPCHInclude.empty())
167 return;
168
169 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
170 FileManager &FileMgr = CI.getFileManager();
171 const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
172 if (!PCHDir) {
173 MDC->addFile(PCHInclude);
174 return;
175 }
176
177 std::error_code EC;
178 SmallString<128> DirNative;
179 llvm::sys::path::native(PCHDir->getName(), DirNative);
180 llvm::vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
181 SimpleASTReaderListener Validator(CI.getPreprocessor());
182 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
183 Dir != DirEnd && !EC; Dir.increment(EC)) {
184 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
185 // used here since we're not interested in validating the PCH at this time,
186 // but only to check whether this is a file containing an AST.
187 if (!ASTReader::readASTFileControlBlock(
188 Dir->path(), FileMgr, CI.getPCHContainerReader(),
189 /*FindModuleFileExtensions=*/false, Validator,
190 /*ValidateDiagnosticOptions=*/false))
191 MDC->addFile(Dir->path());
192 }
193 }
194
195 static void collectVFSEntries(CompilerInstance &CI,
196 std::shared_ptr<ModuleDependencyCollector> MDC) {
197 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
198 return;
199
200 // Collect all VFS found.
201 SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries;
202 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
203 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
204 llvm::MemoryBuffer::getFile(VFSFile);
205 if (!Buffer)
206 return;
207 llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),
208 /*DiagHandler*/ nullptr, VFSFile, VFSEntries);
209 }
210
211 for (auto &E : VFSEntries)
212 MDC->addFile(E.VPath, E.RPath);
213 }
214
215 // Diagnostics
216 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
217 const CodeGenOptions *CodeGenOpts,
218 DiagnosticsEngine &Diags) {
219 std::error_code EC;
220 std::unique_ptr<raw_ostream> StreamOwner;
221 raw_ostream *OS = &llvm::errs();
222 if (DiagOpts->DiagnosticLogFile != "-") {
223 // Create the output stream.
224 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
225 DiagOpts->DiagnosticLogFile, EC,
226 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
227 if (EC) {
228 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
229 << DiagOpts->DiagnosticLogFile << EC.message();
230 } else {
231 FileOS->SetUnbuffered();
232 OS = FileOS.get();
233 StreamOwner = std::move(FileOS);
234 }
235 }
236
237 // Chain in the diagnostic client which will log the diagnostics.
238 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
239 std::move(StreamOwner));
240 if (CodeGenOpts)
241 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
242 assert(Diags.ownsClient());
243 Diags.setClient(
244 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
245 }
246
247 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
248 DiagnosticsEngine &Diags,
249 StringRef OutputFile) {
250 auto SerializedConsumer =
251 clang::serialized_diags::create(OutputFile, DiagOpts);
252
253 if (Diags.ownsClient()) {
254 Diags.setClient(new ChainedDiagnosticConsumer(
255 Diags.takeClient(), std::move(SerializedConsumer)));
256 } else {
257 Diags.setClient(new ChainedDiagnosticConsumer(
258 Diags.getClient(), std::move(SerializedConsumer)));
259 }
260 }
261
262 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
263 bool ShouldOwnClient) {
264 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
265 ShouldOwnClient, &getCodeGenOpts());
266 }
267
268 IntrusiveRefCntPtr<DiagnosticsEngine>
269 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
270 DiagnosticConsumer *Client,
271 bool ShouldOwnClient,
272 const CodeGenOptions *CodeGenOpts) {
273 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
274 IntrusiveRefCntPtr<DiagnosticsEngine>
275 Diags(new DiagnosticsEngine(DiagID, Opts));
276
277 // Create the diagnostic client for reporting errors or for
278 // implementing -verify.
279 if (Client) {
280 Diags->setClient(Client, ShouldOwnClient);
281 } else
282 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
283
284 // Chain in -verify checker, if requested.
285 if (Opts->VerifyDiagnostics)
286 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
287
288 // Chain in -diagnostic-log-file dumper, if requested.
289 if (!Opts->DiagnosticLogFile.empty())
290 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
291
292 if (!Opts->DiagnosticSerializationFile.empty())
293 SetupSerializedDiagnostics(Opts, *Diags,
294 Opts->DiagnosticSerializationFile);
295
296 // Configure our handling of diagnostics.
297 ProcessWarningOptions(*Diags, *Opts);
298
299 return Diags;
300 }
301
302 // File Manager
303
304 FileManager *CompilerInstance::createFileManager() {
305 if (!hasVirtualFileSystem()) {
306 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS =
307 createVFSFromCompilerInvocation(getInvocation(), getDiagnostics());
308 setVirtualFileSystem(VFS);
309 }
310 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
311 return FileMgr.get();
312 }
313
314 // Source Manager
315
316 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
317 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
318 }
319
320 // Initialize the remapping of files to alternative contents, e.g.,
321 // those specified through other files.
322 static void InitializeFileRemapping(DiagnosticsEngine &Diags,
323 SourceManager &SourceMgr,
324 FileManager &FileMgr,
325 const PreprocessorOptions &InitOpts) {
326 // Remap files in the source manager (with buffers).
327 for (const auto &RB : InitOpts.RemappedFileBuffers) {
328 // Create the file entry for the file that we're mapping from.
329 const FileEntry *FromFile =
330 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
331 if (!FromFile) {
332 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
333 if (!InitOpts.RetainRemappedFileBuffers)
334 delete RB.second;
335 continue;
336 }
337
338 // Override the contents of the "from" file with the contents of
339 // the "to" file.
340 SourceMgr.overrideFileContents(FromFile, RB.second,
341 InitOpts.RetainRemappedFileBuffers);
342 }
343
344 // Remap files in the source manager (with other files).
345 for (const auto &RF : InitOpts.RemappedFiles) {
346 // Find the file that we're mapping to.
347 const FileEntry *ToFile = FileMgr.getFile(RF.second);
348 if (!ToFile) {
349 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
350 continue;
351 }
352
353 // Create the file entry for the file that we're mapping from.
354 const FileEntry *FromFile =
355 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
356 if (!FromFile) {
357 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
358 continue;
359 }
360
361 // Override the contents of the "from" file with the contents of
362 // the "to" file.
363 SourceMgr.overrideFileContents(FromFile, ToFile);
364 }
365
366 SourceMgr.setOverridenFilesKeepOriginalName(
367 InitOpts.RemappedFilesKeepOriginalName);
368 }
369
370 // Preprocessor
371
372 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
373 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
374
375 // The module manager holds a reference to the old preprocessor (if any).
376 ModuleManager.reset();
377
378 // Create the Preprocessor.
379 HeaderSearch *HeaderInfo =
380 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
381 getDiagnostics(), getLangOpts(), &getTarget());
382 PP = std::make_shared<Preprocessor>(
383 Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
384 getSourceManager(), getPCMCache(), *HeaderInfo, *this,
385 /*IdentifierInfoLookup=*/nullptr,
386 /*OwnsHeaderSearch=*/true, TUKind);
387 getTarget().adjust(getLangOpts());
388 PP->Initialize(getTarget(), getAuxTarget());
389
390 if (PPOpts.DetailedRecord)
391 PP->createPreprocessingRecord();
392
393 // Apply remappings to the source manager.
394 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
395 PP->getFileManager(), PPOpts);
396
397 // Predefine macros and configure the preprocessor.
398 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
399 getFrontendOpts());
400
401 // Initialize the header search object. In CUDA compilations, we use the aux
402 // triple (the host triple) to initialize our header search, since we need to
403 // find the host headers in order to compile the CUDA code.
404 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
405 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
406 PP->getAuxTargetInfo())
407 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
408
409 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
410 PP->getLangOpts(), *HeaderSearchTriple);
411
412 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
413
414 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
415 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
416
417 // Handle generating dependencies, if requested.
418 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
419 if (!DepOpts.OutputFile.empty())
420 TheDependencyFileGenerator.reset(
421 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
422 if (!DepOpts.DOTOutputFile.empty())
423 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
424 getHeaderSearchOpts().Sysroot);
425
426 // If we don't have a collector, but we are collecting module dependencies,
427 // then we're the top level compiler instance and need to create one.
428 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
429 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
430 DepOpts.ModuleDependencyOutputDir);
431 }
432
433 // If there is a module dep collector, register with other dep collectors
434 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
435 if (ModuleDepCollector) {
436 addDependencyCollector(ModuleDepCollector);
437 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
438 collectIncludePCH(*this, ModuleDepCollector);
439 collectVFSEntries(*this, ModuleDepCollector);
440 }
441
442 for (auto &Listener : DependencyCollectors)
443 Listener->attachToPreprocessor(*PP);
444
445 // Handle generating header include information, if requested.
446 if (DepOpts.ShowHeaderIncludes)
447 AttachHeaderIncludeGen(*PP, DepOpts);
448 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
449 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
450 if (OutputPath == "-")
451 OutputPath = "";
452 AttachHeaderIncludeGen(*PP, DepOpts,
453 /*ShowAllHeaders=*/true, OutputPath,
454 /*ShowDepth=*/false);
455 }
456
457 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) {
458 AttachHeaderIncludeGen(*PP, DepOpts,
459 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
460 /*ShowDepth=*/true, /*MSStyle=*/true);
461 }
462 }
463
464 std::string CompilerInstance::getSpecificModuleCachePath() {
465 // Set up the module path, including the hash for the
466 // module-creation options.
467 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
468 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
469 llvm::sys::path::append(SpecificModuleCache,
470 getInvocation().getModuleHash());
471 return SpecificModuleCache.str();
472 }
473
474 // ASTContext
475
476 void CompilerInstance::createASTContext() {
477 Preprocessor &PP = getPreprocessor();
478 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
479 PP.getIdentifierTable(), PP.getSelectorTable(),
480 PP.getBuiltinInfo());
481 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
482 setASTContext(Context);
483 }
484
485 // ExternalASTSource
486
487 void CompilerInstance::createPCHExternalASTSource(
488 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
489 void *DeserializationListener, bool OwnDeserializationListener) {
490 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
491 ModuleManager = createPCHExternalASTSource(
492 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
493 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
494 getPCHContainerReader(),
495 getFrontendOpts().ModuleFileExtensions,
496 TheDependencyFileGenerator.get(),
497 DependencyCollectors,
498 DeserializationListener,
499 OwnDeserializationListener, Preamble,
500 getFrontendOpts().UseGlobalModuleIndex);
501 }
502
503 IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
504 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
505 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
506 const PCHContainerReader &PCHContainerRdr,
507 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
508 DependencyFileGenerator *DependencyFile,
509 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
510 void *DeserializationListener, bool OwnDeserializationListener,
511 bool Preamble, bool UseGlobalModuleIndex) {
512 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
513
514 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
515 PP, &Context, PCHContainerRdr, Extensions,
516 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
517 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
518 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
519
520 // We need the external source to be set up before we read the AST, because
521 // eagerly-deserialized declarations may use it.
522 Context.setExternalSource(Reader.get());
523
524 Reader->setDeserializationListener(
525 static_cast<ASTDeserializationListener *>(DeserializationListener),
526 /*TakeOwnership=*/OwnDeserializationListener);
527
528 if (DependencyFile)
529 DependencyFile->AttachToASTReader(*Reader);
530 for (auto &Listener : DependencyCollectors)
531 Listener->attachToASTReader(*Reader);
532
533 switch (Reader->ReadAST(Path,
534 Preamble ? serialization::MK_Preamble
535 : serialization::MK_PCH,
536 SourceLocation(),
537 ASTReader::ARR_None)) {
538 case ASTReader::Success:
539 // Set the predefines buffer as suggested by the PCH reader. Typically, the
540 // predefines buffer will be empty.
541 PP.setPredefines(Reader->getSuggestedPredefines());
542 return Reader;
543
544 case ASTReader::Failure:
545 // Unrecoverable failure: don't even try to process the input file.
546 break;
547
548 case ASTReader::Missing:
549 case ASTReader::OutOfDate:
550 case ASTReader::VersionMismatch:
551 case ASTReader::ConfigurationMismatch:
552 case ASTReader::HadErrors:
553 // No suitable PCH file could be found. Return an error.
554 break;
555 }
556
557 Context.setExternalSource(nullptr);
558 return nullptr;
559 }
560
561 // Code Completion
562
563 static bool EnableCodeCompletion(Preprocessor &PP,
564 StringRef Filename,
565 unsigned Line,
566 unsigned Column) {
567 // Tell the source manager to chop off the given file at a specific
568 // line and column.
569 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
570 if (!Entry) {
571 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
572 << Filename;
573 return true;
574 }
575
576 // Truncate the named file at the given line/column.
577 PP.SetCodeCompletionPoint(Entry, Line, Column);
578 return false;
579 }
580
581 void CompilerInstance::createCodeCompletionConsumer() {
582 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
583 if (!CompletionConsumer) {
584 setCodeCompletionConsumer(
585 createCodeCompletionConsumer(getPreprocessor(),
586 Loc.FileName, Loc.Line, Loc.Column,
587 getFrontendOpts().CodeCompleteOpts,
588 llvm::outs()));
589 if (!CompletionConsumer)
590 return;
591 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
592 Loc.Line, Loc.Column)) {
593 setCodeCompletionConsumer(nullptr);
594 return;
595 }
596
597 if (CompletionConsumer->isOutputBinary() &&
598 llvm::sys::ChangeStdoutToBinary()) {
599 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
600 setCodeCompletionConsumer(nullptr);
601 }
602 }
603
604 void CompilerInstance::createFrontendTimer() {
605 FrontendTimerGroup.reset(
606 new llvm::TimerGroup("frontend", "Clang front-end time report"));
607 FrontendTimer.reset(
608 new llvm::Timer("frontend", "Clang front-end timer",
609 *FrontendTimerGroup));
610 }
611
612 CodeCompleteConsumer *
613 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
614 StringRef Filename,
615 unsigned Line,
616 unsigned Column,
617 const CodeCompleteOptions &Opts,
618 raw_ostream &OS) {
619 if (EnableCodeCompletion(PP, Filename, Line, Column))
620 return nullptr;
621
622 // Set up the creation routine for code-completion.
623 return new PrintingCodeCompleteConsumer(Opts, OS);
624 }
625
626 void CompilerInstance::createSema(TranslationUnitKind TUKind,
627 CodeCompleteConsumer *CompletionConsumer) {
628 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
629 TUKind, CompletionConsumer));
630 // Attach the external sema source if there is any.
631 if (ExternalSemaSrc) {
632 TheSema->addExternalSource(ExternalSemaSrc.get());
633 ExternalSemaSrc->InitializeSema(*TheSema);
634 }
635 }
636
637 // Output Files
638
639 void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
640 OutputFiles.push_back(std::move(OutFile));
641 }
642
643 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
644 for (OutputFile &OF : OutputFiles) {
645 if (!OF.TempFilename.empty()) {
646 if (EraseFiles) {
647 llvm::sys::fs::remove(OF.TempFilename);
648 } else {
649 SmallString<128> NewOutFile(OF.Filename);
650
651 // If '-working-directory' was passed, the output filename should be
652 // relative to that.
653 FileMgr->FixupRelativePath(NewOutFile);
654 if (std::error_code ec =
655 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
656 getDiagnostics().Report(diag::err_unable_to_rename_temp)
657 << OF.TempFilename << OF.Filename << ec.message();
658
659 llvm::sys::fs::remove(OF.TempFilename);
660 }
661 }
662 } else if (!OF.Filename.empty() && EraseFiles)
663 llvm::sys::fs::remove(OF.Filename);
664 }
665 OutputFiles.clear();
666 if (DeleteBuiltModules) {
667 for (auto &Module : BuiltModules)
668 llvm::sys::fs::remove(Module.second);
669 BuiltModules.clear();
670 }
671 NonSeekStream.reset();
672 }
673
674 std::unique_ptr<raw_pwrite_stream>
675 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
676 StringRef Extension) {
677 return createOutputFile(getFrontendOpts().OutputFile, Binary,
678 /*RemoveFileOnSignal=*/true, InFile, Extension,
679 /*UseTemporary=*/true);
680 }
681
682 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
683 return llvm::make_unique<llvm::raw_null_ostream>();
684 }
685
686 std::unique_ptr<raw_pwrite_stream>
687 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
688 bool RemoveFileOnSignal, StringRef InFile,
689 StringRef Extension, bool UseTemporary,
690 bool CreateMissingDirectories) {
691 std::string OutputPathName, TempPathName;
692 std::error_code EC;
693 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
694 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
695 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
696 if (!OS) {
697 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
698 << EC.message();
699 return nullptr;
700 }
701
702 // Add the output file -- but don't try to remove "-", since this means we are
703 // using stdin.
704 addOutputFile(
705 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
706
707 return OS;
708 }
709
710 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
711 StringRef OutputPath, std::error_code &Error, bool Binary,
712 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
713 bool UseTemporary, bool CreateMissingDirectories,
714 std::string *ResultPathName, std::string *TempPathName) {
715 assert((!CreateMissingDirectories || UseTemporary) &&
716 "CreateMissingDirectories is only allowed when using temporary files");
717
718 std::string OutFile, TempFile;
719 if (!OutputPath.empty()) {
720 OutFile = OutputPath;
721 } else if (InFile == "-") {
722 OutFile = "-";
723 } else if (!Extension.empty()) {
724 SmallString<128> Path(InFile);
725 llvm::sys::path::replace_extension(Path, Extension);
726 OutFile = Path.str();
727 } else {
728 OutFile = "-";
729 }
730
731 std::unique_ptr<llvm::raw_fd_ostream> OS;
732 std::string OSFile;
733
734 if (UseTemporary) {
735 if (OutFile == "-")
736 UseTemporary = false;
737 else {
738 llvm::sys::fs::file_status Status;
739 llvm::sys::fs::status(OutputPath, Status);
740 if (llvm::sys::fs::exists(Status)) {
741 // Fail early if we can't write to the final destination.
742 if (!llvm::sys::fs::can_write(OutputPath)) {
743 Error = make_error_code(llvm::errc::operation_not_permitted);
744 return nullptr;
745 }
746
747 // Don't use a temporary if the output is a special file. This handles
748 // things like '-o /dev/null'
749 if (!llvm::sys::fs::is_regular_file(Status))
750 UseTemporary = false;
751 }
752 }
753 }
754
755 if (UseTemporary) {
756 // Create a temporary file.
757 // Insert -%%%%%%%% before the extension (if any), and because some tools
758 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
759 // artifacts, also append .tmp.
760 StringRef OutputExtension = llvm::sys::path::extension(OutFile);
761 SmallString<128> TempPath =
762 StringRef(OutFile).drop_back(OutputExtension.size());
763 TempPath += "-%%%%%%%%";
764 TempPath += OutputExtension;
765 TempPath += ".tmp";
766 int fd;
767 std::error_code EC =
768 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
769
770 if (CreateMissingDirectories &&
771 EC == llvm::errc::no_such_file_or_directory) {
772 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
773 EC = llvm::sys::fs::create_directories(Parent);
774 if (!EC) {
775 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
776 }
777 }
778
779 if (!EC) {
780 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
781 OSFile = TempFile = TempPath.str();
782 }
783 // If we failed to create the temporary, fallback to writing to the file
784 // directly. This handles the corner case where we cannot write to the
785 // directory, but can write to the file.
786 }
787
788 if (!OS) {
789 OSFile = OutFile;
790 OS.reset(new llvm::raw_fd_ostream(
791 OSFile, Error,
792 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
793 if (Error)
794 return nullptr;
795 }
796
797 // Make sure the out stream file gets removed if we crash.
798 if (RemoveFileOnSignal)
799 llvm::sys::RemoveFileOnSignal(OSFile);
800
801 if (ResultPathName)
802 *ResultPathName = OutFile;
803 if (TempPathName)
804 *TempPathName = TempFile;
805
806 if (!Binary || OS->supportsSeeking())
807 return std::move(OS);
808
809 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
810 assert(!NonSeekStream);
811 NonSeekStream = std::move(OS);
812 return std::move(B);
813 }
814
815 // Initialization Utilities
816
817 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
818 return InitializeSourceManager(
819 Input, getDiagnostics(), getFileManager(), getSourceManager(),
820 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
821 getDependencyOutputOpts(), getFrontendOpts());
822 }
823
824 // static
825 bool CompilerInstance::InitializeSourceManager(
826 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
827 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
828 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
829 SrcMgr::CharacteristicKind Kind =
830 Input.getKind().getFormat() == InputKind::ModuleMap
831 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
832 : SrcMgr::C_User_ModuleMap
833 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
834
835 if (Input.isBuffer()) {
836 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
837 Input.getBuffer(), Kind));
838 assert(SourceMgr.getMainFileID().isValid() &&
839 "Couldn't establish MainFileID!");
840 return true;
841 }
842
843 StringRef InputFile = Input.getFile();
844
845 // Figure out where to get and map in the main file.
846 if (InputFile != "-") {
847 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
848 if (!File) {
849 Diags.Report(diag::err_fe_error_reading) << InputFile;
850 return false;
851 }
852
853 // The natural SourceManager infrastructure can't currently handle named
854 // pipes, but we would at least like to accept them for the main
855 // file. Detect them here, read them with the volatile flag so FileMgr will
856 // pick up the correct size, and simply override their contents as we do for
857 // STDIN.
858 if (File->isNamedPipe()) {
859 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
860 if (MB) {
861 // Create a new virtual file that will have the correct size.
862 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
863 SourceMgr.overrideFileContents(File, std::move(*MB));
864 } else {
865 Diags.Report(diag::err_cannot_open_file) << InputFile
866 << MB.getError().message();
867 return false;
868 }
869 }
870
871 SourceMgr.setMainFileID(
872 SourceMgr.createFileID(File, SourceLocation(), Kind));
873 } else {
874 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
875 llvm::MemoryBuffer::getSTDIN();
876 if (std::error_code EC = SBOrErr.getError()) {
877 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
878 return false;
879 }
880 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
881
882 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
883 SB->getBufferSize(), 0);
884 SourceMgr.setMainFileID(
885 SourceMgr.createFileID(File, SourceLocation(), Kind));
886 SourceMgr.overrideFileContents(File, std::move(SB));
887 }
888
889 assert(SourceMgr.getMainFileID().isValid() &&
890 "Couldn't establish MainFileID!");
891 return true;
892 }
893
894 // High-Level Operations
895
896 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
897 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
898 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
899 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
900
901 // FIXME: Take this as an argument, once all the APIs we used have moved to
902 // taking it as an input instead of hard-coding llvm::errs.
903 raw_ostream &OS = llvm::errs();
904
905 if (!Act.PrepareToExecute(*this))
906 return false;
907
908 // Create the target instance.
909 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
910 getInvocation().TargetOpts));
911 if (!hasTarget())
912 return false;
913
914 // Create TargetInfo for the other side of CUDA and OpenMP compilation.
915 if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
916 !getFrontendOpts().AuxTriple.empty()) {
917 auto TO = std::make_shared<TargetOptions>();
918 TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
919 TO->HostTriple = getTarget().getTriple().str();
920 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
921 }
922
923 // Inform the target of the language options.
924 //
925 // FIXME: We shouldn't need to do this, the target should be immutable once
926 // created. This complexity should be lifted elsewhere.
927 getTarget().adjust(getLangOpts());
928
929 // Adjust target options based on codegen options.
930 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
931
932 // rewriter project will change target built-in bool type from its default.
933 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
934 getTarget().noSignedCharForObjCBool();
935
936 // Validate/process some options.
937 if (getHeaderSearchOpts().Verbose)
938 OS << "clang -cc1 version " CLANG_VERSION_STRING
939 << " based upon " << BACKEND_PACKAGE_STRING
940 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
941
942 if (getFrontendOpts().ShowTimers)
943 createFrontendTimer();
944
945 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
946 llvm::EnableStatistics(false);
947
948 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
949 // Reset the ID tables if we are reusing the SourceManager and parsing
950 // regular files.
951 if (hasSourceManager() && !Act.isModelParsingAction())
952 getSourceManager().clearIDTables();
953
954 if (Act.BeginSourceFile(*this, FIF)) {
955 Act.Execute();
956 Act.EndSourceFile();
957 }
958 }
959
960 // Notify the diagnostic client that all files were processed.
961 getDiagnostics().getClient()->finish();
962
963 if (getDiagnosticOpts().ShowCarets) {
964 // We can have multiple diagnostics sharing one diagnostic client.
965 // Get the total number of warnings/errors from the client.
966 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
967 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
968
969 if (NumWarnings)
970 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
971 if (NumWarnings && NumErrors)
972 OS << " and ";
973 if (NumErrors)
974 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
975 if (NumWarnings || NumErrors) {
976 OS << " generated";
977 if (getLangOpts().CUDA) {
978 if (!getLangOpts().CUDAIsDevice) {
979 OS << " when compiling for host";
980 } else {
981 OS << " when compiling for " << getTargetOpts().CPU;
982 }
983 }
984 OS << ".\n";
985 }
986 }
987
988 if (getFrontendOpts().ShowStats) {
989 if (hasFileManager()) {
990 getFileManager().PrintStats();
991 OS << '\n';
992 }
993 llvm::PrintStatistics(OS);
994 }
995 StringRef StatsFile = getFrontendOpts().StatsFile;
996 if (!StatsFile.empty()) {
997 std::error_code EC;
998 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
999 llvm::sys::fs::F_Text);
1000 if (EC) {
1001 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1002 << StatsFile << EC.message();
1003 } else {
1004 llvm::PrintStatisticsJSON(*StatS);
1005 }
1006 }
1007
1008 return !getDiagnostics().getClient()->getNumErrors();
1009 }
1010
1011 /// Determine the appropriate source input kind based on language
1012 /// options.
1013 static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
1014 if (LangOpts.OpenCL)
1015 return InputKind::OpenCL;
1016 if (LangOpts.CUDA)
1017 return InputKind::CUDA;
1018 if (LangOpts.ObjC)
1019 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1020 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1021 }
1022
1023 /// Compile a module file for the given module, using the options
1024 /// provided by the importing compiler instance. Returns true if the module
1025 /// was built without errors.
1026 static bool
1027 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1028 StringRef ModuleName, FrontendInputFile Input,
1029 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1030 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1031 [](CompilerInstance &) {},
1032 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1033 [](CompilerInstance &) {}) {
1034 // Construct a compiler invocation for creating this module.
1035 auto Invocation =
1036 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1037
1038 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1039
1040 // For any options that aren't intended to affect how a module is built,
1041 // reset them to their default values.
1042 Invocation->getLangOpts()->resetNonModularOptions();
1043 PPOpts.resetNonModularOptions();
1044
1045 // Remove any macro definitions that are explicitly ignored by the module.
1046 // They aren't supposed to affect how the module is built anyway.
1047 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1048 PPOpts.Macros.erase(
1049 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1050 [&HSOpts](const std::pair<std::string, bool> &def) {
1051 StringRef MacroDef = def.first;
1052 return HSOpts.ModulesIgnoreMacros.count(
1053 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1054 }),
1055 PPOpts.Macros.end());
1056
1057 // If the original compiler invocation had -fmodule-name, pass it through.
1058 Invocation->getLangOpts()->ModuleName =
1059 ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1060
1061 // Note the name of the module we're building.
1062 Invocation->getLangOpts()->CurrentModule = ModuleName;
1063
1064 // Make sure that the failed-module structure has been allocated in
1065 // the importing instance, and propagate the pointer to the newly-created
1066 // instance.
1067 PreprocessorOptions &ImportingPPOpts
1068 = ImportingInstance.getInvocation().getPreprocessorOpts();
1069 if (!ImportingPPOpts.FailedModules)
1070 ImportingPPOpts.FailedModules =
1071 std::make_shared<PreprocessorOptions::FailedModulesSet>();
1072 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1073
1074 // If there is a module map file, build the module using the module map.
1075 // Set up the inputs/outputs so that we build the module from its umbrella
1076 // header.
1077 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1078 FrontendOpts.OutputFile = ModuleFileName.str();
1079 FrontendOpts.DisableFree = false;
1080 FrontendOpts.GenerateGlobalModuleIndex = false;
1081 FrontendOpts.BuildingImplicitModule = true;
1082 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1083 // Force implicitly-built modules to hash the content of the module file.
1084 HSOpts.ModulesHashContent = true;
1085 FrontendOpts.Inputs = {Input};
1086
1087 // Don't free the remapped file buffers; they are owned by our caller.
1088 PPOpts.RetainRemappedFileBuffers = true;
1089
1090 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1091 assert(ImportingInstance.getInvocation().getModuleHash() ==
1092 Invocation->getModuleHash() && "Module hash mismatch!");
1093
1094 // Construct a compiler instance that will be used to actually create the
1095 // module. Since we're sharing a PCMCache,
1096 // CompilerInstance::CompilerInstance is responsible for finalizing the
1097 // buffers to prevent use-after-frees.
1098 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1099 &ImportingInstance.getPreprocessor().getPCMCache());
1100 auto &Inv = *Invocation;
1101 Instance.setInvocation(std::move(Invocation));
1102
1103 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1104 ImportingInstance.getDiagnosticClient()),
1105 /*ShouldOwnClient=*/true);
1106
1107 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1108
1109 // Note that this module is part of the module build stack, so that we
1110 // can detect cycles in the module graph.
1111 Instance.setFileManager(&ImportingInstance.getFileManager());
1112 Instance.createSourceManager(Instance.getFileManager());
1113 SourceManager &SourceMgr = Instance.getSourceManager();
1114 SourceMgr.setModuleBuildStack(
1115 ImportingInstance.getSourceManager().getModuleBuildStack());
1116 SourceMgr.pushModuleBuildStack(ModuleName,
1117 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1118
1119 // If we're collecting module dependencies, we need to share a collector
1120 // between all of the module CompilerInstances. Other than that, we don't
1121 // want to produce any dependency output from the module build.
1122 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1123 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1124
1125 ImportingInstance.getDiagnostics().Report(ImportLoc,
1126 diag::remark_module_build)
1127 << ModuleName << ModuleFileName;
1128
1129 PreBuildStep(Instance);
1130
1131 // Execute the action to actually build the module in-place. Use a separate
1132 // thread so that we get a stack large enough.
1133 llvm::CrashRecoveryContext CRC;
1134 CRC.RunSafelyOnThread(
1135 [&]() {
1136 GenerateModuleFromModuleMapAction Action;
1137 Instance.ExecuteAction(Action);
1138 },
1139 DesiredStackSize);
1140
1141 PostBuildStep(Instance);
1142
1143 ImportingInstance.getDiagnostics().Report(ImportLoc,
1144 diag::remark_module_build_done)
1145 << ModuleName;
1146
1147 // Delete the temporary module map file.
1148 // FIXME: Even though we're executing under crash protection, it would still
1149 // be nice to do this with RemoveFileOnSignal when we can. However, that
1150 // doesn't make sense for all clients, so clean this up manually.
1151 Instance.clearOutputFiles(/*EraseFiles=*/true);
1152
1153 return !Instance.getDiagnostics().hasErrorOccurred();
1154 }
1155
1156 static const FileEntry *getPublicModuleMap(const FileEntry *File,
1157 FileManager &FileMgr) {
1158 StringRef Filename = llvm::sys::path::filename(File->getName());
1159 SmallString<128> PublicFilename(File->getDir()->getName());
1160 if (Filename == "module_private.map")
1161 llvm::sys::path::append(PublicFilename, "module.map");
1162 else if (Filename == "module.private.modulemap")
1163 llvm::sys::path::append(PublicFilename, "module.modulemap");
1164 else
1165 return nullptr;
1166 return FileMgr.getFile(PublicFilename);
1167 }
1168
1169 /// Compile a module file for the given module, using the options
1170 /// provided by the importing compiler instance. Returns true if the module
1171 /// was built without errors.
1172 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1173 SourceLocation ImportLoc,
1174 Module *Module,
1175 StringRef ModuleFileName) {
1176 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1177 InputKind::ModuleMap);
1178
1179 // Get or create the module map that we'll use to build this module.
1180 ModuleMap &ModMap
1181 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1182 bool Result;
1183 if (const FileEntry *ModuleMapFile =
1184 ModMap.getContainingModuleMapFile(Module)) {
1185 // Canonicalize compilation to start with the public module map. This is
1186 // vital for submodules declarations in the private module maps to be
1187 // correctly parsed when depending on a top level module in the public one.
1188 if (const FileEntry *PublicMMFile = getPublicModuleMap(
1189 ModuleMapFile, ImportingInstance.getFileManager()))
1190 ModuleMapFile = PublicMMFile;
1191
1192 // Use the module map where this module resides.
1193 Result = compileModuleImpl(
1194 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1195 FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1196 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1197 ModuleFileName);
1198 } else {
1199 // FIXME: We only need to fake up an input file here as a way of
1200 // transporting the module's directory to the module map parser. We should
1201 // be able to do that more directly, and parse from a memory buffer without
1202 // inventing this file.
1203 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1204 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1205
1206 std::string InferredModuleMapContent;
1207 llvm::raw_string_ostream OS(InferredModuleMapContent);
1208 Module->print(OS);
1209 OS.flush();
1210
1211 Result = compileModuleImpl(
1212 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1213 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1214 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1215 ModuleFileName,
1216 [&](CompilerInstance &Instance) {
1217 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1218 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1219 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1220 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1221 Instance.getSourceManager().overrideFileContents(
1222 ModuleMapFile, std::move(ModuleMapBuffer));
1223 });
1224 }
1225
1226 // We've rebuilt a module. If we're allowed to generate or update the global
1227 // module index, record that fact in the importing compiler instance.
1228 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1229 ImportingInstance.setBuildGlobalModuleIndex(true);
1230 }
1231
1232 return Result;
1233 }
1234
1235 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1236 SourceLocation ImportLoc,
1237 SourceLocation ModuleNameLoc, Module *Module,
1238 StringRef ModuleFileName) {
1239 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1240
1241 auto diagnoseBuildFailure = [&] {
1242 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1243 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1244 };
1245
1246 // FIXME: have LockFileManager return an error_code so that we can
1247 // avoid the mkdir when the directory already exists.
1248 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1249 llvm::sys::fs::create_directories(Dir);
1250
1251 while (1) {
1252 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1253 llvm::LockFileManager Locked(ModuleFileName);
1254 switch (Locked) {
1255 case llvm::LockFileManager::LFS_Error:
1256 // PCMCache takes care of correctness and locks are only necessary for
1257 // performance. Fallback to building the module in case of any lock
1258 // related errors.
1259 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1260 << Module->Name << Locked.getErrorMessage();
1261 // Clear out any potential leftover.
1262 Locked.unsafeRemoveLockFile();
1263 LLVM_FALLTHROUGH;
1264 case llvm::LockFileManager::LFS_Owned:
1265 // We're responsible for building the module ourselves.
1266 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1267 ModuleFileName)) {
1268 diagnoseBuildFailure();
1269 return false;
1270 }
1271 break;
1272
1273 case llvm::LockFileManager::LFS_Shared:
1274 // Someone else is responsible for building the module. Wait for them to
1275 // finish.
1276 switch (Locked.waitForUnlock()) {
1277 case llvm::LockFileManager::Res_Success:
1278 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1279 break;
1280 case llvm::LockFileManager::Res_OwnerDied:
1281 continue; // try again to get the lock.
1282 case llvm::LockFileManager::Res_Timeout:
1283 // Since PCMCache takes care of correctness, we try waiting for another
1284 // process to complete the build so clang does not do it done twice. If
1285 // case of timeout, build it ourselves.
1286 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1287 << Module->Name;
1288 // Clear the lock file so that future invocations can make progress.
1289 Locked.unsafeRemoveLockFile();
1290 continue;
1291 }
1292 break;
1293 }
1294
1295 // Try to read the module file, now that we've compiled it.
1296 ASTReader::ASTReadResult ReadResult =
1297 ImportingInstance.getModuleManager()->ReadAST(
1298 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1299 ModuleLoadCapabilities);
1300
1301 if (ReadResult == ASTReader::OutOfDate &&
1302 Locked == llvm::LockFileManager::LFS_Shared) {
1303 // The module may be out of date in the presence of file system races,
1304 // or if one of its imports depends on header search paths that are not
1305 // consistent with this ImportingInstance. Try again...
1306 continue;
1307 } else if (ReadResult == ASTReader::Missing) {
1308 diagnoseBuildFailure();
1309 } else if (ReadResult != ASTReader::Success &&
1310 !Diags.hasErrorOccurred()) {
1311 // The ASTReader didn't diagnose the error, so conservatively report it.
1312 diagnoseBuildFailure();
1313 }
1314 return ReadResult == ASTReader::Success;
1315 }
1316 }
1317
1318 /// Diagnose differences between the current definition of the given
1319 /// configuration macro and the definition provided on the command line.
1320 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1321 Module *Mod, SourceLocation ImportLoc) {
1322 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1323 SourceManager &SourceMgr = PP.getSourceManager();
1324
1325 // If this identifier has never had a macro definition, then it could
1326 // not have changed.
1327 if (!Id->hadMacroDefinition())
1328 return;
1329 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1330
1331 // Find the macro definition from the command line.
1332 MacroInfo *CmdLineDefinition = nullptr;
1333 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1334 // We only care about the predefines buffer.
1335 FileID FID = SourceMgr.getFileID(MD->getLocation());
1336 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1337 continue;
1338 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1339 CmdLineDefinition = DMD->getMacroInfo();
1340 break;
1341 }
1342
1343 auto *CurrentDefinition = PP.getMacroInfo(Id);
1344 if (CurrentDefinition == CmdLineDefinition) {
1345 // Macro matches. Nothing to do.
1346 } else if (!CurrentDefinition) {
1347 // This macro was defined on the command line, then #undef'd later.
1348 // Complain.
1349 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1350 << true << ConfigMacro << Mod->getFullModuleName();
1351 auto LatestDef = LatestLocalMD->getDefinition();
1352 assert(LatestDef.isUndefined() &&
1353 "predefined macro went away with no #undef?");
1354 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1355 << true;
1356 return;
1357 } else if (!CmdLineDefinition) {
1358 // There was no definition for this macro in the predefines buffer,
1359 // but there was a local definition. Complain.
1360 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1361 << false << ConfigMacro << Mod->getFullModuleName();
1362 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1363 diag::note_module_def_undef_here)
1364 << false;
1365 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1366 /*Syntactically=*/true)) {
1367 // The macro definitions differ.
1368 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1369 << false << ConfigMacro << Mod->getFullModuleName();
1370 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1371 diag::note_module_def_undef_here)
1372 << false;
1373 }
1374 }
1375
1376 /// Write a new timestamp file with the given path.
1377 static void writeTimestampFile(StringRef TimestampFile) {
1378 std::error_code EC;
1379 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1380 }
1381
1382 /// Prune the module cache of modules that haven't been accessed in
1383 /// a long time.
1384 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1385 struct stat StatBuf;
1386 llvm::SmallString<128> TimestampFile;
1387 TimestampFile = HSOpts.ModuleCachePath;
1388 assert(!TimestampFile.empty());
1389 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1390
1391 // Try to stat() the timestamp file.
1392 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1393 // If the timestamp file wasn't there, create one now.
1394 if (errno == ENOENT) {
1395 writeTimestampFile(TimestampFile);
1396 }
1397 return;
1398 }
1399
1400 // Check whether the time stamp is older than our pruning interval.
1401 // If not, do nothing.
1402 time_t TimeStampModTime = StatBuf.st_mtime;
1403 time_t CurrentTime = time(nullptr);
1404 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1405 return;
1406
1407 // Write a new timestamp file so that nobody else attempts to prune.
1408 // There is a benign race condition here, if two Clang instances happen to
1409 // notice at the same time that the timestamp is out-of-date.
1410 writeTimestampFile(TimestampFile);
1411
1412 // Walk the entire module cache, looking for unused module files and module
1413 // indices.
1414 std::error_code EC;
1415 SmallString<128> ModuleCachePathNative;
1416 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1417 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1418 Dir != DirEnd && !EC; Dir.increment(EC)) {
1419 // If we don't have a directory, there's nothing to look into.
1420 if (!llvm::sys::fs::is_directory(Dir->path()))
1421 continue;
1422
1423 // Walk all of the files within this directory.
1424 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1425 File != FileEnd && !EC; File.increment(EC)) {
1426 // We only care about module and global module index files.
1427 StringRef Extension = llvm::sys::path::extension(File->path());
1428 if (Extension != ".pcm" && Extension != ".timestamp" &&
1429 llvm::sys::path::filename(File->path()) != "modules.idx")
1430 continue;
1431
1432 // Look at this file. If we can't stat it, there's nothing interesting
1433 // there.
1434 if (::stat(File->path().c_str(), &StatBuf))
1435 continue;
1436
1437 // If the file has been used recently enough, leave it there.
1438 time_t FileAccessTime = StatBuf.st_atime;
1439 if (CurrentTime - FileAccessTime <=
1440 time_t(HSOpts.ModuleCachePruneAfter)) {
1441 continue;
1442 }
1443
1444 // Remove the file.
1445 llvm::sys::fs::remove(File->path());
1446
1447 // Remove the timestamp file.
1448 std::string TimpestampFilename = File->path() + ".timestamp";
1449 llvm::sys::fs::remove(TimpestampFilename);
1450 }
1451
1452 // If we removed all of the files in the directory, remove the directory
1453 // itself.
1454 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1455 llvm::sys::fs::directory_iterator() && !EC)
1456 llvm::sys::fs::remove(Dir->path());
1457 }
1458 }
1459
1460 void CompilerInstance::createModuleManager() {
1461 if (!ModuleManager) {
1462 if (!hasASTContext())
1463 createASTContext();
1464
1465 // If we're implicitly building modules but not currently recursively
1466 // building a module, check whether we need to prune the module cache.
1467 if (getSourceManager().getModuleBuildStack().empty() &&
1468 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1469 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1470 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1471 pruneModuleCache(getHeaderSearchOpts());
1472 }
1473
1474 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1475 std::string Sysroot = HSOpts.Sysroot;
1476 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1477 std::unique_ptr<llvm::Timer> ReadTimer;
1478 if (FrontendTimerGroup)
1479 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1480 "Reading modules",
1481 *FrontendTimerGroup);
1482 ModuleManager = new ASTReader(
1483 getPreprocessor(), &getASTContext(), getPCHContainerReader(),
1484 getFrontendOpts().ModuleFileExtensions,
1485 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1486 /*AllowASTWithCompilerErrors=*/false,
1487 /*AllowConfigurationMismatch=*/false,
1488 HSOpts.ModulesValidateSystemHeaders,
1489 getFrontendOpts().UseGlobalModuleIndex,
1490 std::move(ReadTimer));
1491 if (hasASTConsumer()) {
1492 ModuleManager->setDeserializationListener(
1493 getASTConsumer().GetASTDeserializationListener());
1494 getASTContext().setASTMutationListener(
1495 getASTConsumer().GetASTMutationListener());
1496 }
1497 getASTContext().setExternalSource(ModuleManager);
1498 if (hasSema())
1499 ModuleManager->InitializeSema(getSema());
1500 if (hasASTConsumer())
1501 ModuleManager->StartTranslationUnit(&getASTConsumer());
1502
1503 if (TheDependencyFileGenerator)
1504 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1505 for (auto &Listener : DependencyCollectors)
1506 Listener->attachToASTReader(*ModuleManager);
1507 }
1508 }
1509
1510 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1511 llvm::Timer Timer;
1512 if (FrontendTimerGroup)
1513 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1514 *FrontendTimerGroup);
1515 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1516
1517 // Helper to recursively read the module names for all modules we're adding.
1518 // We mark these as known and redirect any attempt to load that module to
1519 // the files we were handed.
1520 struct ReadModuleNames : ASTReaderListener {
1521 CompilerInstance &CI;
1522 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
1523
1524 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1525
1526 void ReadModuleName(StringRef ModuleName) override {
1527 LoadedModules.push_back(
1528 CI.getPreprocessor().getIdentifierInfo(ModuleName));
1529 }
1530
1531 void registerAll() {
1532 for (auto *II : LoadedModules) {
1533 CI.KnownModules[II] = CI.getPreprocessor()
1534 .getHeaderSearchInfo()
1535 .getModuleMap()
1536 .findModule(II->getName());
1537 }
1538 LoadedModules.clear();
1539 }
1540
1541 void markAllUnavailable() {
1542 for (auto *II : LoadedModules) {
1543 if (Module *M = CI.getPreprocessor()
1544 .getHeaderSearchInfo()
1545 .getModuleMap()
1546 .findModule(II->getName())) {
1547 M->HasIncompatibleModuleFile = true;
1548
1549 // Mark module as available if the only reason it was unavailable
1550 // was missing headers.
1551 SmallVector<Module *, 2> Stack;
1552 Stack.push_back(M);
1553 while (!Stack.empty()) {
1554 Module *Current = Stack.pop_back_val();
1555 if (Current->IsMissingRequirement) continue;
1556 Current->IsAvailable = true;
1557 Stack.insert(Stack.end(),
1558 Current->submodule_begin(), Current->submodule_end());
1559 }
1560 }
1561 }
1562 LoadedModules.clear();
1563 }
1564 };
1565
1566 // If we don't already have an ASTReader, create one now.
1567 if (!ModuleManager)
1568 createModuleManager();
1569
1570 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1571 // ASTReader to diagnose it, since it can produce better errors that we can.
1572 bool ConfigMismatchIsRecoverable =
1573 getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1574 SourceLocation())
1575 <= DiagnosticsEngine::Warning;
1576
1577 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1578 auto &ListenerRef = *Listener;
1579 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1580 std::move(Listener));
1581
1582 // Try to load the module file.
1583 switch (ModuleManager->ReadAST(
1584 FileName, serialization::MK_ExplicitModule, SourceLocation(),
1585 ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) {
1586 case ASTReader::Success:
1587 // We successfully loaded the module file; remember the set of provided
1588 // modules so that we don't try to load implicit modules for them.
1589 ListenerRef.registerAll();
1590 return true;
1591
1592 case ASTReader::ConfigurationMismatch:
1593 // Ignore unusable module files.
1594 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1595 << FileName;
1596 // All modules provided by any files we tried and failed to load are now
1597 // unavailable; includes of those modules should now be handled textually.
1598 ListenerRef.markAllUnavailable();
1599 return true;
1600
1601 default:
1602 return false;
1603 }
1604 }
1605
1606 ModuleLoadResult
1607 CompilerInstance::loadModule(SourceLocation ImportLoc,
1608 ModuleIdPath Path,
1609 Module::NameVisibilityKind Visibility,
1610 bool IsInclusionDirective) {
1611 // Determine what file we're searching from.
1612 StringRef ModuleName = Path[0].first->getName();
1613 SourceLocation ModuleNameLoc = Path[0].second;
1614
1615 // If we've already handled this import, just return the cached result.
1616 // This one-element cache is important to eliminate redundant diagnostics
1617 // when both the preprocessor and parser see the same import declaration.
1618 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1619 // Make the named module visible.
1620 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1621 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1622 ImportLoc);
1623 return LastModuleImportResult;
1624 }
1625
1626 clang::Module *Module = nullptr;
1627
1628 // If we don't already have information on this module, load the module now.
1629 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1630 = KnownModules.find(Path[0].first);
1631 if (Known != KnownModules.end()) {
1632 // Retrieve the cached top-level module.
1633 Module = Known->second;
1634 } else if (ModuleName == getLangOpts().CurrentModule) {
1635 // This is the module we're building.
1636 Module = PP->getHeaderSearchInfo().lookupModule(
1637 ModuleName, /*AllowSearch*/ true,
1638 /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
1639 /// FIXME: perhaps we should (a) look for a module using the module name
1640 // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1641 //if (Module == nullptr) {
1642 // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1643 // << ModuleName;
1644 // ModuleBuildFailed = true;
1645 // return ModuleLoadResult();
1646 //}
1647 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1648 } else {
1649 // Search for a module with the given name.
1650 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1651 !IsInclusionDirective);
1652 HeaderSearchOptions &HSOpts =
1653 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1654
1655 std::string ModuleFileName;
1656 enum ModuleSource {
1657 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1658 } Source = ModuleNotFound;
1659
1660 // Check to see if the module has been built as part of this compilation
1661 // via a module build pragma.
1662 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1663 if (BuiltModuleIt != BuiltModules.end()) {
1664 ModuleFileName = BuiltModuleIt->second;
1665 Source = ModuleBuildPragma;
1666 }
1667
1668 // Try to load the module from the prebuilt module path.
1669 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1670 !HSOpts.PrebuiltModulePaths.empty())) {
1671 ModuleFileName =
1672 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1673 if (!ModuleFileName.empty())
1674 Source = PrebuiltModulePath;
1675 }
1676
1677 // Try to load the module from the module cache.
1678 if (Source == ModuleNotFound && Module) {
1679 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1680 Source = ModuleCache;
1681 }
1682
1683 if (Source == ModuleNotFound) {
1684 // We can't find a module, error out here.
1685 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1686 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1687 ModuleBuildFailed = true;
1688 return ModuleLoadResult();
1689 }
1690
1691 if (ModuleFileName.empty()) {
1692 if (Module && Module->HasIncompatibleModuleFile) {
1693 // We tried and failed to load a module file for this module. Fall
1694 // back to textual inclusion for its headers.
1695 return ModuleLoadResult::ConfigMismatch;
1696 }
1697
1698 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1699 << ModuleName;
1700 ModuleBuildFailed = true;
1701 return ModuleLoadResult();
1702 }
1703
1704 // If we don't already have an ASTReader, create one now.
1705 if (!ModuleManager)
1706 createModuleManager();
1707
1708 llvm::Timer Timer;
1709 if (FrontendTimerGroup)
1710 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1711 *FrontendTimerGroup);
1712 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1713
1714 // Try to load the module file. If we are not trying to load from the
1715 // module cache, we don't know how to rebuild modules.
1716 unsigned ARRFlags = Source == ModuleCache ?
1717 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing :
1718 Source == PrebuiltModulePath ?
1719 0 :
1720 ASTReader::ARR_ConfigurationMismatch;
1721 switch (ModuleManager->ReadAST(ModuleFileName,
1722 Source == PrebuiltModulePath
1723 ? serialization::MK_PrebuiltModule
1724 : Source == ModuleBuildPragma
1725 ? serialization::MK_ExplicitModule
1726 : serialization::MK_ImplicitModule,
1727 ImportLoc, ARRFlags)) {
1728 case ASTReader::Success: {
1729 if (Source != ModuleCache && !Module) {
1730 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1731 !IsInclusionDirective);
1732 if (!Module || !Module->getASTFile() ||
1733 FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1734 // Error out if Module does not refer to the file in the prebuilt
1735 // module path.
1736 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1737 << ModuleName;
1738 ModuleBuildFailed = true;
1739 KnownModules[Path[0].first] = nullptr;
1740 return ModuleLoadResult();
1741 }
1742 }
1743 break;
1744 }
1745
1746 case ASTReader::OutOfDate:
1747 case ASTReader::Missing: {
1748 if (Source != ModuleCache) {
1749 // We don't know the desired configuration for this module and don't
1750 // necessarily even have a module map. Since ReadAST already produces
1751 // diagnostics for these two cases, we simply error out here.
1752 ModuleBuildFailed = true;
1753 KnownModules[Path[0].first] = nullptr;
1754 return ModuleLoadResult();
1755 }
1756
1757 // The module file is missing or out-of-date. Build it.
1758 assert(Module && "missing module file");
1759 // Check whether there is a cycle in the module graph.
1760 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1761 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1762 for (; Pos != PosEnd; ++Pos) {
1763 if (Pos->first == ModuleName)
1764 break;
1765 }
1766
1767 if (Pos != PosEnd) {
1768 SmallString<256> CyclePath;
1769 for (; Pos != PosEnd; ++Pos) {
1770 CyclePath += Pos->first;
1771 CyclePath += " -> ";
1772 }
1773 CyclePath += ModuleName;
1774
1775 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1776 << ModuleName << CyclePath;
1777 return ModuleLoadResult();
1778 }
1779
1780 // Check whether we have already attempted to build this module (but
1781 // failed).
1782 if (getPreprocessorOpts().FailedModules &&
1783 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1784 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1785 << ModuleName
1786 << SourceRange(ImportLoc, ModuleNameLoc);
1787 ModuleBuildFailed = true;
1788 return ModuleLoadResult();
1789 }
1790
1791 // Try to compile and then load the module.
1792 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1793 ModuleFileName)) {
1794 assert(getDiagnostics().hasErrorOccurred() &&
1795 "undiagnosed error in compileAndLoadModule");
1796 if (getPreprocessorOpts().FailedModules)
1797 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1798 KnownModules[Path[0].first] = nullptr;
1799 ModuleBuildFailed = true;
1800 return ModuleLoadResult();
1801 }
1802
1803 // Okay, we've rebuilt and now loaded the module.
1804 break;
1805 }
1806
1807 case ASTReader::ConfigurationMismatch:
1808 if (Source == PrebuiltModulePath)
1809 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1810 // produce a warning here!
1811 getDiagnostics().Report(SourceLocation(),
1812 diag::warn_module_config_mismatch)
1813 << ModuleFileName;
1814 // Fall through to error out.
1815 LLVM_FALLTHROUGH;
1816 case ASTReader::VersionMismatch:
1817 case ASTReader::HadErrors:
1818 ModuleLoader::HadFatalFailure = true;
1819 // FIXME: The ASTReader will already have complained, but can we shoehorn
1820 // that diagnostic information into a more useful form?
1821 KnownModules[Path[0].first] = nullptr;
1822 return ModuleLoadResult();
1823
1824 case ASTReader::Failure:
1825 ModuleLoader::HadFatalFailure = true;
1826 // Already complained, but note now that we failed.
1827 KnownModules[Path[0].first] = nullptr;
1828 ModuleBuildFailed = true;
1829 return ModuleLoadResult();
1830 }
1831
1832 // Cache the result of this top-level module lookup for later.
1833 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1834 }
1835
1836 // If we never found the module, fail.
1837 if (!Module)
1838 return ModuleLoadResult();
1839
1840 // Verify that the rest of the module path actually corresponds to
1841 // a submodule.
1842 bool MapPrivateSubModToTopLevel = false;
1843 if (Path.size() > 1) {
1844 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1845 StringRef Name = Path[I].first->getName();
1846 clang::Module *Sub = Module->findSubmodule(Name);
1847
1848 // If the user is requesting Foo.Private and it doesn't exist, try to
1849 // match Foo_Private and emit a warning asking for the user to write
1850 // @import Foo_Private instead. FIXME: remove this when existing clients
1851 // migrate off of Foo.Private syntax.
1852 if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1853 Module == Module->getTopLevelModule()) {
1854 SmallString<128> PrivateModule(Module->Name);
1855 PrivateModule.append("_Private");
1856
1857 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
1858 auto &II = PP->getIdentifierTable().get(
1859 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1860 PrivPath.push_back(std::make_pair(&II, Path[0].second));
1861
1862 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
1863 !IsInclusionDirective))
1864 Sub =
1865 loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1866 if (Sub) {
1867 MapPrivateSubModToTopLevel = true;
1868 if (!getDiagnostics().isIgnored(
1869 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1870 getDiagnostics().Report(Path[I].second,
1871 diag::warn_no_priv_submodule_use_toplevel)
1872 << Path[I].first << Module->getFullModuleName() << PrivateModule
1873 << SourceRange(Path[0].second, Path[I].second)
1874 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1875 PrivateModule);
1876 getDiagnostics().Report(Sub->DefinitionLoc,
1877 diag::note_private_top_level_defined);
1878 }
1879 }
1880 }
1881
1882 if (!Sub) {
1883 // Attempt to perform typo correction to find a module name that works.
1884 SmallVector<StringRef, 2> Best;
1885 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1886
1887 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1888 JEnd = Module->submodule_end();
1889 J != JEnd; ++J) {
1890 unsigned ED = Name.edit_distance((*J)->Name,
1891 /*AllowReplacements=*/true,
1892 BestEditDistance);
1893 if (ED <= BestEditDistance) {
1894 if (ED < BestEditDistance) {
1895 Best.clear();
1896 BestEditDistance = ED;
1897 }
1898
1899 Best.push_back((*J)->Name);
1900 }
1901 }
1902
1903 // If there was a clear winner, user it.
1904 if (Best.size() == 1) {
1905 getDiagnostics().Report(Path[I].second,
1906 diag::err_no_submodule_suggest)
1907 << Path[I].first << Module->getFullModuleName() << Best[0]
1908 << SourceRange(Path[0].second, Path[I-1].second)
1909 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1910 Best[0]);
1911
1912 Sub = Module->findSubmodule(Best[0]);
1913 }
1914 }
1915
1916 if (!Sub) {
1917 // No submodule by this name. Complain, and don't look for further
1918 // submodules.
1919 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1920 << Path[I].first << Module->getFullModuleName()
1921 << SourceRange(Path[0].second, Path[I-1].second);
1922 break;
1923 }
1924
1925 Module = Sub;
1926 }
1927 }
1928
1929 // Make the named module visible, if it's not already part of the module
1930 // we are parsing.
1931 if (ModuleName != getLangOpts().CurrentModule) {
1932 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1933 // We have an umbrella header or directory that doesn't actually include
1934 // all of the headers within the directory it covers. Complain about
1935 // this missing submodule and recover by forgetting that we ever saw
1936 // this submodule.
1937 // FIXME: Should we detect this at module load time? It seems fairly
1938 // expensive (and rare).
1939 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1940 << Module->getFullModuleName()
1941 << SourceRange(Path.front().second, Path.back().second);
1942
1943 return ModuleLoadResult::MissingExpected;
1944 }
1945
1946 // Check whether this module is available.
1947 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1948 getDiagnostics(), Module)) {
1949 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1950 << SourceRange(Path.front().second, Path.back().second);
1951 LastModuleImportLoc = ImportLoc;
1952 LastModuleImportResult = ModuleLoadResult();
1953 return ModuleLoadResult();
1954 }
1955
1956 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1957 }
1958
1959 // Check for any configuration macros that have changed.
1960 clang::Module *TopModule = Module->getTopLevelModule();
1961 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1962 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1963 Module, ImportLoc);
1964 }
1965
1966 // Resolve any remaining module using export_as for this one.
1967 getPreprocessor()
1968 .getHeaderSearchInfo()
1969 .getModuleMap()
1970 .resolveLinkAsDependencies(TopModule);
1971
1972 LastModuleImportLoc = ImportLoc;
1973 LastModuleImportResult = ModuleLoadResult(Module);
1974 return LastModuleImportResult;
1975 }
1976
1977 void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1978 StringRef ModuleName,
1979 StringRef Source) {
1980 // Avoid creating filenames with special characters.
1981 SmallString<128> CleanModuleName(ModuleName);
1982 for (auto &C : CleanModuleName)
1983 if (!isAlphanumeric(C))
1984 C = '_';
1985
1986 // FIXME: Using a randomized filename here means that our intermediate .pcm
1987 // output is nondeterministic (as .pcm files refer to each other by name).
1988 // Can this affect the output in any way?
1989 SmallString<128> ModuleFileName;
1990 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1991 CleanModuleName, "pcm", ModuleFileName)) {
1992 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
1993 << ModuleFileName << EC.message();
1994 return;
1995 }
1996 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
1997
1998 FrontendInputFile Input(
1999 ModuleMapFileName,
2000 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2001 InputKind::ModuleMap, /*Preprocessed*/true));
2002
2003 std::string NullTerminatedSource(Source.str());
2004
2005 auto PreBuildStep = [&](CompilerInstance &Other) {
2006 // Create a virtual file containing our desired source.
2007 // FIXME: We shouldn't need to do this.
2008 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2009 ModuleMapFileName, NullTerminatedSource.size(), 0);
2010 Other.getSourceManager().overrideFileContents(
2011 ModuleMapFile,
2012 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2013
2014 Other.BuiltModules = std::move(BuiltModules);
2015 Other.DeleteBuiltModules = false;
2016 };
2017
2018 auto PostBuildStep = [this](CompilerInstance &Other) {
2019 BuiltModules = std::move(Other.BuiltModules);
2020 };
2021
2022 // Build the module, inheriting any modules that we've built locally.
2023 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2024 ModuleFileName, PreBuildStep, PostBuildStep)) {
2025 BuiltModules[ModuleName] = ModuleFileName.str();
2026 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2027 }
2028 }
2029
2030 void CompilerInstance::makeModuleVisible(Module *Mod,
2031 Module::NameVisibilityKind Visibility,
2032 SourceLocation ImportLoc) {
2033 if (!ModuleManager)
2034 createModuleManager();
2035 if (!ModuleManager)
2036 return;
2037
2038 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2039 }
2040
2041 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2042 SourceLocation TriggerLoc) {
2043 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2044 return nullptr;
2045 if (!ModuleManager)
2046 createModuleManager();
2047 // Can't do anything if we don't have the module manager.
2048 if (!ModuleManager)
2049 return nullptr;
2050 // Get an existing global index. This loads it if not already
2051 // loaded.
2052 ModuleManager->loadGlobalIndex();
2053 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2054 // If the global index doesn't exist, create it.
2055 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2056 hasPreprocessor()) {
2057 llvm::sys::fs::create_directories(
2058 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2059 GlobalModuleIndex::writeIndex(
2060 getFileManager(), getPCHContainerReader(),
2061 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2062 ModuleManager->resetForReload();
2063 ModuleManager->loadGlobalIndex();
2064 GlobalIndex = ModuleManager->getGlobalIndex();
2065 }
2066 // For finding modules needing to be imported for fixit messages,
2067 // we need to make the global index cover all modules, so we do that here.
2068 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2069 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2070 bool RecreateIndex = false;
2071 for (ModuleMap::module_iterator I = MMap.module_begin(),
2072 E = MMap.module_end(); I != E; ++I) {
2073 Module *TheModule = I->second;
2074 const FileEntry *Entry = TheModule->getASTFile();
2075 if (!Entry) {
2076 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2077 Path.push_back(std::make_pair(
2078 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2079 std::reverse(Path.begin(), Path.end());
2080 // Load a module as hidden. This also adds it to the global index.
2081 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2082 RecreateIndex = true;
2083 }
2084 }
2085 if (RecreateIndex) {
2086 GlobalModuleIndex::writeIndex(
2087 getFileManager(), getPCHContainerReader(),
2088 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2089 ModuleManager->resetForReload();
2090 ModuleManager->loadGlobalIndex();
2091 GlobalIndex = ModuleManager->getGlobalIndex();
2092 }
2093 HaveFullGlobalModuleIndex = true;
2094 }
2095 return GlobalIndex;
2096 }
2097
2098 // Check global module index for missing imports.
2099 bool
2100 CompilerInstance::lookupMissingImports(StringRef Name,
2101 SourceLocation TriggerLoc) {
2102 // Look for the symbol in non-imported modules, but only if an error
2103 // actually occurred.
2104 if (!buildingModule()) {
2105 // Load global module index, or retrieve a previously loaded one.
2106 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2107 TriggerLoc);
2108
2109 // Only if we have a global index.
2110 if (GlobalIndex) {
2111 GlobalModuleIndex::HitSet FoundModules;
2112
2113 // Find the modules that reference the identifier.
2114 // Note that this only finds top-level modules.
2115 // We'll let diagnoseTypo find the actual declaration module.
2116 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2117 return true;
2118 }
2119 }
2120
2121 return false;
2122 }
2123 void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(takeSema()); }
2124
2125 void CompilerInstance::setExternalSemaSource(
2126 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2127 ExternalSemaSrc = std::move(ESS);
2128 }
clang::FrontendOptions::OutputFile
std::string OutputFile
The output file, if any.
Definition: FrontendOptions.h:382
clang::Module::IsAvailable
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:213
clang::ASTContext::setExternalSource
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:921
compileAndLoadModule
static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)
Definition: CompilerInstance.cpp:1235
ASTContext.h
Defines the clang::ASTContext interface.
clang::CompilerInstance::getLangOpts
LangOptions & getLangOpts()
Definition: CompilerInstance.h:310
clang::ASTReader::ASTReadResult
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:381
clang::FrontendOptions::OriginalModuleMap
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred...
Definition: FrontendOptions.h:379
clang::Module::Name
std::string Name
The name of this module.
Definition: Module.h:68
clang::CompilerInstance::getInvocation
CompilerInvocation & getInvocation()
Definition: CompilerInstance.h:240
clang::CompilerInstance::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInstance.h:317
clang::CompilerInstance::createCodeCompletionConsumer
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
Definition: CompilerInstance.cpp:581
clang::DiagnosticsEngine::hasErrorOccurred
bool hasErrorOccurred() const
Definition: Diagnostic.h:747
clang::DependencyOutputOptions::ModuleDependencyOutputDir
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
Definition: DependencyOutputOptions.h:65
FrontendActions.h
clang::DiagnosticsEngine::getClient
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:510
clang::CodeGenOptions::DwarfDebugFlags
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
Definition: CodeGenOptions.h:149
clang::HeaderSearchOptions::PrebuiltModulePaths
std::vector< std::string > PrebuiltModulePaths
The directories used to load prebuilt module files.
Definition: HeaderSearchOptions.h:121
clang::Preprocessor::getSelectorTable
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:825
clang::DependencyOutputOptions::DOTOutputFile
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
Definition: DependencyOutputOptions.h:62
clang::Module::submodule_iterator
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:553
clang::VerifyDiagnosticConsumer
VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to c...
Definition: VerifyDiagnosticConsumer.h:147
clang::CompilerInstance::createFrontendTimer
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
Definition: CompilerInstance.cpp:604
clang::PreprocessorOptions::RemappedFilesKeepOriginalName
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
Definition: PreprocessorOptions.h:125
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:121
clang::Preprocessor::getIdentifierInfo
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:1066
clang::TargetInfo::adjust
virtual void adjust(LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:325
clang::CompilerInstance::setCodeCompletionConsumer
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...
Definition: CompilerInstance.cpp:128
FileManager.h
Defines the clang::FileManager interface and associated types.
clang::FrontendAction::EndSourceFile
void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
Definition: FrontendAction.cpp:951
clang::Preprocessor::getPCMCache
MemoryBufferCache & getPCMCache() const
Definition: Preprocessor.h:820
clang::CompilerInstance::createDiagnostics
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation&#39;s diagnostic options and replace any existing one ...
Definition: CompilerInstance.cpp:262
clang::Module::submodule_begin
submodule_iterator submodule_begin()
Definition: Module.h:556
writeTimestampFile
static void writeTimestampFile(StringRef TimestampFile)
Write a new timestamp file with the given path.
Definition: CompilerInstance.cpp:1377
clang::ASTFrontendAction::ExecuteAction
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
Definition: FrontendAction.cpp:1017
clang::InputKind::getFormat
Format getFormat() const
Definition: FrontendOptions.h:180
clang::TargetInfo::getTriple
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:953
clang::ModuleLoader::buildingModule
bool buildingModule() const
Returns true if this instance is building a module.
Definition: ModuleLoader.h:85
clang::Module::getTopLevelModule
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:451
SourceManager.h
Defines the SourceManager interface.
clang::CompilerInstance::createSema
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Definition: CompilerInstance.cpp:626
clang::Preprocessor::getFileManager
FileManager & getFileManager() const
Definition: Preprocessor.h:818
clang::CompilerInstance::getPCHContainerOperations
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Definition: CompilerInstance.h:529
clang::FrontendAction
Abstract base class for actions which can be performed by the frontend.
Definition: FrontendAction.h:36
clang::ModuleMap::getModuleMapFileForUniquing
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp:1214
clang::CompilerInstance::getDiagnosticOpts
DiagnosticOptions & getDiagnosticOpts()
Definition: CompilerInstance.h:279
clang::DependencyOutputOptions::HeaderIncludeOutputFile
std::string HeaderIncludeOutputFile
The file to write header include output to.
Definition: DependencyOutputOptions.h:49
clang::CompilerInstance::getHeaderSearchOptsPtr
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
Definition: CompilerInstance.h:306
clang::Module::getASTFile
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:466
CodeCompleteConsumer.h
ASTReader.h
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1295
clang::CompilerInstance::InitializeSourceManager
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file...
Definition: CompilerInstance.cpp:817
HeaderSearch.h
clang::CompilerInstance::setAuxTarget
void setAuxTarget(TargetInfo *Value)
Replace the current AuxTarget.
Definition: CompilerInstance.cpp:92
clang::ChainedDiagnosticConsumer
ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client a...
Definition: ChainedDiagnosticConsumer.h:23
clang::ModuleMap::module_iterator
llvm::StringMap< Module * >::const_iterator module_iterator
Definition: ModuleMap.h:680
clang::PreprocessorOptions
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Definition: PreprocessorOptions.h:43
clang::PreprocessorOptions::FailedModules
std::shared_ptr< FailedModulesSet > FailedModules
The set of modules that failed to build.
Definition: PreprocessorOptions.h:171
clang::DiagnosticsEngine::takeClient
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:518
clang::CompilerInstance::getASTContext
ASTContext & getASTContext() const
Definition: CompilerInstance.h:469
clang::ASTReader::ARR_OutOfDate
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
Definition: ASTReader.h:1516
clang::CompilerInstance::setModuleManager
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
Definition: CompilerInstance.cpp:139
Value
Value
Definition: UninitializedValues.cpp:102
clang::ASTReader::HadErrors
The AST file has errors.
Definition: ASTReader.h:404
clang::TargetInfo::adjustTargetOptions
virtual void adjustTargetOptions(const CodeGenOptions &CGOpts, TargetOptions &TargetOpts) const
Adjust target options based on codegen options.
Definition: TargetInfo.h:1007
clang::CompilerInstance::setSourceManager
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
Definition: CompilerInstance.cpp:102
clang::SrcMgr::C_System
Definition: SourceManager.h:79
Sema.h
clang::HeaderSearchOptions::ModulesIgnoreMacros
llvm::SmallSetVector< llvm::CachedHashString, 16 > ModulesIgnoreMacros
The set of macro names that should be ignored for the purposes of computing the module hash...
Definition: HeaderSearchOptions.h:171
clang::MemoryBufferCache
Manage memory buffers across multiple users.
Definition: MemoryBufferCache.h:32
clang::DiagnosticConsumer
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1488
clang::CompilerInstance::getDependencyOutputOpts
DependencyOutputOptions & getDependencyOutputOpts()
Definition: CompilerInstance.h:272
clang::SrcMgr::CharacteristicKind
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:655
clang::HeaderSearchOptions::ModuleCachePath
std::string ModuleCachePath
The directory used for the module cache.
Definition: HeaderSearchOptions.h:112
clang::Preprocessor::getBuiltinInfo
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:826
clang::Preprocessor::setPredefines
void setPredefines(const char *P)
Set the predefines for this Preprocessor.
Definition: Preprocessor.h:1061
normalize
float __ovld __cnfn normalize(float p)
Returns a vector in the same direction as p but with a length of 1.
compileModuleImpl
static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, StringRef ModuleName, FrontendInputFile Input, StringRef OriginalModuleMapFile, StringRef ModuleFileName, llvm::function_ref< void(CompilerInstance &)> PreBuildStep=[](CompilerInstance &) {}, llvm::function_ref< void(CompilerInstance &)> PostBuildStep=[](CompilerInstance &) {})
Compile a module file for the given module, using the options provided by the importing compiler inst...
Definition: CompilerInstance.cpp:1027
clang::ASTReader::ARR_Missing
The client can handle an AST file that cannot load because it is missing.
Definition: ASTReader.h:1512
clang::CompilerInstance::setExternalSemaSource
void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)
Definition: CompilerInstance.cpp:2125
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:58
clang::SourceManager::setMainFileID
void setMainFileID(FileID FID)
Set the file ID for the main source file.
Definition: SourceManager.h:796
clang::DiagnosticsEngine::setClient
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:100
SetupSerializedDiagnostics
static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)
Definition: CompilerInstance.cpp:247
clang::InputKind::CXX
Definition: FrontendOptions.h:158
clang::CompilerInstance::loadModuleFromSource
void loadModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) override
Attempt to load the given module from the specified source buffer.
Definition: CompilerInstance.cpp:1977
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
clang::FrontendAction::BeginSourceFile
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
Definition: FrontendAction.cpp:537
clang::CompilerInstance::createSourceManager
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
Definition: CompilerInstance.cpp:316
collectHeaderMaps
static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr< ModuleDependencyCollector > MDC)
Definition: CompilerInstance.cpp:155
clang::DependencyOutputOptions::ShowIncludesDest
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
Definition: DependencyOutputOptions.h:37
clang::DiagnosticConsumer::getNumErrors
unsigned getNumErrors() const
Definition: Diagnostic.h:1497
std
Definition: Format.h:2072
clang::ParsedSourceLocation
A source location that has been parsed on the command line.
Definition: CommandLineSourceLoc.h:25
clang::GlobalModuleIndex::HitSet
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
Definition: GlobalModuleIndex.h:166
clang::CompilerInstance::setASTContext
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
Definition: CompilerInstance.cpp:110
clang::CompilerInstance::getCodeGenOpts
CodeGenOptions & getCodeGenOpts()
Definition: CompilerInstance.h:265
clang::ShowIncludesDestination::None
clang::ASTReader::ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1525
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
clang::FrontendOptions::BuildingImplicitModule
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
Definition: FrontendOptions.h:298
clang::Module
Describes a module or submodule.
Definition: Module.h:65
clang::InputKind::C
Languages that the frontend can parse and compile.
Definition: FrontendOptions.h:157
clang::CompilerInstance::makeModuleVisible
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override
Make the given module visible.
Definition: CompilerInstance.cpp:2030
clang::Preprocessor::SetCodeCompletionPoint
bool SetCodeCompletionPoint(const FileEntry *File, unsigned Line, unsigned Column)
Specify the point at which code-completion will be performed.
Definition: Preprocessor.cpp:381
ChainedDiagnosticConsumer.h
clang::Module::getTopLevelModuleName
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:461
clang::FileID::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:47
clang::ModuleMap::findModule
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
Definition: ModuleMap.cpp:765
clang::CompilerInstance::getPCMCache
MemoryBufferCache & getPCMCache() const
Definition: CompilerInstance.h:817
clang::make_error_code
std::error_code make_error_code(BuildPreambleError Error)
Definition: PrecompiledPreamble.cpp:749
clang::CompilerInstance::setBuildGlobalModuleIndex
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
Definition: CompilerInstance.h:253
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:214
clang::SourceManager::getModuleBuildStack
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
Definition: SourceManager.h:773
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
clang::CompilerInstance::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInstance.h:293
clang::Visibility
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:34
clang::HeaderSearchOptions::VFSOverlayFiles
std::vector< std::string > VFSOverlayFiles
The set of user-provided virtual filesystem overlay files.
Definition: HeaderSearchOptions.h:174
clang::CompilerInstance::getPreprocessorOutputOpts
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Definition: CompilerInstance.h:324
clang::ModuleLoadResult::ConfigMismatch
Definition: ModuleLoader.h:48
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
clang::CompilerInstance::getASTConsumer
ASTConsumer & getASTConsumer() const
Definition: CompilerInstance.h:492
Diagnostic.h
Defines the Diagnostic-related interfaces.
clang::HeaderSearchOptions::ModulesHashContent
unsigned ModulesHashContent
Definition: HeaderSearchOptions.h:204
clang::PreprocessorOptions::RetainRemappedFileBuffers
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
Definition: PreprocessorOptions.h:144
clang::ParsedSourceLocation::Column
unsigned Column
Definition: CommandLineSourceLoc.h:28
clang::CompilerInstance::setASTConsumer
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value...
Definition: CompilerInstance.cpp:121
clang::Module::IsFromModuleFile
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:216
clang::Module::submodule_end
submodule_iterator submodule_end()
Definition: Module.h:558
Utils.h
clang::CompilerInstance::hasASTConsumer
bool hasASTConsumer() const
Definition: CompilerInstance.h:490
clang::FrontendInputFile::getKind
InputKind getKind() const
Definition: FrontendOptions.h:222
clang::CompilerInstance::setFileManager
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
Definition: CompilerInstance.cpp:94
clang::HeaderSearchOptions::DisableModuleHash
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
Definition: HeaderSearchOptions.h:130
clang::CompilerInstance::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInstance.h:300
clang::PCHContainerReader
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Definition: PCHContainerOperations.h:58
checkConfigMacro
static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc)
Diagnose differences between the current definition of the given configuration macro and the definiti...
Definition: CompilerInstance.cpp:1320
clang::CompilerInstance::getModuleDepCollector
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
Definition: CompilerInstance.cpp:146
llvm::ArrayRef
Definition: LLVM.h:32
clang::ASTReader::Failure
The AST file itself appears corrupted.
Definition: ASTReader.h:387
llvm::SmallString
Definition: LLVM.h:35
clang::PreprocessorOptions::DisablePCHValidation
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
Definition: PreprocessorOptions.h:82
clang::DependencyFileGenerator
Builds a depdenency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
Definition: Utils.h:119
FrontendDiagnostic.h
clang::CompilerInstance::getVirtualFileSystem
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: CompilerInstance.h:388
clang::ParsedSourceLocation::Line
unsigned Line
Definition: CommandLineSourceLoc.h:27
clang::CompilerInstance::createPCHExternalASTSource
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
Definition: CompilerInstance.cpp:487
clang::PreprocessorOptions::RemappedFileBuffers
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
Definition: PreprocessorOptions.h:136
clang::HeaderSearch
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
clang::ModuleMap::getContainingModuleMapFile
const FileEntry * getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
Definition: ModuleMap.cpp:1206
clang::CompilerInstance::getSema
Sema & getSema() const
Definition: CompilerInstance.h:510
clang::Module::IsSystem
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:226
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::PreprocessorOptions::DetailedRecord
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
Definition: PreprocessorOptions.h:55
clang::FileManager::getFile
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Definition: FileManager.cpp:183
clang::DependencyFileGenerator::CreateAndAttachToPreprocessor
static DependencyFileGenerator * CreateAndAttachToPreprocessor(Preprocessor &PP, const DependencyOutputOptions &Opts)
Definition: DependencyFile.cpp:245
llvm::str
return Out str()
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
CharInfo.h
CompilerInstance.h
SetUpDiagnosticLog
static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)
Definition: CompilerInstance.cpp:216
clang::LangOptions::CurrentModule
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:227
clang::FileManager::getDirectory
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
Definition: FileManager.cpp:119
clang::Module::findSubmodule
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:317
clang::ModuleLoadResult
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:36
Filename
StringRef Filename
Definition: Format.cpp:1629
clang::FileID::isValid
bool isValid() const
Definition: SourceLocation.h:46
clang::GlobalModuleIndex::lookupIdentifier
bool lookupIdentifier(llvm::StringRef Name, HitSet &Hits)
Look for all of the module files with information about the given identifier, e.g., a global function, variable, or type with that name.
Definition: GlobalModuleIndex.cpp:290
clang::ModuleMap
Definition: ModuleMap.h:75
clang::CompilerInstance::getModuleManager
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
Definition: CompilerInstance.cpp:136
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:54
clang::CompilerInstance::addDependencyCollector
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
Definition: CompilerInstance.h:811
clang::PrintingCodeCompleteConsumer
A simple code-completion consumer that prints the results it receives in a simple format...
Definition: CodeCompleteConsumer.h:1181
clang::serialization::MK_PrebuiltModule
File is from a prebuilt module path.
Definition: Module.h:60
clang::FrontendInputFile::getBuffer
llvm::MemoryBuffer * getBuffer() const
Definition: FrontendOptions.h:235
clang::HeaderSearchOptions::ModuleCachePruneInterval
unsigned ModuleCachePruneInterval
The interval (in seconds) between pruning operations.
Definition: HeaderSearchOptions.h:152
clang::CompilerInstance::getSpecificModuleCachePath
std::string getSpecificModuleCachePath()
Definition: CompilerInstance.cpp:464
Id
int Id
Definition: ASTDiff.cpp:191
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:69
clang::ASTReader::ListenerScope
RAII object to temporarily add an AST callback listener.
Definition: ASTReader.h:1590
clang::SourceManager::createFileID
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
Definition: SourceManager.h:817
clang::FrontendInputFile::getFile
StringRef getFile() const
Definition: FrontendOptions.h:230
clang::CompilerInstance::hasFileManager
bool hasFileManager() const
Definition: CompilerInstance.h:406
Version.h
Defines version macros and version-related utility functions for Clang.
clang::MemoryBufferCache::finalizeCurrentBuffers
void finalizeCurrentBuffers()
Finalize the current buffers in the cache.
Definition: MemoryBufferCache.cpp:48
clang::Module::print
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
Definition: Module.cpp:405
Preprocessor.h
Defines the clang::Preprocessor interface.
clang::SimpleASTReaderListener
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:318
clang::CompilerInstance::createASTContext
void createASTContext()
Create the AST context.
Definition: CompilerInstance.cpp:476
clang::DependencyOutputOptions::ShowHeaderIncludes
unsigned ShowHeaderIncludes
Show header inclusions (-H).
Definition: DependencyOutputOptions.h:29
clang::isAlphanumeric
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:118
clang::Preprocessor::checkModuleIsAvailable
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
Definition: PPDirectives.cpp:1617
clang::HeaderSearch::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized. ...
Definition: HeaderSearch.h:269
clang::CompilerInstance::setSema
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
Definition: CompilerInstance.cpp:117
clang::Preprocessor::getMacroInfo
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:981
clang::AttachHeaderIncludeGen
void AttachHeaderIncludeGen(Preprocessor &PP, const DependencyOutputOptions &DepOpts, bool ShowAllHeaders=false, StringRef OutputPath={}, bool ShowDepth=true, bool MSStyle=false)
AttachHeaderIncludeGen - Create a header include list generator, and attach it to the given preproces...
Definition: HeaderIncludeGen.cpp:79
clang::CompilerInstance::createFileManager
FileManager * createFileManager()
Create the file manager and replace any existing one with it.
Definition: CompilerInstance.cpp:304
getLanguageFromOptions
static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts)
Determine the appropriate source input kind based on language options.
Definition: CompilerInstance.cpp:1013
clang::DiagnosticLevelMask::Error
clang::ModuleMap::module_begin
module_iterator module_begin() const
Definition: ModuleMap.h:682
clang::CompilerInstance::getAuxTarget
TargetInfo * getAuxTarget() const
Definition: CompilerInstance.h:377
clang::TargetInfo::CreateTargetInfo
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:608
clang::FrontendInputFile
An input file for the front end.
Definition: FrontendOptions.h:199
ASTConsumer.h
clang::ObjCSubstitutionContext::Result
The result type of a method or function.
clang::CompilerInstance::addOutputFile
void addOutputFile(OutputFile &&OutFile)
addOutputFile - Add an output file onto the list of tracked output files.
Definition: CompilerInstance.cpp:639
clang::SkipFunctionBodiesScope::Preamble
EnableCodeCompletion
static bool EnableCodeCompletion(Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column)
Definition: CompilerInstance.cpp:563
clang::ASTReader::ARR_None
The client can&#39;t handle any AST loading failures.
Definition: ASTReader.h:1508
clang::CompilerInstance::createOutputFile
std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
Definition: CompilerInstance.cpp:687
clang::GenerateModuleFromModuleMapAction
Definition: FrontendActions.h:129
clang::ASTReader::Missing
The AST file was missing.
Definition: ASTReader.h:390
clang::CompilerInstance::lookupMissingImports
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
Check global module index for missing imports.
Definition: CompilerInstance.cpp:2100
clang::CompilerInstance::takeSema
std::unique_ptr< Sema > takeSema()
Definition: CompilerInstance.cpp:132
clang::TargetOptions::CPU
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:37
clang::Preprocessor::getSourceManager
SourceManager & getSourceManager() const
Definition: Preprocessor.h:819
clang::Module::Directory
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:96
clang::SourceManager::overrideFileContents
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
Definition: SourceManager.cpp:629
clang::FileEntry::getDir
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:95
clang::CompilerInstance::resetAndLeakSema
void resetAndLeakSema()
Definition: CompilerInstance.cpp:2123
clang::CompilerInstance::getFileSystemOpts
FileSystemOptions & getFileSystemOpts()
Definition: CompilerInstance.h:286
clang::ASTReader::Success
The control block was read successfully.
Definition: ASTReader.h:384
clang::CompilerInstance::hasPreprocessor
bool hasPreprocessor() const
Definition: CompilerInstance.h:446
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::ModuleLoadResult::MissingExpected
Definition: ModuleLoader.h:45
clang::ApplyHeaderSearchOptions
void ApplyHeaderSearchOptions(HeaderSearch &HS, const HeaderSearchOptions &HSOpts, const LangOptions &Lang, const llvm::Triple &triple)
Apply the header search options to get given HeaderSearch object.
Definition: InitHeaderSearch.cpp:650
clang::CompilerInstance::ExecuteAction
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler&#39;s CompilerInvocation object...
Definition: CompilerInstance.cpp:896
clang::serialization::MK_Preamble
File is a PCH file treated as the preamble.
Definition: Module.h:54
clang::DependencyFileGenerator::AttachToASTReader
void AttachToASTReader(ASTReader &R)
Definition: DependencyFile.cpp:264
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:45
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:73
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::FrontendAction::Execute
bool Execute()
Set the source manager&#39;s main input file, and run the action.
Definition: FrontendAction.cpp:928
clang::FileEntry::getName
StringRef getName() const
Definition: FileManager.h:85
clang::serialization::MK_PCH
File is a PCH file treated as such.
Definition: Module.h:51
clang::FrontendOptions::CodeCompletionAt
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
Definition: FrontendOptions.h:391
PreprocessorOptions.h
clang::PreprocessorOptions::ImplicitPCHInclude
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
Definition: PreprocessorOptions.h:75
clang::FileEntry::isNamedPipe
bool isNamedPipe() const
Check whether the file is a named pipe (and thus can&#39;t be opened by the native FileManager methods)...
Definition: FileManager.h:101
clang::Preprocessor::getLocalMacroDirectiveHistory
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
Definition: PPMacroExpansion.cpp:60
clang::DiagnosticConsumer::getNumWarnings
unsigned getNumWarnings() const
Definition: Diagnostic.h:1498
clang::DiagnosticOptions
Options for controlling the compiler diagnostics engine.
Definition: DiagnosticOptions.h:64
clang::ModuleLoader::HadFatalFailure
bool HadFatalFailure
Definition: ModuleLoader.h:153
clang::FrontendOptions::Inputs
std::vector< FrontendInputFile > Inputs
The input files and their types.
Definition: FrontendOptions.h:375
clang::DiagnosticConsumer::finish
virtual void finish()
Callback to inform the diagnostic client that processing of all source files has ended.
Definition: Diagnostic.h:1524
clang::Module::Hidden
All of the names in this module are hidden.
Definition: Module.h:269
clang::serialization::MK_ImplicitModule
File is an implicitly-loaded module.
Definition: Module.h:45
clang::HeaderSearchOptions::ModulesValidateSystemHeaders
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
Definition: HeaderSearchOptions.h:197
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
clang::AttachDependencyGraphGen
void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)
AttachDependencyGraphGen - Create a dependency graph generator, and attach it to the given preprocess...
Definition: DependencyGraph.cpp:63
clang::FrontendAction::PrepareToExecute
bool PrepareToExecute(CompilerInstance &CI)
Prepare the action to execute on the given compiler instance.
Definition: FrontendAction.h:207
clang::SourceManager::Unowned
Definition: SourceManager.h:839
clang::DiagnosticOptions::DiagnosticSerializationFile
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Definition: DiagnosticOptions.h:96
clang::InputKind
The kind of a file that we&#39;ve been handed as an input.
Definition: FrontendOptions.h:137
clang::ForwardingDiagnosticConsumer
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
Definition: Diagnostic.h:1555
clang::FrontendInputFile::isBuffer
bool isBuffer() const
Definition: FrontendOptions.h:227
clang::ProcessWarningOptions
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
Definition: Warnings.cpp:44
clang::CompilerInstance::hasVirtualFileSystem
bool hasVirtualFileSystem() const
Definition: CompilerInstance.h:386
GlobalModuleIndex.h
clang::ParsedSourceLocation::FileName
std::string FileName
Definition: CommandLineSourceLoc.h:26
clang::CompilerInstance::hasSourceManager
bool hasSourceManager() const
Definition: CompilerInstance.h:426
clang::CompilerInstance::createNullOutputFile
std::unique_ptr< raw_pwrite_stream > createNullOutputFile()
Definition: CompilerInstance.cpp:682
clang::DependencyOutputOptions
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
Definition: DependencyOutputOptions.h:26
LogDiagnosticPrinter.h
clang::FileManager::PrintStats
void PrintStats() const
Definition: FileManager.cpp:527
clang::LangOptions::ModuleName
std::string ModuleName
The module currently being compiled as speficied by -fmodule-name.
Definition: LangOptions.h:220
clang::FileManager::getVirtualFile
const FileEntry * getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
Definition: FileManager.cpp:295
llvm::SmallVector
Definition: LLVM.h:36
clang::DesiredStackSize
constexpr size_t DesiredStackSize
The amount of stack space that Clang would like to be provided with.
Definition: Stack.h:24
clang::SourceManager::pushModuleBuildStack
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
Definition: SourceManager.h:784
clang::FrontendOptions::GenerateGlobalModuleIndex
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
Definition: FrontendOptions.h:286
clang::CompilerInstance::createPreprocessor
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
Definition: CompilerInstance.cpp:372
clang::GlobalModuleIndex
A global index for a set of module files, providing information about the identifiers within those mo...
Definition: GlobalModuleIndex.h:56
clang::CompilerInstance::shouldBuildGlobalModuleIndex
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
Definition: CompilerInstance.cpp:80
clang::ModuleMap::module_end
module_iterator module_end() const
Definition: ModuleMap.h:683
clang::ASTReader::ConfigurationMismatch
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:401
MemoryBufferCache.h
clang::DependencyOutputOptions::OutputFile
std::string OutputFile
The file to write dependency output to.
Definition: DependencyOutputOptions.h:43
clang::CodeCompleteConsumer
Abstract interface for a consumer of code-completion information.
Definition: CodeCompleteConsumer.h:999
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:40
clang::frontend::RewriteObjC
ObjC->C Rewriter.
Definition: FrontendOptions.h:116
clang::CodeCompleteOptions
Options controlling the behavior of code completion.
Definition: CodeCompleteOptions.h:16
clang::HeaderSearch::getHeaderMapFileNames
void getHeaderMapFileNames(SmallVectorImpl< std::string > &Names) const
Get filenames for all registered header maps.
Definition: HeaderSearch.cpp:122
clang::IdentifierInfo::hadMacroDefinition
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
Definition: IdentifierTable.h:179
Decl.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::DiagnosticsEngine::getDiagnosticLevel
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:834
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:108
clang::ASTReader::setDeserializationListener
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
Definition: ASTReader.cpp:808
clang::Module::IsMissingRequirement
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
Definition: Module.h:204
clang::CompilerInstance::setPreprocessor
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
Definition: CompilerInstance.cpp:106
clang::InputKind::ModuleMap
Definition: FrontendOptions.h:171
clang::InputKind::ObjC
Definition: FrontendOptions.h:159
clang::CompilerInstance::getFileManager
FileManager & getFileManager() const
Return the current file manager to the caller.
Definition: CompilerInstance.h:409
clang::SrcMgr::C_System_ModuleMap
Definition: SourceManager.h:79
clang::CompilerInvocationBase::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInvocation.h:109
InitializeFileRemapping
static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)
Definition: CompilerInstance.cpp:322
clang::TextDiagnosticPrinter
Definition: TextDiagnosticPrinter.h:28
clang::FileEntry::getSize
off_t getSize() const
Definition: FileManager.h:88
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:355
clang::serialization::MK_ExplicitModule
File is an explicitly-loaded module.
Definition: Module.h:48
clang::createVFSFromCompilerInvocation
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
Definition: CompilerInvocation.cpp:3465
clang::SrcMgr::C_User
Definition: SourceManager.h:79
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:793
clang::CompilerInstance::loadModuleFile
bool loadModuleFile(StringRef FileName)
Definition: CompilerInstance.cpp:1510
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:297
clang::FileManager::getBufferForFile
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
Definition: FileManager.cpp:401
clang::FrontendOptions::UseGlobalModuleIndex
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
Definition: FrontendOptions.h:283
clang::InputKind::OpenCL
Definition: FrontendOptions.h:161
clang::DiagnosticIDs
Used for handling and querying diagnostic IDs.
Definition: DiagnosticIDs.h:164
clang::ASTContext::setASTMutationListener
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1092
clang::CompilerInvocation
Helper class for holding the data necessary to invoke the compiler.
Definition: CompilerInvocation.h:121
getPublicModuleMap
static const FileEntry * getPublicModuleMap(const FileEntry *File, FileManager &FileMgr)
Definition: CompilerInstance.cpp:1156
pruneModuleCache
static void pruneModuleCache(const HeaderSearchOptions &HSOpts)
Prune the module cache of modules that haven&#39;t been accessed in a long time.
Definition: CompilerInstance.cpp:1384
clang::CompilerInstance::getSourceManager
SourceManager & getSourceManager() const
Return the current source manager.
Definition: CompilerInstance.h:429
clang::InputKind::Language
Language
The language for the input, used to select and validate the language standard and possible actions...
Definition: FrontendOptions.h:146
TextDiagnosticPrinter.h
clang::SrcMgr::C_User_ModuleMap
Definition: SourceManager.h:79
collectIncludePCH
static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
Definition: CompilerInstance.cpp:163
clang::FrontendOptions
FrontendOptions - Options for controlling the behavior of the frontend.
Definition: FrontendOptions.h:242
clang::ModuleLoader
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
clang::DiagnosticsEngine::Warning
Definition: Diagnostic.h:156
clang::MacroInfo
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
clang::FrontendOptions::StatsFile
std::string StatsFile
Filename to write statistics to.
Definition: FrontendOptions.h:436
clang::Module::DefinitionLoc
SourceLocation DefinitionLoc
The location of the module definition.
Definition: Module.h:71
clang::CompilerInstance::clearOutputFiles
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
Definition: CompilerInstance.cpp:643
clang::SourceManager::getFileID
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
Definition: SourceManager.h:1048
clang::ASTReaderListener
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:127
clang::CompilerInstance::hasDiagnostics
bool hasDiagnostics() const
Definition: CompilerInstance.h:342
clang::CompilerInstance::getTarget
TargetInfo & getTarget() const
Definition: CompilerInstance.h:365
clang::SourceManager::setOverridenFilesKeepOriginalName
void setOverridenFilesKeepOriginalName(bool value)
Set true if the SourceManager should report the original file name for contents of files that were ov...
Definition: SourceManager.h:764
clang::CodeGenOptions
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
Definition: CodeGenOptions.h:46
clang::FrontendInputFile::isSystem
bool isSystem() const
Definition: FrontendOptions.h:223
clang::CompilerInstance::createDefaultOutputFile
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation&#39;s options) and add it to the list of tracked outp...
Definition: CompilerInstance.cpp:675
clang::CompilerInstance::hasTarget
bool hasTarget() const
Definition: CompilerInstance.h:363
clang::CompilerInstance::setTarget
void setTarget(TargetInfo *Value)
Replace the current Target.
Definition: CompilerInstance.cpp:91
clang::CompilerInstance::setVirtualFileSystem
void setVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
Replace the current virtual file system.
Definition: CompilerInstance.h:398
clang::DirectoryEntry
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:46
clang::CompilerInstance::hasASTContext
bool hasASTContext() const
Definition: CompilerInstance.h:467
clang::InputKind::ObjCXX
Definition: FrontendOptions.h:160
clang::FrontendOptions::DisableFree
unsigned DisableFree
Disable memory freeing on exit.
Definition: FrontendOptions.h:245
clang::ASTConsumer::Initialize
virtual void Initialize(ASTContext &Context)
Initialize - This is called to initialize the consumer, providing the ASTContext. ...
Definition: ASTConsumer.h:48
VerifyDiagnosticConsumer.h
clang::CompilerInstance::setInvocation
void setInvocation(std::shared_ptr< CompilerInvocation > Value)
setInvocation - Replace the current invocation.
Definition: CompilerInstance.cpp:75
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:449
clang::CompilerInstance::~CompilerInstance
~CompilerInstance() override
Definition: CompilerInstance.cpp:71
clang::CompilerInstance::getDiagnosticClient
DiagnosticConsumer & getDiagnosticClient() const
Definition: CompilerInstance.h:353
clang::Preprocessor::getPredefinesFileID
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
Definition: Preprocessor.h:900
clang::Preprocessor::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:812
clang::HeaderSearchOptions::ModuleCachePruneAfter
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
Definition: HeaderSearchOptions.h:161
clang::InitializePreprocessor
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
Definition: InitPreprocessor.cpp:1088
clang::SourceManager::setModuleBuildStack
void setModuleBuildStack(ModuleBuildStack stack)
Set the module build stack.
Definition: SourceManager.h:778
clang::AttrSyntax::C
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
clang::FixItHint::CreateReplacement
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
clang::PreprocessorOptions::RemappedFiles
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
Definition: PreprocessorOptions.h:131
clang::CompilerInstance::getPCHContainerReader
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
Definition: CompilerInstance.h:549
clang::ModuleMap::resolveLinkAsDependencies
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
Definition: ModuleMap.cpp:59
clang::Module::HasIncompatibleModuleFile
unsigned HasIncompatibleModuleFile
Whether we tried and failed to load a module file for this module.
Definition: Module.h:207
clang::PreprocessorOptions::PrecompiledPreambleBytes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Definition: PreprocessorOptions.h:99
TargetInfo.h
Defines the clang::TargetInfo interface.
clang::ASTReader::OutOfDate
The AST file is out-of-date relative to its input files, and needs to be regenerated.
Definition: ASTReader.h:394
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:340
clang::Module::NameVisibilityKind
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:267
clang::CompilerInstance::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
Definition: CompilerInstance.h:345
clang::HeaderSearchOptions
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
Definition: HeaderSearchOptions.h:67
clang::Module::ConfigMacros
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:344
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_device_functions.h:1611
FrontendAction.h
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
clang::ASTReader::VersionMismatch
The AST file was written by a different version of Clang.
Definition: ASTReader.h:397
clang::CompilerInstance::loadModule
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
Definition: CompilerInstance.cpp:1607
clang::CompilerInstance::createModuleManager
void createModuleManager()
Definition: CompilerInstance.cpp:1460
clang::CompilerInstance::setModuleDepCollector
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
Definition: CompilerInstance.cpp:150
collectVFSEntries
static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
Definition: CompilerInstance.cpp:195
clang::DiagnosticsEngine::isIgnored
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:819
Stack.h
Defines utilities for dealing with stack allocation and stack space.
clang::ASTReader::readASTFileControlBlock
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
Definition: ASTReader.cpp:4718
clang::CompilerInstance::loadGlobalModuleIndex
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module.
Definition: CompilerInstance.cpp:2041
SerializedDiagnosticPrinter.h
clang::HeaderSearchOptions::Sysroot
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
Definition: HeaderSearchOptions.h:99
clang::InputKind::CUDA
Definition: FrontendOptions.h:162
clang::GlobalModuleIndex::writeIndex
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)
Write a global index into the given.
Definition: GlobalModuleIndex.cpp:821
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:198
clang::CompilerInvocationBase::getLangOpts
LangOptions * getLangOpts()
Definition: CompilerInvocation.h:87
clang::HeaderSearchOptions::PrebuiltModuleFiles
std::map< std::string, std::string > PrebuiltModuleFiles
The mapping of module names to prebuilt module files.
Definition: HeaderSearchOptions.h:118
clang::CompilerInstance::getTargetOpts
TargetOptions & getTargetOpts()
Definition: CompilerInstance.h:331
clang::SourceManager::clearIDTables
void clearIDTables()
Definition: SourceManager.cpp:343
clang::Preprocessor::Diag
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
Definition: Preprocessor.h:1549
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:582
clang::CompilerInstance::setDiagnostics
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
Definition: CompilerInstance.cpp:87
clang::TargetInfo::noSignedCharForObjCBool
void noSignedCharForObjCBool()
Definition: TargetInfo.h:658
clang::CompilerInvocation::getModuleHash
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
Definition: CompilerInvocation.cpp:3350
clang::FileManager::getVirtualFileSystem
IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystem() const
Definition: FileManager.h:225
clang::DiagnosticOptions::DiagnosticLogFile
std::string DiagnosticLogFile
The file to log diagnostic output to.
Definition: DiagnosticOptions.h:93
clang::CompilerInstance::hasSema
bool hasSema() const
Definition: CompilerInstance.h:508
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
clang::DiagnosticsEngine::ownsClient
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:514
clang::DirectoryEntry::getName
StringRef getName() const
Definition: FileManager.h:52
clang::FrontendAction::isModelParsingAction
virtual bool isModelParsingAction() const
Is this action invoked on a model file?
Definition: FrontendAction.h:179