clang 19.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>(RB.second));
415 }
416
417 // Remap files in the source manager (with other files).
418 for (const auto &RF : InitOpts.RemappedFiles) {
419 // Find the file that we're mapping to.
420 OptionalFileEntryRef ToFile = FileMgr.getOptionalFileRef(RF.second);
421 if (!ToFile) {
422 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
423 continue;
424 }
425
426 // Create the file entry for the file that we're mapping from.
427 const FileEntry *FromFile =
428 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
429 if (!FromFile) {
430 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
431 continue;
432 }
433
434 // Override the contents of the "from" file with the contents of
435 // the "to" file.
436 SourceMgr.overrideFileContents(FromFile, *ToFile);
437 }
438
441}
442
443// Preprocessor
444
447
448 // The AST reader holds a reference to the old preprocessor (if any).
449 TheASTReader.reset();
450
451 // Create the Preprocessor.
452 HeaderSearch *HeaderInfo =
455 PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(),
457 getSourceManager(), *HeaderInfo, *this,
458 /*IdentifierInfoLookup=*/nullptr,
459 /*OwnsHeaderSearch=*/true, TUKind);
461 PP->Initialize(getTarget(), getAuxTarget());
462
463 if (PPOpts.DetailedRecord)
464 PP->createPreprocessingRecord();
465
466 // Apply remappings to the source manager.
467 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
468 PP->getFileManager(), PPOpts);
469
470 // Predefine macros and configure the preprocessor.
473
474 // Initialize the header search object. In CUDA compilations, we use the aux
475 // triple (the host triple) to initialize our header search, since we need to
476 // find the host headers in order to compile the CUDA code.
477 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
478 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
479 PP->getAuxTargetInfo())
480 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
481
482 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
483 PP->getLangOpts(), *HeaderSearchTriple);
484
485 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
486
487 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) {
488 std::string ModuleHash = getInvocation().getModuleHash();
489 PP->getHeaderSearchInfo().setModuleHash(ModuleHash);
490 PP->getHeaderSearchInfo().setModuleCachePath(
491 getSpecificModuleCachePath(ModuleHash));
492 }
493
494 // Handle generating dependencies, if requested.
496 if (!DepOpts.OutputFile.empty())
497 addDependencyCollector(std::make_shared<DependencyFileGenerator>(DepOpts));
498 if (!DepOpts.DOTOutputFile.empty())
500 getHeaderSearchOpts().Sysroot);
501
502 // If we don't have a collector, but we are collecting module dependencies,
503 // then we're the top level compiler instance and need to create one.
504 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
505 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
507 }
508
509 // If there is a module dep collector, register with other dep collectors
510 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
511 if (ModuleDepCollector) {
512 addDependencyCollector(ModuleDepCollector);
513 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
514 collectIncludePCH(*this, ModuleDepCollector);
515 collectVFSEntries(*this, ModuleDepCollector);
516 }
517
518 for (auto &Listener : DependencyCollectors)
519 Listener->attachToPreprocessor(*PP);
520
521 // Handle generating header include information, if requested.
522 if (DepOpts.ShowHeaderIncludes)
523 AttachHeaderIncludeGen(*PP, DepOpts);
524 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
525 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
526 if (OutputPath == "-")
527 OutputPath = "";
528 AttachHeaderIncludeGen(*PP, DepOpts,
529 /*ShowAllHeaders=*/true, OutputPath,
530 /*ShowDepth=*/false);
531 }
532
534 AttachHeaderIncludeGen(*PP, DepOpts,
535 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
536 /*ShowDepth=*/true, /*MSStyle=*/true);
537 }
538}
539
540std::string CompilerInstance::getSpecificModuleCachePath(StringRef ModuleHash) {
541 // Set up the module path, including the hash for the module-creation options.
542 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
543 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
544 llvm::sys::path::append(SpecificModuleCache, ModuleHash);
545 return std::string(SpecificModuleCache);
546}
547
548// ASTContext
549
552 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
554 PP.getBuiltinInfo(), PP.TUKind);
555 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
556 setASTContext(Context);
557}
558
559// ExternalASTSource
560
561namespace {
562// Helper to recursively read the module names for all modules we're adding.
563// We mark these as known and redirect any attempt to load that module to
564// the files we were handed.
565struct ReadModuleNames : ASTReaderListener {
566 Preprocessor &PP;
568
569 ReadModuleNames(Preprocessor &PP) : PP(PP) {}
570
571 void ReadModuleName(StringRef ModuleName) override {
572 // Keep the module name as a string for now. It's not safe to create a new
573 // IdentifierInfo from an ASTReader callback.
574 LoadedModules.push_back(ModuleName.str());
575 }
576
577 void registerAll() {
579 for (const std::string &LoadedModule : LoadedModules)
580 MM.cacheModuleLoad(*PP.getIdentifierInfo(LoadedModule),
581 MM.findModule(LoadedModule));
582 LoadedModules.clear();
583 }
584
585 void markAllUnavailable() {
586 for (const std::string &LoadedModule : LoadedModules) {
588 LoadedModule)) {
589 M->HasIncompatibleModuleFile = true;
590
591 // Mark module as available if the only reason it was unavailable
592 // was missing headers.
594 Stack.push_back(M);
595 while (!Stack.empty()) {
596 Module *Current = Stack.pop_back_val();
597 if (Current->IsUnimportable) continue;
598 Current->IsAvailable = true;
599 auto SubmodulesRange = Current->submodules();
600 Stack.insert(Stack.end(), SubmodulesRange.begin(),
601 SubmodulesRange.end());
602 }
603 }
604 }
605 LoadedModules.clear();
606 }
607};
608} // namespace
609
611 StringRef Path, DisableValidationForModuleKind DisableValidation,
612 bool AllowPCHWithCompilerErrors, void *DeserializationListener,
613 bool OwnDeserializationListener) {
615 TheASTReader = createPCHExternalASTSource(
616 Path, getHeaderSearchOpts().Sysroot, DisableValidation,
617 AllowPCHWithCompilerErrors, getPreprocessor(), getModuleCache(),
619 getFrontendOpts().ModuleFileExtensions, DependencyCollectors,
620 DeserializationListener, OwnDeserializationListener, Preamble,
621 getFrontendOpts().UseGlobalModuleIndex);
622}
623
625 StringRef Path, StringRef Sysroot,
626 DisableValidationForModuleKind DisableValidation,
627 bool AllowPCHWithCompilerErrors, Preprocessor &PP,
628 InMemoryModuleCache &ModuleCache, ASTContext &Context,
629 const PCHContainerReader &PCHContainerRdr,
630 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
631 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
632 void *DeserializationListener, bool OwnDeserializationListener,
633 bool Preamble, bool UseGlobalModuleIndex) {
635
637 PP, ModuleCache, &Context, PCHContainerRdr, Extensions,
638 Sysroot.empty() ? "" : Sysroot.data(), DisableValidation,
639 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
641 UseGlobalModuleIndex));
642
643 // We need the external source to be set up before we read the AST, because
644 // eagerly-deserialized declarations may use it.
645 Context.setExternalSource(Reader.get());
646
647 Reader->setDeserializationListener(
648 static_cast<ASTDeserializationListener *>(DeserializationListener),
649 /*TakeOwnership=*/OwnDeserializationListener);
650
651 for (auto &Listener : DependencyCollectors)
652 Listener->attachToASTReader(*Reader);
653
654 auto Listener = std::make_unique<ReadModuleNames>(PP);
655 auto &ListenerRef = *Listener;
656 ASTReader::ListenerScope ReadModuleNamesListener(*Reader,
657 std::move(Listener));
658
659 switch (Reader->ReadAST(Path,
665 // Set the predefines buffer as suggested by the PCH reader. Typically, the
666 // predefines buffer will be empty.
667 PP.setPredefines(Reader->getSuggestedPredefines());
668 ListenerRef.registerAll();
669 return Reader;
670
672 // Unrecoverable failure: don't even try to process the input file.
673 break;
674
680 // No suitable PCH file could be found. Return an error.
681 break;
682 }
683
684 ListenerRef.markAllUnavailable();
685 Context.setExternalSource(nullptr);
686 return nullptr;
687}
688
689// Code Completion
690
692 StringRef Filename,
693 unsigned Line,
694 unsigned Column) {
695 // Tell the source manager to chop off the given file at a specific
696 // line and column.
697 auto Entry = PP.getFileManager().getOptionalFileRef(Filename);
698 if (!Entry) {
699 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
700 << Filename;
701 return true;
702 }
703
704 // Truncate the named file at the given line/column.
706 return false;
707}
708
711 if (!CompletionConsumer) {
713 getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column,
714 getFrontendOpts().CodeCompleteOpts, llvm::outs()));
715 return;
716 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
717 Loc.Line, Loc.Column)) {
719 return;
720 }
721}
722
724 FrontendTimerGroup.reset(
725 new llvm::TimerGroup("frontend", "Clang front-end time report"));
726 FrontendTimer.reset(
727 new llvm::Timer("frontend", "Clang front-end timer",
728 *FrontendTimerGroup));
729}
730
733 StringRef Filename,
734 unsigned Line,
735 unsigned Column,
736 const CodeCompleteOptions &Opts,
737 raw_ostream &OS) {
739 return nullptr;
740
741 // Set up the creation routine for code-completion.
742 return new PrintingCodeCompleteConsumer(Opts, OS);
743}
744
746 CodeCompleteConsumer *CompletionConsumer) {
747 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
748 TUKind, CompletionConsumer));
749
750 // Set up API notes.
751 TheSema->APINotes.setSwiftVersion(getAPINotesOpts().SwiftVersion);
752
753 // Attach the external sema source if there is any.
754 if (ExternalSemaSrc) {
755 TheSema->addExternalSource(ExternalSemaSrc.get());
756 ExternalSemaSrc->InitializeSema(*TheSema);
757 }
758
759 // If we're building a module and are supposed to load API notes,
760 // notify the API notes manager.
761 if (auto *currentModule = getPreprocessor().getCurrentModule()) {
762 (void)TheSema->APINotes.loadCurrentModuleAPINotes(
763 currentModule, getLangOpts().APINotesModules,
765 }
766}
767
768// Output Files
769
771 // The ASTConsumer can own streams that write to the output files.
772 assert(!hasASTConsumer() && "ASTConsumer should be reset");
773 // Ignore errors that occur when trying to discard the temp file.
774 for (OutputFile &OF : OutputFiles) {
775 if (EraseFiles) {
776 if (OF.File)
777 consumeError(OF.File->discard());
778 if (!OF.Filename.empty())
779 llvm::sys::fs::remove(OF.Filename);
780 continue;
781 }
782
783 if (!OF.File)
784 continue;
785
786 if (OF.File->TmpName.empty()) {
787 consumeError(OF.File->discard());
788 continue;
789 }
790
791 llvm::Error E = OF.File->keep(OF.Filename);
792 if (!E)
793 continue;
794
795 getDiagnostics().Report(diag::err_unable_to_rename_temp)
796 << OF.File->TmpName << OF.Filename << std::move(E);
797
798 llvm::sys::fs::remove(OF.File->TmpName);
799 }
800 OutputFiles.clear();
801 if (DeleteBuiltModules) {
802 for (auto &Module : BuiltModules)
803 llvm::sys::fs::remove(Module.second);
804 BuiltModules.clear();
805 }
806}
807
808std::unique_ptr<raw_pwrite_stream> CompilerInstance::createDefaultOutputFile(
809 bool Binary, StringRef InFile, StringRef Extension, bool RemoveFileOnSignal,
810 bool CreateMissingDirectories, bool ForceUseTemporary) {
811 StringRef OutputPath = getFrontendOpts().OutputFile;
812 std::optional<SmallString<128>> PathStorage;
813 if (OutputPath.empty()) {
814 if (InFile == "-" || Extension.empty()) {
815 OutputPath = "-";
816 } else {
817 PathStorage.emplace(InFile);
818 llvm::sys::path::replace_extension(*PathStorage, Extension);
819 OutputPath = *PathStorage;
820 }
821 }
822
823 return createOutputFile(OutputPath, Binary, RemoveFileOnSignal,
824 getFrontendOpts().UseTemporary || ForceUseTemporary,
825 CreateMissingDirectories);
826}
827
828std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
829 return std::make_unique<llvm::raw_null_ostream>();
830}
831
832std::unique_ptr<raw_pwrite_stream>
833CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
834 bool RemoveFileOnSignal, bool UseTemporary,
835 bool CreateMissingDirectories) {
837 createOutputFileImpl(OutputPath, Binary, RemoveFileOnSignal, UseTemporary,
838 CreateMissingDirectories);
839 if (OS)
840 return std::move(*OS);
841 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
842 << OutputPath << errorToErrorCode(OS.takeError()).message();
843 return nullptr;
844}
845
847CompilerInstance::createOutputFileImpl(StringRef OutputPath, bool Binary,
848 bool RemoveFileOnSignal,
849 bool UseTemporary,
850 bool CreateMissingDirectories) {
851 assert((!CreateMissingDirectories || UseTemporary) &&
852 "CreateMissingDirectories is only allowed when using temporary files");
853
854 // If '-working-directory' was passed, the output filename should be
855 // relative to that.
856 std::optional<SmallString<128>> AbsPath;
857 if (OutputPath != "-" && !llvm::sys::path::is_absolute(OutputPath)) {
858 assert(hasFileManager() &&
859 "File Manager is required to fix up relative path.\n");
860
861 AbsPath.emplace(OutputPath);
862 FileMgr->FixupRelativePath(*AbsPath);
863 OutputPath = *AbsPath;
864 }
865
866 std::unique_ptr<llvm::raw_fd_ostream> OS;
867 std::optional<StringRef> OSFile;
868
869 if (UseTemporary) {
870 if (OutputPath == "-")
871 UseTemporary = false;
872 else {
873 llvm::sys::fs::file_status Status;
874 llvm::sys::fs::status(OutputPath, Status);
875 if (llvm::sys::fs::exists(Status)) {
876 // Fail early if we can't write to the final destination.
877 if (!llvm::sys::fs::can_write(OutputPath))
878 return llvm::errorCodeToError(
879 make_error_code(llvm::errc::operation_not_permitted));
880
881 // Don't use a temporary if the output is a special file. This handles
882 // things like '-o /dev/null'
883 if (!llvm::sys::fs::is_regular_file(Status))
884 UseTemporary = false;
885 }
886 }
887 }
888
889 std::optional<llvm::sys::fs::TempFile> Temp;
890 if (UseTemporary) {
891 // Create a temporary file.
892 // Insert -%%%%%%%% before the extension (if any), and because some tools
893 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
894 // artifacts, also append .tmp.
895 StringRef OutputExtension = llvm::sys::path::extension(OutputPath);
896 SmallString<128> TempPath =
897 StringRef(OutputPath).drop_back(OutputExtension.size());
898 TempPath += "-%%%%%%%%";
899 TempPath += OutputExtension;
900 TempPath += ".tmp";
901 llvm::sys::fs::OpenFlags BinaryFlags =
902 Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text;
904 llvm::sys::fs::TempFile::create(
905 TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write,
906 BinaryFlags);
907
908 llvm::Error E = handleErrors(
909 ExpectedFile.takeError(), [&](const llvm::ECError &E) -> llvm::Error {
910 std::error_code EC = E.convertToErrorCode();
911 if (CreateMissingDirectories &&
912 EC == llvm::errc::no_such_file_or_directory) {
913 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
914 EC = llvm::sys::fs::create_directories(Parent);
915 if (!EC) {
916 ExpectedFile = llvm::sys::fs::TempFile::create(
917 TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write,
918 BinaryFlags);
919 if (!ExpectedFile)
920 return llvm::errorCodeToError(
921 llvm::errc::no_such_file_or_directory);
922 }
923 }
924 return llvm::errorCodeToError(EC);
925 });
926
927 if (E) {
928 consumeError(std::move(E));
929 } else {
930 Temp = std::move(ExpectedFile.get());
931 OS.reset(new llvm::raw_fd_ostream(Temp->FD, /*shouldClose=*/false));
932 OSFile = Temp->TmpName;
933 }
934 // If we failed to create the temporary, fallback to writing to the file
935 // directly. This handles the corner case where we cannot write to the
936 // directory, but can write to the file.
937 }
938
939 if (!OS) {
940 OSFile = OutputPath;
941 std::error_code EC;
942 OS.reset(new llvm::raw_fd_ostream(
943 *OSFile, EC,
944 (Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));
945 if (EC)
946 return llvm::errorCodeToError(EC);
947 }
948
949 // Add the output file -- but don't try to remove "-", since this means we are
950 // using stdin.
951 OutputFiles.emplace_back(((OutputPath != "-") ? OutputPath : "").str(),
952 std::move(Temp));
953
954 if (!Binary || OS->supportsSeeking())
955 return std::move(OS);
956
957 return std::make_unique<llvm::buffer_unique_ostream>(std::move(OS));
958}
959
960// Initialization Utilities
961
965}
966
967// static
969 DiagnosticsEngine &Diags,
970 FileManager &FileMgr,
971 SourceManager &SourceMgr) {
977
978 if (Input.isBuffer()) {
979 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind));
980 assert(SourceMgr.getMainFileID().isValid() &&
981 "Couldn't establish MainFileID!");
982 return true;
983 }
984
985 StringRef InputFile = Input.getFile();
986
987 // Figure out where to get and map in the main file.
988 auto FileOrErr = InputFile == "-"
989 ? FileMgr.getSTDIN()
990 : FileMgr.getFileRef(InputFile, /*OpenFile=*/true);
991 if (!FileOrErr) {
992 auto EC = llvm::errorToErrorCode(FileOrErr.takeError());
993 if (InputFile != "-")
994 Diags.Report(diag::err_fe_error_reading) << InputFile << EC.message();
995 else
996 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
997 return false;
998 }
999
1000 SourceMgr.setMainFileID(
1001 SourceMgr.createFileID(*FileOrErr, SourceLocation(), Kind));
1002
1003 assert(SourceMgr.getMainFileID().isValid() &&
1004 "Couldn't establish MainFileID!");
1005 return true;
1006}
1007
1008// High-Level Operations
1009
1011 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
1012 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
1013 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
1014
1015 // Mark this point as the bottom of the stack if we don't have somewhere
1016 // better. We generally expect frontend actions to be invoked with (nearly)
1017 // DesiredStackSpace available.
1019
1020 auto FinishDiagnosticClient = llvm::make_scope_exit([&]() {
1021 // Notify the diagnostic client that all files were processed.
1023 });
1024
1025 raw_ostream &OS = getVerboseOutputStream();
1026
1027 if (!Act.PrepareToExecute(*this))
1028 return false;
1029
1030 if (!createTarget())
1031 return false;
1032
1033 // rewriter project will change target built-in bool type from its default.
1034 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
1036
1037 // Validate/process some options.
1038 if (getHeaderSearchOpts().Verbose)
1039 OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon LLVM "
1040 << LLVM_VERSION_STRING << " default target "
1041 << llvm::sys::getDefaultTargetTriple() << "\n";
1042
1043 if (getCodeGenOpts().TimePasses)
1045
1046 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
1047 llvm::EnableStatistics(false);
1048
1049 // Sort vectors containing toc data and no toc data variables to facilitate
1050 // binary search later.
1051 llvm::sort(getCodeGenOpts().TocDataVarsUserSpecified);
1052 llvm::sort(getCodeGenOpts().NoTocDataVars);
1053
1054 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
1055 // Reset the ID tables if we are reusing the SourceManager and parsing
1056 // regular files.
1057 if (hasSourceManager() && !Act.isModelParsingAction())
1059
1060 if (Act.BeginSourceFile(*this, FIF)) {
1061 if (llvm::Error Err = Act.Execute()) {
1062 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1063 }
1064 Act.EndSourceFile();
1065 }
1066 }
1067
1069
1070 if (getFrontendOpts().ShowStats) {
1071 if (hasFileManager()) {
1073 OS << '\n';
1074 }
1075 llvm::PrintStatistics(OS);
1076 }
1077 StringRef StatsFile = getFrontendOpts().StatsFile;
1078 if (!StatsFile.empty()) {
1079 llvm::sys::fs::OpenFlags FileFlags = llvm::sys::fs::OF_TextWithCRLF;
1080 if (getFrontendOpts().AppendStats)
1081 FileFlags |= llvm::sys::fs::OF_Append;
1082 std::error_code EC;
1083 auto StatS =
1084 std::make_unique<llvm::raw_fd_ostream>(StatsFile, EC, FileFlags);
1085 if (EC) {
1086 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1087 << StatsFile << EC.message();
1088 } else {
1089 llvm::PrintStatisticsJSON(*StatS);
1090 }
1091 }
1092
1093 return !getDiagnostics().getClient()->getNumErrors();
1094}
1095
1097 if (!getDiagnosticOpts().ShowCarets)
1098 return;
1099
1100 raw_ostream &OS = getVerboseOutputStream();
1101
1102 // We can have multiple diagnostics sharing one diagnostic client.
1103 // Get the total number of warnings/errors from the client.
1104 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
1105 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
1106
1107 if (NumWarnings)
1108 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1109 if (NumWarnings && NumErrors)
1110 OS << " and ";
1111 if (NumErrors)
1112 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1113 if (NumWarnings || NumErrors) {
1114 OS << " generated";
1115 if (getLangOpts().CUDA) {
1116 if (!getLangOpts().CUDAIsDevice) {
1117 OS << " when compiling for host";
1118 } else {
1119 OS << " when compiling for " << getTargetOpts().CPU;
1120 }
1121 }
1122 OS << ".\n";
1123 }
1124}
1125
1127 // Load any requested plugins.
1128 for (const std::string &Path : getFrontendOpts().Plugins) {
1129 std::string Error;
1130 if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error))
1131 getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
1132 << Path << Error;
1133 }
1134
1135 // Check if any of the loaded plugins replaces the main AST action
1136 for (const FrontendPluginRegistry::entry &Plugin :
1137 FrontendPluginRegistry::entries()) {
1138 std::unique_ptr<PluginASTAction> P(Plugin.instantiate());
1139 if (P->getActionType() == PluginASTAction::ReplaceAction) {
1141 getFrontendOpts().ActionName = Plugin.getName().str();
1142 break;
1143 }
1144 }
1145}
1146
1147/// Determine the appropriate source input kind based on language
1148/// options.
1150 if (LangOpts.OpenCL)
1151 return Language::OpenCL;
1152 if (LangOpts.CUDA)
1153 return Language::CUDA;
1154 if (LangOpts.ObjC)
1155 return LangOpts.CPlusPlus ? Language::ObjCXX : Language::ObjC;
1156 return LangOpts.CPlusPlus ? Language::CXX : Language::C;
1157}
1158
1159/// Compile a module file for the given module, using the options
1160/// provided by the importing compiler instance. Returns true if the module
1161/// was built without errors.
1162static bool
1164 StringRef ModuleName, FrontendInputFile Input,
1165 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1166 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1167 [](CompilerInstance &) {},
1168 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1169 [](CompilerInstance &) {}) {
1170 llvm::TimeTraceScope TimeScope("Module Compile", ModuleName);
1171
1172 // Never compile a module that's already finalized - this would cause the
1173 // existing module to be freed, causing crashes if it is later referenced
1174 if (ImportingInstance.getModuleCache().isPCMFinal(ModuleFileName)) {
1175 ImportingInstance.getDiagnostics().Report(
1176 ImportLoc, diag::err_module_rebuild_finalized)
1177 << ModuleName;
1178 return false;
1179 }
1180
1181 // Construct a compiler invocation for creating this module.
1182 auto Invocation =
1183 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1184
1185 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1186
1187 // For any options that aren't intended to affect how a module is built,
1188 // reset them to their default values.
1189 Invocation->resetNonModularOptions();
1190
1191 // Remove any macro definitions that are explicitly ignored by the module.
1192 // They aren't supposed to affect how the module is built anyway.
1193 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1194 llvm::erase_if(PPOpts.Macros,
1195 [&HSOpts](const std::pair<std::string, bool> &def) {
1196 StringRef MacroDef = def.first;
1197 return HSOpts.ModulesIgnoreMacros.contains(
1198 llvm::CachedHashString(MacroDef.split('=').first));
1199 });
1200
1201 // If the original compiler invocation had -fmodule-name, pass it through.
1202 Invocation->getLangOpts().ModuleName =
1203 ImportingInstance.getInvocation().getLangOpts().ModuleName;
1204
1205 // Note the name of the module we're building.
1206 Invocation->getLangOpts().CurrentModule = std::string(ModuleName);
1207
1208 // If there is a module map file, build the module using the module map.
1209 // Set up the inputs/outputs so that we build the module from its umbrella
1210 // header.
1211 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1212 FrontendOpts.OutputFile = ModuleFileName.str();
1213 FrontendOpts.DisableFree = false;
1214 FrontendOpts.GenerateGlobalModuleIndex = false;
1215 FrontendOpts.BuildingImplicitModule = true;
1216 FrontendOpts.OriginalModuleMap = std::string(OriginalModuleMapFile);
1217 // Force implicitly-built modules to hash the content of the module file.
1218 HSOpts.ModulesHashContent = true;
1219 FrontendOpts.Inputs = {Input};
1220
1221 // Don't free the remapped file buffers; they are owned by our caller.
1222 PPOpts.RetainRemappedFileBuffers = true;
1223
1224 DiagnosticOptions &DiagOpts = Invocation->getDiagnosticOpts();
1225
1226 DiagOpts.VerifyDiagnostics = 0;
1227 assert(ImportingInstance.getInvocation().getModuleHash() ==
1228 Invocation->getModuleHash() && "Module hash mismatch!");
1229
1230 // Construct a compiler instance that will be used to actually create the
1231 // module. Since we're sharing an in-memory module cache,
1232 // CompilerInstance::CompilerInstance is responsible for finalizing the
1233 // buffers to prevent use-after-frees.
1234 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1235 &ImportingInstance.getModuleCache());
1236 auto &Inv = *Invocation;
1237 Instance.setInvocation(std::move(Invocation));
1238
1239 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1240 ImportingInstance.getDiagnosticClient()),
1241 /*ShouldOwnClient=*/true);
1242
1243 if (llvm::is_contained(DiagOpts.SystemHeaderWarningsModules, ModuleName))
1244 Instance.getDiagnostics().setSuppressSystemWarnings(false);
1245
1246 if (FrontendOpts.ModulesShareFileManager) {
1247 Instance.setFileManager(&ImportingInstance.getFileManager());
1248 } else {
1249 Instance.createFileManager(&ImportingInstance.getVirtualFileSystem());
1250 }
1251 Instance.createSourceManager(Instance.getFileManager());
1252 SourceManager &SourceMgr = Instance.getSourceManager();
1253
1254 // Note that this module is part of the module build stack, so that we
1255 // can detect cycles in the module graph.
1256 SourceMgr.setModuleBuildStack(
1257 ImportingInstance.getSourceManager().getModuleBuildStack());
1258 SourceMgr.pushModuleBuildStack(ModuleName,
1259 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1260
1261 // Make sure that the failed-module structure has been allocated in
1262 // the importing instance, and propagate the pointer to the newly-created
1263 // instance.
1264 if (!ImportingInstance.hasFailedModulesSet())
1265 ImportingInstance.createFailedModulesSet();
1266 Instance.setFailedModulesSet(ImportingInstance.getFailedModulesSetPtr());
1267
1268 // If we're collecting module dependencies, we need to share a collector
1269 // between all of the module CompilerInstances. Other than that, we don't
1270 // want to produce any dependency output from the module build.
1271 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1272 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1273
1274 ImportingInstance.getDiagnostics().Report(ImportLoc,
1275 diag::remark_module_build)
1276 << ModuleName << ModuleFileName;
1277
1278 PreBuildStep(Instance);
1279
1280 // Execute the action to actually build the module in-place. Use a separate
1281 // thread so that we get a stack large enough.
1282 bool Crashed = !llvm::CrashRecoveryContext().RunSafelyOnThread(
1283 [&]() {
1285 Instance.ExecuteAction(Action);
1286 },
1288
1289 PostBuildStep(Instance);
1290
1291 ImportingInstance.getDiagnostics().Report(ImportLoc,
1292 diag::remark_module_build_done)
1293 << ModuleName;
1294
1295 // Propagate the statistics to the parent FileManager.
1296 if (!FrontendOpts.ModulesShareFileManager)
1297 ImportingInstance.getFileManager().AddStats(Instance.getFileManager());
1298
1299 if (Crashed) {
1300 // Clear the ASTConsumer if it hasn't been already, in case it owns streams
1301 // that must be closed before clearing output files.
1302 Instance.setSema(nullptr);
1303 Instance.setASTConsumer(nullptr);
1304
1305 // Delete any remaining temporary files related to Instance.
1306 Instance.clearOutputFiles(/*EraseFiles=*/true);
1307 }
1308
1309 // If \p AllowPCMWithCompilerErrors is set return 'success' even if errors
1310 // occurred.
1311 return !Instance.getDiagnostics().hasErrorOccurred() ||
1312 Instance.getFrontendOpts().AllowPCMWithCompilerErrors;
1313}
1314
1316 FileManager &FileMgr) {
1317 StringRef Filename = llvm::sys::path::filename(File.getName());
1318 SmallString<128> PublicFilename(File.getDir().getName());
1319 if (Filename == "module_private.map")
1320 llvm::sys::path::append(PublicFilename, "module.map");
1321 else if (Filename == "module.private.modulemap")
1322 llvm::sys::path::append(PublicFilename, "module.modulemap");
1323 else
1324 return std::nullopt;
1325 return FileMgr.getOptionalFileRef(PublicFilename);
1326}
1327
1328/// Compile a module file for the given module in a separate compiler instance,
1329/// using the options provided by the importing compiler instance. Returns true
1330/// if the module was built without errors.
1331static bool compileModule(CompilerInstance &ImportingInstance,
1332 SourceLocation ImportLoc, Module *Module,
1333 StringRef ModuleFileName) {
1334 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1336
1337 // Get or create the module map that we'll use to build this module.
1338 ModuleMap &ModMap
1339 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1340 SourceManager &SourceMgr = ImportingInstance.getSourceManager();
1341 bool Result;
1342 if (FileID ModuleMapFID = ModMap.getContainingModuleMapFileID(Module);
1343 ModuleMapFID.isValid()) {
1344 // We want to use the top-level module map. If we don't, the compiling
1345 // instance may think the containing module map is a top-level one, while
1346 // the importing instance knows it's included from a parent module map via
1347 // the extern directive. This mismatch could bite us later.
1348 SourceLocation Loc = SourceMgr.getIncludeLoc(ModuleMapFID);
1349 while (Loc.isValid() && isModuleMap(SourceMgr.getFileCharacteristic(Loc))) {
1350 ModuleMapFID = SourceMgr.getFileID(Loc);
1351 Loc = SourceMgr.getIncludeLoc(ModuleMapFID);
1352 }
1353
1354 OptionalFileEntryRef ModuleMapFile =
1355 SourceMgr.getFileEntryRefForID(ModuleMapFID);
1356 assert(ModuleMapFile && "Top-level module map with no FileID");
1357
1358 // Canonicalize compilation to start with the public module map. This is
1359 // vital for submodules declarations in the private module maps to be
1360 // correctly parsed when depending on a top level module in the public one.
1361 if (OptionalFileEntryRef PublicMMFile = getPublicModuleMap(
1362 *ModuleMapFile, ImportingInstance.getFileManager()))
1363 ModuleMapFile = PublicMMFile;
1364
1365 StringRef ModuleMapFilePath = ModuleMapFile->getNameAsRequested();
1366
1367 // Use the module map where this module resides.
1369 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1370 FrontendInputFile(ModuleMapFilePath, IK, +Module->IsSystem),
1371 ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName);
1372 } else {
1373 // FIXME: We only need to fake up an input file here as a way of
1374 // transporting the module's directory to the module map parser. We should
1375 // be able to do that more directly, and parse from a memory buffer without
1376 // inventing this file.
1377 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1378 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1379
1380 std::string InferredModuleMapContent;
1381 llvm::raw_string_ostream OS(InferredModuleMapContent);
1382 Module->print(OS);
1383 OS.flush();
1384
1386 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1387 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1389 ModuleFileName,
1390 [&](CompilerInstance &Instance) {
1391 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1392 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1393 FileEntryRef ModuleMapFile = Instance.getFileManager().getVirtualFileRef(
1394 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1395 Instance.getSourceManager().overrideFileContents(
1396 ModuleMapFile, std::move(ModuleMapBuffer));
1397 });
1398 }
1399
1400 // We've rebuilt a module. If we're allowed to generate or update the global
1401 // module index, record that fact in the importing compiler instance.
1402 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1403 ImportingInstance.setBuildGlobalModuleIndex(true);
1404 }
1405
1406 return Result;
1407}
1408
1409/// Read the AST right after compiling the module.
1410static bool readASTAfterCompileModule(CompilerInstance &ImportingInstance,
1411 SourceLocation ImportLoc,
1412 SourceLocation ModuleNameLoc,
1413 Module *Module, StringRef ModuleFileName,
1414 bool *OutOfDate) {
1415 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1416
1417 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1418 if (OutOfDate)
1419 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1420
1421 // Try to read the module file, now that we've compiled it.
1422 ASTReader::ASTReadResult ReadResult =
1423 ImportingInstance.getASTReader()->ReadAST(
1424 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1425 ModuleLoadCapabilities);
1426 if (ReadResult == ASTReader::Success)
1427 return true;
1428
1429 // The caller wants to handle out-of-date failures.
1430 if (OutOfDate && ReadResult == ASTReader::OutOfDate) {
1431 *OutOfDate = true;
1432 return false;
1433 }
1434
1435 // The ASTReader didn't diagnose the error, so conservatively report it.
1436 if (ReadResult == ASTReader::Missing || !Diags.hasErrorOccurred())
1437 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1438 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1439
1440 return false;
1441}
1442
1443/// Compile a module in a separate compiler instance and read the AST,
1444/// returning true if the module compiles without errors.
1445static bool compileModuleAndReadASTImpl(CompilerInstance &ImportingInstance,
1446 SourceLocation ImportLoc,
1447 SourceLocation ModuleNameLoc,
1448 Module *Module,
1449 StringRef ModuleFileName) {
1450 if (!compileModule(ImportingInstance, ModuleNameLoc, Module,
1451 ModuleFileName)) {
1452 ImportingInstance.getDiagnostics().Report(ModuleNameLoc,
1453 diag::err_module_not_built)
1454 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1455 return false;
1456 }
1457
1458 return readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc,
1459 Module, ModuleFileName,
1460 /*OutOfDate=*/nullptr);
1461}
1462
1463/// Compile a module in a separate compiler instance and read the AST,
1464/// returning true if the module compiles without errors, using a lock manager
1465/// to avoid building the same module in multiple compiler instances.
1466///
1467/// Uses a lock file manager and exponential backoff to reduce the chances that
1468/// multiple instances will compete to create the same module. On timeout,
1469/// deletes the lock file in order to avoid deadlock from crashing processes or
1470/// bugs in the lock file manager.
1472 CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1473 SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) {
1474 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1475
1476 Diags.Report(ModuleNameLoc, diag::remark_module_lock)
1477 << ModuleFileName << Module->Name;
1478
1479 // FIXME: have LockFileManager return an error_code so that we can
1480 // avoid the mkdir when the directory already exists.
1481 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1482 llvm::sys::fs::create_directories(Dir);
1483
1484 while (true) {
1485 llvm::LockFileManager Locked(ModuleFileName);
1486 switch (Locked) {
1487 case llvm::LockFileManager::LFS_Error:
1488 // ModuleCache takes care of correctness and locks are only necessary for
1489 // performance. Fallback to building the module in case of any lock
1490 // related errors.
1491 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1492 << Module->Name << Locked.getErrorMessage();
1493 // Clear out any potential leftover.
1494 Locked.unsafeRemoveLockFile();
1495 [[fallthrough]];
1496 case llvm::LockFileManager::LFS_Owned:
1497 // We're responsible for building the module ourselves.
1498 return compileModuleAndReadASTImpl(ImportingInstance, ImportLoc,
1499 ModuleNameLoc, Module, ModuleFileName);
1500
1501 case llvm::LockFileManager::LFS_Shared:
1502 break; // The interesting case.
1503 }
1504
1505 // Someone else is responsible for building the module. Wait for them to
1506 // finish.
1507 switch (Locked.waitForUnlock()) {
1508 case llvm::LockFileManager::Res_Success:
1509 break; // The interesting case.
1510 case llvm::LockFileManager::Res_OwnerDied:
1511 continue; // try again to get the lock.
1512 case llvm::LockFileManager::Res_Timeout:
1513 // Since ModuleCache takes care of correctness, we try waiting for
1514 // another process to complete the build so clang does not do it done
1515 // twice. If case of timeout, build it ourselves.
1516 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1517 << Module->Name;
1518 // Clear the lock file so that future invocations can make progress.
1519 Locked.unsafeRemoveLockFile();
1520 continue;
1521 }
1522
1523 // Read the module that was just written by someone else.
1524 bool OutOfDate = false;
1525 if (readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc,
1526 Module, ModuleFileName, &OutOfDate))
1527 return true;
1528 if (!OutOfDate)
1529 return false;
1530
1531 // The module may be out of date in the presence of file system races,
1532 // or if one of its imports depends on header search paths that are not
1533 // consistent with this ImportingInstance. Try again...
1534 }
1535}
1536
1537/// Compile a module in a separate compiler instance and read the AST,
1538/// returning true if the module compiles without errors, potentially using a
1539/// lock manager to avoid building the same module in multiple compiler
1540/// instances.
1541static bool compileModuleAndReadAST(CompilerInstance &ImportingInstance,
1542 SourceLocation ImportLoc,
1543 SourceLocation ModuleNameLoc,
1544 Module *Module, StringRef ModuleFileName) {
1545 return ImportingInstance.getInvocation()
1548 ? compileModuleAndReadASTBehindLock(ImportingInstance, ImportLoc,
1549 ModuleNameLoc, Module,
1550 ModuleFileName)
1551 : compileModuleAndReadASTImpl(ImportingInstance, ImportLoc,
1552 ModuleNameLoc, Module,
1553 ModuleFileName);
1554}
1555
1556/// Diagnose differences between the current definition of the given
1557/// configuration macro and the definition provided on the command line.
1558static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1559 Module *Mod, SourceLocation ImportLoc) {
1560 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1561 SourceManager &SourceMgr = PP.getSourceManager();
1562
1563 // If this identifier has never had a macro definition, then it could
1564 // not have changed.
1565 if (!Id->hadMacroDefinition())
1566 return;
1567 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1568
1569 // Find the macro definition from the command line.
1570 MacroInfo *CmdLineDefinition = nullptr;
1571 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1572 // We only care about the predefines buffer.
1573 FileID FID = SourceMgr.getFileID(MD->getLocation());
1574 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1575 continue;
1576 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1577 CmdLineDefinition = DMD->getMacroInfo();
1578 break;
1579 }
1580
1581 auto *CurrentDefinition = PP.getMacroInfo(Id);
1582 if (CurrentDefinition == CmdLineDefinition) {
1583 // Macro matches. Nothing to do.
1584 } else if (!CurrentDefinition) {
1585 // This macro was defined on the command line, then #undef'd later.
1586 // Complain.
1587 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1588 << true << ConfigMacro << Mod->getFullModuleName();
1589 auto LatestDef = LatestLocalMD->getDefinition();
1590 assert(LatestDef.isUndefined() &&
1591 "predefined macro went away with no #undef?");
1592 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1593 << true;
1594 return;
1595 } else if (!CmdLineDefinition) {
1596 // There was no definition for this macro in the predefines buffer,
1597 // but there was a local definition. Complain.
1598 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1599 << false << ConfigMacro << Mod->getFullModuleName();
1600 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1601 diag::note_module_def_undef_here)
1602 << false;
1603 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1604 /*Syntactically=*/true)) {
1605 // The macro definitions differ.
1606 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1607 << false << ConfigMacro << Mod->getFullModuleName();
1608 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1609 diag::note_module_def_undef_here)
1610 << false;
1611 }
1612}
1613
1615 SourceLocation ImportLoc) {
1616 clang::Module *TopModule = M->getTopLevelModule();
1617 for (const StringRef ConMacro : TopModule->ConfigMacros) {
1618 checkConfigMacro(PP, ConMacro, M, ImportLoc);
1619 }
1620}
1621
1622/// Write a new timestamp file with the given path.
1623static void writeTimestampFile(StringRef TimestampFile) {
1624 std::error_code EC;
1625 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None);
1626}
1627
1628/// Prune the module cache of modules that haven't been accessed in
1629/// a long time.
1630static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1631 llvm::sys::fs::file_status StatBuf;
1632 llvm::SmallString<128> TimestampFile;
1633 TimestampFile = HSOpts.ModuleCachePath;
1634 assert(!TimestampFile.empty());
1635 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1636
1637 // Try to stat() the timestamp file.
1638 if (std::error_code EC = llvm::sys::fs::status(TimestampFile, StatBuf)) {
1639 // If the timestamp file wasn't there, create one now.
1640 if (EC == std::errc::no_such_file_or_directory) {
1641 writeTimestampFile(TimestampFile);
1642 }
1643 return;
1644 }
1645
1646 // Check whether the time stamp is older than our pruning interval.
1647 // If not, do nothing.
1648 time_t TimeStampModTime =
1649 llvm::sys::toTimeT(StatBuf.getLastModificationTime());
1650 time_t CurrentTime = time(nullptr);
1651 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1652 return;
1653
1654 // Write a new timestamp file so that nobody else attempts to prune.
1655 // There is a benign race condition here, if two Clang instances happen to
1656 // notice at the same time that the timestamp is out-of-date.
1657 writeTimestampFile(TimestampFile);
1658
1659 // Walk the entire module cache, looking for unused module files and module
1660 // indices.
1661 std::error_code EC;
1662 SmallString<128> ModuleCachePathNative;
1663 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1664 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1665 Dir != DirEnd && !EC; Dir.increment(EC)) {
1666 // If we don't have a directory, there's nothing to look into.
1667 if (!llvm::sys::fs::is_directory(Dir->path()))
1668 continue;
1669
1670 // Walk all of the files within this directory.
1671 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1672 File != FileEnd && !EC; File.increment(EC)) {
1673 // We only care about module and global module index files.
1674 StringRef Extension = llvm::sys::path::extension(File->path());
1675 if (Extension != ".pcm" && Extension != ".timestamp" &&
1676 llvm::sys::path::filename(File->path()) != "modules.idx")
1677 continue;
1678
1679 // Look at this file. If we can't stat it, there's nothing interesting
1680 // there.
1681 if (llvm::sys::fs::status(File->path(), StatBuf))
1682 continue;
1683
1684 // If the file has been used recently enough, leave it there.
1685 time_t FileAccessTime = llvm::sys::toTimeT(StatBuf.getLastAccessedTime());
1686 if (CurrentTime - FileAccessTime <=
1687 time_t(HSOpts.ModuleCachePruneAfter)) {
1688 continue;
1689 }
1690
1691 // Remove the file.
1692 llvm::sys::fs::remove(File->path());
1693
1694 // Remove the timestamp file.
1695 std::string TimpestampFilename = File->path() + ".timestamp";
1696 llvm::sys::fs::remove(TimpestampFilename);
1697 }
1698
1699 // If we removed all of the files in the directory, remove the directory
1700 // itself.
1701 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1702 llvm::sys::fs::directory_iterator() && !EC)
1703 llvm::sys::fs::remove(Dir->path());
1704 }
1705}
1706
1708 if (TheASTReader)
1709 return;
1710
1711 if (!hasASTContext())
1713
1714 // If we're implicitly building modules but not currently recursively
1715 // building a module, check whether we need to prune the module cache.
1716 if (getSourceManager().getModuleBuildStack().empty() &&
1717 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1718 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1719 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1721 }
1722
1724 std::string Sysroot = HSOpts.Sysroot;
1725 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1726 const FrontendOptions &FEOpts = getFrontendOpts();
1727 std::unique_ptr<llvm::Timer> ReadTimer;
1728
1729 if (FrontendTimerGroup)
1730 ReadTimer = std::make_unique<llvm::Timer>("reading_modules",
1731 "Reading modules",
1732 *FrontendTimerGroup);
1733 TheASTReader = new ASTReader(
1735 getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions,
1736 Sysroot.empty() ? "" : Sysroot.c_str(),
1738 /*AllowASTWithCompilerErrors=*/FEOpts.AllowPCMWithCompilerErrors,
1739 /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders,
1741 getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer));
1742 if (hasASTConsumer()) {
1743 TheASTReader->setDeserializationListener(
1744 getASTConsumer().GetASTDeserializationListener());
1746 getASTConsumer().GetASTMutationListener());
1747 }
1748 getASTContext().setExternalSource(TheASTReader);
1749 if (hasSema())
1750 TheASTReader->InitializeSema(getSema());
1751 if (hasASTConsumer())
1752 TheASTReader->StartTranslationUnit(&getASTConsumer());
1753
1754 for (auto &Listener : DependencyCollectors)
1755 Listener->attachToASTReader(*TheASTReader);
1756}
1757
1759 StringRef FileName, serialization::ModuleFile *&LoadedModuleFile) {
1760 llvm::Timer Timer;
1761 if (FrontendTimerGroup)
1762 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1763 *FrontendTimerGroup);
1764 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1765
1766 // If we don't already have an ASTReader, create one now.
1767 if (!TheASTReader)
1769
1770 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1771 // ASTReader to diagnose it, since it can produce better errors that we can.
1772 bool ConfigMismatchIsRecoverable =
1773 getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1776
1777 auto Listener = std::make_unique<ReadModuleNames>(*PP);
1778 auto &ListenerRef = *Listener;
1779 ASTReader::ListenerScope ReadModuleNamesListener(*TheASTReader,
1780 std::move(Listener));
1781
1782 // Try to load the module file.
1783 switch (TheASTReader->ReadAST(
1785 ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0,
1786 &LoadedModuleFile)) {
1787 case ASTReader::Success:
1788 // We successfully loaded the module file; remember the set of provided
1789 // modules so that we don't try to load implicit modules for them.
1790 ListenerRef.registerAll();
1791 return true;
1792
1794 // Ignore unusable module files.
1795 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1796 << FileName;
1797 // All modules provided by any files we tried and failed to load are now
1798 // unavailable; includes of those modules should now be handled textually.
1799 ListenerRef.markAllUnavailable();
1800 return true;
1801
1802 default:
1803 return false;
1804 }
1805}
1806
1807namespace {
1808enum ModuleSource {
1809 MS_ModuleNotFound,
1810 MS_ModuleCache,
1811 MS_PrebuiltModulePath,
1812 MS_ModuleBuildPragma
1813};
1814} // end namespace
1815
1816/// Select a source for loading the named module and compute the filename to
1817/// load it from.
1818static ModuleSource selectModuleSource(
1819 Module *M, StringRef ModuleName, std::string &ModuleFilename,
1820 const std::map<std::string, std::string, std::less<>> &BuiltModules,
1821 HeaderSearch &HS) {
1822 assert(ModuleFilename.empty() && "Already has a module source?");
1823
1824 // Check to see if the module has been built as part of this compilation
1825 // via a module build pragma.
1826 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1827 if (BuiltModuleIt != BuiltModules.end()) {
1828 ModuleFilename = BuiltModuleIt->second;
1829 return MS_ModuleBuildPragma;
1830 }
1831
1832 // Try to load the module from the prebuilt module path.
1833 const HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts();
1834 if (!HSOpts.PrebuiltModuleFiles.empty() ||
1835 !HSOpts.PrebuiltModulePaths.empty()) {
1836 ModuleFilename = HS.getPrebuiltModuleFileName(ModuleName);
1837 if (HSOpts.EnablePrebuiltImplicitModules && ModuleFilename.empty())
1838 ModuleFilename = HS.getPrebuiltImplicitModuleFileName(M);
1839 if (!ModuleFilename.empty())
1840 return MS_PrebuiltModulePath;
1841 }
1842
1843 // Try to load the module from the module cache.
1844 if (M) {
1845 ModuleFilename = HS.getCachedModuleFileName(M);
1846 return MS_ModuleCache;
1847 }
1848
1849 return MS_ModuleNotFound;
1850}
1851
1852ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST(
1853 StringRef ModuleName, SourceLocation ImportLoc,
1854 SourceLocation ModuleNameLoc, bool IsInclusionDirective) {
1855 // Search for a module with the given name.
1857 Module *M =
1858 HS.lookupModule(ModuleName, ImportLoc, true, !IsInclusionDirective);
1859
1860 // Check for any configuration macros that have changed. This is done
1861 // immediately before potentially building a module in case this module
1862 // depends on having one of its configuration macros defined to successfully
1863 // build. If this is not done the user will never see the warning.
1864 if (M)
1865 checkConfigMacros(getPreprocessor(), M, ImportLoc);
1866
1867 // Select the source and filename for loading the named module.
1868 std::string ModuleFilename;
1869 ModuleSource Source =
1870 selectModuleSource(M, ModuleName, ModuleFilename, BuiltModules, HS);
1871 if (Source == MS_ModuleNotFound) {
1872 // We can't find a module, error out here.
1873 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1874 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1875 return nullptr;
1876 }
1877 if (ModuleFilename.empty()) {
1878 if (M && M->HasIncompatibleModuleFile) {
1879 // We tried and failed to load a module file for this module. Fall
1880 // back to textual inclusion for its headers.
1882 }
1883
1884 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1885 << ModuleName;
1886 return nullptr;
1887 }
1888
1889 // Create an ASTReader on demand.
1890 if (!getASTReader())
1892
1893 // Time how long it takes to load the module.
1894 llvm::Timer Timer;
1895 if (FrontendTimerGroup)
1896 Timer.init("loading." + ModuleFilename, "Loading " + ModuleFilename,
1897 *FrontendTimerGroup);
1898 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1899 llvm::TimeTraceScope TimeScope("Module Load", ModuleName);
1900
1901 // Try to load the module file. If we are not trying to load from the
1902 // module cache, we don't know how to rebuild modules.
1903 unsigned ARRFlags = Source == MS_ModuleCache
1906 : Source == MS_PrebuiltModulePath
1907 ? 0
1909 switch (getASTReader()->ReadAST(ModuleFilename,
1910 Source == MS_PrebuiltModulePath
1912 : Source == MS_ModuleBuildPragma
1915 ImportLoc, ARRFlags)) {
1916 case ASTReader::Success: {
1917 if (M)
1918 return M;
1919 assert(Source != MS_ModuleCache &&
1920 "missing module, but file loaded from cache");
1921
1922 // A prebuilt module is indexed as a ModuleFile; the Module does not exist
1923 // until the first call to ReadAST. Look it up now.
1924 M = HS.lookupModule(ModuleName, ImportLoc, true, !IsInclusionDirective);
1925
1926 // Check whether M refers to the file in the prebuilt module path.
1927 if (M && M->getASTFile())
1928 if (auto ModuleFile = FileMgr->getFile(ModuleFilename))
1929 if (*ModuleFile == M->getASTFile())
1930 return M;
1931
1932 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1933 << ModuleName;
1934 return ModuleLoadResult();
1935 }
1936
1938 case ASTReader::Missing:
1939 // The most interesting case.
1940 break;
1941
1943 if (Source == MS_PrebuiltModulePath)
1944 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1945 // produce a warning here!
1947 diag::warn_module_config_mismatch)
1948 << ModuleFilename;
1949 // Fall through to error out.
1950 [[fallthrough]];
1954 // FIXME: The ASTReader will already have complained, but can we shoehorn
1955 // that diagnostic information into a more useful form?
1956 return ModuleLoadResult();
1957
1958 case ASTReader::Failure:
1960 return ModuleLoadResult();
1961 }
1962
1963 // ReadAST returned Missing or OutOfDate.
1964 if (Source != MS_ModuleCache) {
1965 // We don't know the desired configuration for this module and don't
1966 // necessarily even have a module map. Since ReadAST already produces
1967 // diagnostics for these two cases, we simply error out here.
1968 return ModuleLoadResult();
1969 }
1970
1971 // The module file is missing or out-of-date. Build it.
1972 assert(M && "missing module, but trying to compile for cache");
1973
1974 // Check whether there is a cycle in the module graph.
1976 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1977 for (; Pos != PosEnd; ++Pos) {
1978 if (Pos->first == ModuleName)
1979 break;
1980 }
1981
1982 if (Pos != PosEnd) {
1983 SmallString<256> CyclePath;
1984 for (; Pos != PosEnd; ++Pos) {
1985 CyclePath += Pos->first;
1986 CyclePath += " -> ";
1987 }
1988 CyclePath += ModuleName;
1989
1990 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1991 << ModuleName << CyclePath;
1992 return nullptr;
1993 }
1994
1995 // Check whether we have already attempted to build this module (but failed).
1996 if (FailedModules && FailedModules->hasAlreadyFailed(ModuleName)) {
1997 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1998 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1999 return nullptr;
2000 }
2001
2002 // Try to compile and then read the AST.
2003 if (!compileModuleAndReadAST(*this, ImportLoc, ModuleNameLoc, M,
2004 ModuleFilename)) {
2005 assert(getDiagnostics().hasErrorOccurred() &&
2006 "undiagnosed error in compileModuleAndReadAST");
2007 if (FailedModules)
2008 FailedModules->addFailed(ModuleName);
2009 return nullptr;
2010 }
2011
2012 // Okay, we've rebuilt and now loaded the module.
2013 return M;
2014}
2015
2018 ModuleIdPath Path,
2020 bool IsInclusionDirective) {
2021 // Determine what file we're searching from.
2022 StringRef ModuleName = Path[0].first->getName();
2023 SourceLocation ModuleNameLoc = Path[0].second;
2024
2025 // If we've already handled this import, just return the cached result.
2026 // This one-element cache is important to eliminate redundant diagnostics
2027 // when both the preprocessor and parser see the same import declaration.
2028 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
2029 // Make the named module visible.
2030 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
2031 TheASTReader->makeModuleVisible(LastModuleImportResult, Visibility,
2032 ImportLoc);
2033 return LastModuleImportResult;
2034 }
2035
2036 // If we don't already have information on this module, load the module now.
2037 Module *Module = nullptr;
2039 if (auto MaybeModule = MM.getCachedModuleLoad(*Path[0].first)) {
2040 // Use the cached result, which may be nullptr.
2041 Module = *MaybeModule;
2042 // Config macros are already checked before building a module, but they need
2043 // to be checked at each import location in case any of the config macros
2044 // have a new value at the current `ImportLoc`.
2045 if (Module)
2047 } else if (ModuleName == getLangOpts().CurrentModule) {
2048 // This is the module we're building.
2050 ModuleName, ImportLoc, /*AllowSearch*/ true,
2051 /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
2052
2053 // Config macros do not need to be checked here for two reasons.
2054 // * This will always be textual inclusion, and thus the config macros
2055 // actually do impact the content of the header.
2056 // * `Preprocessor::HandleHeaderIncludeOrImport` will never call this
2057 // function as the `#include` or `#import` is textual.
2058
2059 MM.cacheModuleLoad(*Path[0].first, Module);
2060 } else {
2061 ModuleLoadResult Result = findOrCompileModuleAndReadAST(
2062 ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
2063 if (!Result.isNormal())
2064 return Result;
2065 if (!Result)
2066 DisableGeneratingGlobalModuleIndex = true;
2067 Module = Result;
2068 MM.cacheModuleLoad(*Path[0].first, Module);
2069 }
2070
2071 // If we never found the module, fail. Otherwise, verify the module and link
2072 // it up.
2073 if (!Module)
2074 return ModuleLoadResult();
2075
2076 // Verify that the rest of the module path actually corresponds to
2077 // a submodule.
2078 bool MapPrivateSubModToTopLevel = false;
2079 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
2080 StringRef Name = Path[I].first->getName();
2081 clang::Module *Sub = Module->findSubmodule(Name);
2082
2083 // If the user is requesting Foo.Private and it doesn't exist, try to
2084 // match Foo_Private and emit a warning asking for the user to write
2085 // @import Foo_Private instead. FIXME: remove this when existing clients
2086 // migrate off of Foo.Private syntax.
2087 if (!Sub && Name == "Private" && Module == Module->getTopLevelModule()) {
2088 SmallString<128> PrivateModule(Module->Name);
2089 PrivateModule.append("_Private");
2090
2092 auto &II = PP->getIdentifierTable().get(
2093 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
2094 PrivPath.push_back(std::make_pair(&II, Path[0].second));
2095
2096 std::string FileName;
2097 // If there is a modulemap module or prebuilt module, load it.
2098 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, ImportLoc, true,
2099 !IsInclusionDirective) ||
2100 selectModuleSource(nullptr, PrivateModule, FileName, BuiltModules,
2101 PP->getHeaderSearchInfo()) != MS_ModuleNotFound)
2102 Sub = loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
2103 if (Sub) {
2104 MapPrivateSubModToTopLevel = true;
2106 if (!getDiagnostics().isIgnored(
2107 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
2108 getDiagnostics().Report(Path[I].second,
2109 diag::warn_no_priv_submodule_use_toplevel)
2110 << Path[I].first << Module->getFullModuleName() << PrivateModule
2111 << SourceRange(Path[0].second, Path[I].second)
2112 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
2113 PrivateModule);
2114 getDiagnostics().Report(Sub->DefinitionLoc,
2115 diag::note_private_top_level_defined);
2116 }
2117 }
2118 }
2119
2120 if (!Sub) {
2121 // Attempt to perform typo correction to find a module name that works.
2123 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
2124
2125 for (class Module *SubModule : Module->submodules()) {
2126 unsigned ED =
2127 Name.edit_distance(SubModule->Name,
2128 /*AllowReplacements=*/true, BestEditDistance);
2129 if (ED <= BestEditDistance) {
2130 if (ED < BestEditDistance) {
2131 Best.clear();
2132 BestEditDistance = ED;
2133 }
2134
2135 Best.push_back(SubModule->Name);
2136 }
2137 }
2138
2139 // If there was a clear winner, user it.
2140 if (Best.size() == 1) {
2141 getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest)
2142 << Path[I].first << Module->getFullModuleName() << Best[0]
2143 << SourceRange(Path[0].second, Path[I - 1].second)
2144 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
2145 Best[0]);
2146
2147 Sub = Module->findSubmodule(Best[0]);
2148 }
2149 }
2150
2151 if (!Sub) {
2152 // No submodule by this name. Complain, and don't look for further
2153 // submodules.
2154 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
2155 << Path[I].first << Module->getFullModuleName()
2156 << SourceRange(Path[0].second, Path[I - 1].second);
2157 break;
2158 }
2159
2160 Module = Sub;
2161 }
2162
2163 // Make the named module visible, if it's not already part of the module
2164 // we are parsing.
2165 if (ModuleName != getLangOpts().CurrentModule) {
2166 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
2167 // We have an umbrella header or directory that doesn't actually include
2168 // all of the headers within the directory it covers. Complain about
2169 // this missing submodule and recover by forgetting that we ever saw
2170 // this submodule.
2171 // FIXME: Should we detect this at module load time? It seems fairly
2172 // expensive (and rare).
2173 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
2175 << SourceRange(Path.front().second, Path.back().second);
2176
2178 }
2179
2180 // Check whether this module is available.
2182 *Module, getDiagnostics())) {
2183 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
2184 << SourceRange(Path.front().second, Path.back().second);
2185 LastModuleImportLoc = ImportLoc;
2186 LastModuleImportResult = ModuleLoadResult();
2187 return ModuleLoadResult();
2188 }
2189
2190 TheASTReader->makeModuleVisible(Module, Visibility, ImportLoc);
2191 }
2192
2193 // Resolve any remaining module using export_as for this one.
2196 .getModuleMap()
2198
2199 LastModuleImportLoc = ImportLoc;
2200 LastModuleImportResult = ModuleLoadResult(Module);
2201 return LastModuleImportResult;
2202}
2203
2205 StringRef ModuleName,
2206 StringRef Source) {
2207 // Avoid creating filenames with special characters.
2208 SmallString<128> CleanModuleName(ModuleName);
2209 for (auto &C : CleanModuleName)
2210 if (!isAlphanumeric(C))
2211 C = '_';
2212
2213 // FIXME: Using a randomized filename here means that our intermediate .pcm
2214 // output is nondeterministic (as .pcm files refer to each other by name).
2215 // Can this affect the output in any way?
2216 SmallString<128> ModuleFileName;
2217 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2218 CleanModuleName, "pcm", ModuleFileName)) {
2219 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2220 << ModuleFileName << EC.message();
2221 return;
2222 }
2223 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2224
2225 FrontendInputFile Input(
2226 ModuleMapFileName,
2227 InputKind(getLanguageFromOptions(Invocation->getLangOpts()),
2228 InputKind::ModuleMap, /*Preprocessed*/true));
2229
2230 std::string NullTerminatedSource(Source.str());
2231
2232 auto PreBuildStep = [&](CompilerInstance &Other) {
2233 // Create a virtual file containing our desired source.
2234 // FIXME: We shouldn't need to do this.
2235 FileEntryRef ModuleMapFile = Other.getFileManager().getVirtualFileRef(
2236 ModuleMapFileName, NullTerminatedSource.size(), 0);
2237 Other.getSourceManager().overrideFileContents(
2238 ModuleMapFile, llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource));
2239
2240 Other.BuiltModules = std::move(BuiltModules);
2241 Other.DeleteBuiltModules = false;
2242 };
2243
2244 auto PostBuildStep = [this](CompilerInstance &Other) {
2245 BuiltModules = std::move(Other.BuiltModules);
2246 };
2247
2248 // Build the module, inheriting any modules that we've built locally.
2249 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2250 ModuleFileName, PreBuildStep, PostBuildStep)) {
2251 BuiltModules[std::string(ModuleName)] = std::string(ModuleFileName);
2252 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2253 }
2254}
2255
2258 SourceLocation ImportLoc) {
2259 if (!TheASTReader)
2261 if (!TheASTReader)
2262 return;
2263
2264 TheASTReader->makeModuleVisible(Mod, Visibility, ImportLoc);
2265}
2266
2268 SourceLocation TriggerLoc) {
2269 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2270 return nullptr;
2271 if (!TheASTReader)
2273 // Can't do anything if we don't have the module manager.
2274 if (!TheASTReader)
2275 return nullptr;
2276 // Get an existing global index. This loads it if not already
2277 // loaded.
2278 TheASTReader->loadGlobalIndex();
2279 GlobalModuleIndex *GlobalIndex = TheASTReader->getGlobalIndex();
2280 // If the global index doesn't exist, create it.
2281 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2282 hasPreprocessor()) {
2283 llvm::sys::fs::create_directories(
2284 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2285 if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2287 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2288 // FIXME this drops the error on the floor. This code is only used for
2289 // typo correction and drops more than just this one source of errors
2290 // (such as the directory creation failure above). It should handle the
2291 // error.
2292 consumeError(std::move(Err));
2293 return nullptr;
2294 }
2295 TheASTReader->resetForReload();
2296 TheASTReader->loadGlobalIndex();
2297 GlobalIndex = TheASTReader->getGlobalIndex();
2298 }
2299 // For finding modules needing to be imported for fixit messages,
2300 // we need to make the global index cover all modules, so we do that here.
2301 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2303 bool RecreateIndex = false;
2305 E = MMap.module_end(); I != E; ++I) {
2306 Module *TheModule = I->second;
2307 OptionalFileEntryRef Entry = TheModule->getASTFile();
2308 if (!Entry) {
2310 Path.push_back(std::make_pair(
2311 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2312 std::reverse(Path.begin(), Path.end());
2313 // Load a module as hidden. This also adds it to the global index.
2314 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2315 RecreateIndex = true;
2316 }
2317 }
2318 if (RecreateIndex) {
2319 if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2321 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2322 // FIXME As above, this drops the error on the floor.
2323 consumeError(std::move(Err));
2324 return nullptr;
2325 }
2326 TheASTReader->resetForReload();
2327 TheASTReader->loadGlobalIndex();
2328 GlobalIndex = TheASTReader->getGlobalIndex();
2329 }
2330 HaveFullGlobalModuleIndex = true;
2331 }
2332 return GlobalIndex;
2333}
2334
2335// Check global module index for missing imports.
2336bool
2338 SourceLocation TriggerLoc) {
2339 // Look for the symbol in non-imported modules, but only if an error
2340 // actually occurred.
2341 if (!buildingModule()) {
2342 // Load global module index, or retrieve a previously loaded one.
2344 TriggerLoc);
2345
2346 // Only if we have a global index.
2347 if (GlobalIndex) {
2348 GlobalModuleIndex::HitSet FoundModules;
2349
2350 // Find the modules that reference the identifier.
2351 // Note that this only finds top-level modules.
2352 // We'll let diagnoseTypo find the actual declaration module.
2353 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2354 return true;
2355 }
2356 }
2357
2358 return false;
2359}
2360void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(takeSema()); }
2361
2364 ExternalSemaSrc = std::move(ESS);
2365}
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 void checkConfigMacros(Preprocessor &PP, Module *M, SourceLocation ImportLoc)
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:2975
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
llvm::MachO::Target Target
Definition: MachO.h:50
Defines the clang::Preprocessor interface.
SourceLocation Loc
Definition: SemaObjC.cpp:755
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:185
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1207
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:947
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:114
RAII object to temporarily add an AST callback listener.
Definition: ASTReader.h:1702
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:1615
@ ARR_None
The client can't handle any AST loading failures.
Definition: ASTReader.h:1611
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1628
@ 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:1619
@ 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:1632
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
Definition: ASTReader.cpp:5397
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.
std::shared_ptr< FailedModulesSet > getFailedModulesSetPtr() const
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 printDiagnosticStats()
At the end of a compilation, print the number of warnings/errors.
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.
bool hasFailedModulesSet() const
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.
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
StringRef getName() const
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:340
StringRef getName() const
The name of this FileEntry.
Definition: FileEntry.h:61
StringRef getNameAsRequested() const
The name of this FileEntry, as originally requested without applying any remappings for VFS 'use-exte...
Definition: FileEntry.h:68
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:300
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
void AddStats(const FileManager &Other)
Import statistics from a child FileManager and add them to this current FileManager.
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: FileManager.h:251
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
Definition: FileManager.h:240
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:175
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:253
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:837
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized.
Definition: HeaderSearch.h:386
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
@ FPE_Default
Used internally to represent initial unspecified value.
Definition: LangOptions.h:284
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Definition: LangOptions.h:278
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
std::string ModuleName
The module currently being compiled as specified by -fmodule-name.
Definition: LangOptions.h:509
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:735
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
Definition: ModuleMap.cpp:826
module_iterator module_begin() const
Definition: ModuleMap.h:737
OptionalFileEntryRef getModuleMapFileForUniquing(const Module *M) const
Definition: ModuleMap.cpp:1330
std::optional< Module * > getCachedModuleLoad(const IdentifierInfo &II)
Return a cached module load.
Definition: ModuleMap.h:749
module_iterator module_end() const
Definition: ModuleMap.h:738
FileID getContainingModuleMapFileID(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
Definition: ModuleMap.cpp:1309
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:744
Describes a module or submodule.
Definition: Module.h:105
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:676
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:357
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:472
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:387
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:389
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:482
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:333
std::string Name
The name of this module.
Definition: Module.h:108
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:783
OptionalDirectoryEntryRef Directory
The build directory of this module.
Definition: Module.h:159
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:320
unsigned HasIncompatibleModuleFile
Whether we tried and failed to load a module file for this module.
Definition: Module.h:309
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:244
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:666
OptionalFileEntryRef getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:681
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::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:461
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.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
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.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
void setMainFileID(FileID FID)
Set the file ID for the main source file.
SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const
Return the file characteristic of the specified source location, indicating whether this is a normal ...
A trivial tuple used to represent a source range.
Exposes information about the current target.
Definition: TargetInfo.h:218
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1256
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:761
virtual void setAuxTarget(const TargetInfo *Aux)
Definition: TargetInfo.h:1794
void noSignedCharForObjCBool()
Definition: TargetInfo.h:917
virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:392
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:473
@ 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.
The JSON file list parser is used to communicate input to InstallAPI.
@ OpenCL
Definition: LangStandard.h:65
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
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts, const CodeGenOptions &CodeGenOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
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:139
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:1033
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...
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:5427
A source location that has been parsed on the command line.