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