1 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTReader class, which reads AST files.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTMutationListener.h"
20 #include "clang/AST/ASTUnresolvedSet.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclarationName.h"
29 #include "clang/AST/Expr.h"
30 #include "clang/AST/ExprCXX.h"
31 #include "clang/AST/ExternalASTSource.h"
32 #include "clang/AST/NestedNameSpecifier.h"
33 #include "clang/AST/ODRHash.h"
34 #include "clang/AST/RawCommentList.h"
35 #include "clang/AST/TemplateBase.h"
36 #include "clang/AST/TemplateName.h"
37 #include "clang/AST/Type.h"
38 #include "clang/AST/TypeLoc.h"
39 #include "clang/AST/TypeLocVisitor.h"
40 #include "clang/AST/UnresolvedSet.h"
41 #include "clang/Basic/CommentOptions.h"
42 #include "clang/Basic/Diagnostic.h"
43 #include "clang/Basic/DiagnosticOptions.h"
44 #include "clang/Basic/ExceptionSpecificationType.h"
45 #include "clang/Basic/FileManager.h"
46 #include "clang/Basic/FileSystemOptions.h"
47 #include "clang/Basic/IdentifierTable.h"
48 #include "clang/Basic/LLVM.h"
49 #include "clang/Basic/LangOptions.h"
50 #include "clang/Basic/MemoryBufferCache.h"
51 #include "clang/Basic/Module.h"
52 #include "clang/Basic/ObjCRuntime.h"
53 #include "clang/Basic/OperatorKinds.h"
54 #include "clang/Basic/PragmaKinds.h"
55 #include "clang/Basic/Sanitizers.h"
56 #include "clang/Basic/SourceLocation.h"
57 #include "clang/Basic/SourceManager.h"
58 #include "clang/Basic/SourceManagerInternals.h"
59 #include "clang/Basic/Specifiers.h"
60 #include "clang/Basic/TargetInfo.h"
61 #include "clang/Basic/TargetOptions.h"
62 #include "clang/Basic/TokenKinds.h"
63 #include "clang/Basic/Version.h"
64 #include "clang/Frontend/PCHContainerOperations.h"
65 #include "clang/Lex/HeaderSearch.h"
66 #include "clang/Lex/HeaderSearchOptions.h"
67 #include "clang/Lex/MacroInfo.h"
68 #include "clang/Lex/ModuleMap.h"
69 #include "clang/Lex/PreprocessingRecord.h"
70 #include "clang/Lex/Preprocessor.h"
71 #include "clang/Lex/PreprocessorOptions.h"
72 #include "clang/Lex/Token.h"
73 #include "clang/Sema/ObjCMethodList.h"
74 #include "clang/Sema/Scope.h"
75 #include "clang/Sema/Sema.h"
76 #include "clang/Sema/Weak.h"
77 #include "clang/Serialization/ASTBitCodes.h"
78 #include "clang/Serialization/ASTDeserializationListener.h"
79 #include "clang/Serialization/ContinuousRangeMap.h"
80 #include "clang/Serialization/GlobalModuleIndex.h"
81 #include "clang/Serialization/Module.h"
82 #include "clang/Serialization/ModuleFileExtension.h"
83 #include "clang/Serialization/ModuleManager.h"
84 #include "clang/Serialization/SerializationDiagnostic.h"
85 #include "llvm/ADT/APFloat.h"
86 #include "llvm/ADT/APInt.h"
87 #include "llvm/ADT/APSInt.h"
88 #include "llvm/ADT/ArrayRef.h"
89 #include "llvm/ADT/DenseMap.h"
90 #include "llvm/ADT/FoldingSet.h"
91 #include "llvm/ADT/Hashing.h"
92 #include "llvm/ADT/IntrusiveRefCntPtr.h"
93 #include "llvm/ADT/None.h"
94 #include "llvm/ADT/Optional.h"
95 #include "llvm/ADT/STLExtras.h"
96 #include "llvm/ADT/SmallPtrSet.h"
97 #include "llvm/ADT/SmallString.h"
98 #include "llvm/ADT/SmallVector.h"
99 #include "llvm/ADT/StringExtras.h"
100 #include "llvm/ADT/StringMap.h"
101 #include "llvm/ADT/StringRef.h"
102 #include "llvm/ADT/Triple.h"
103 #include "llvm/ADT/iterator_range.h"
104 #include "llvm/Bitcode/BitstreamReader.h"
105 #include "llvm/Support/Casting.h"
106 #include "llvm/Support/Compiler.h"
107 #include "llvm/Support/Compression.h"
108 #include "llvm/Support/DJB.h"
109 #include "llvm/Support/Endian.h"
110 #include "llvm/Support/Error.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/FileSystem.h"
113 #include "llvm/Support/MemoryBuffer.h"
114 #include "llvm/Support/Path.h"
115 #include "llvm/Support/SaveAndRestore.h"
116 #include "llvm/Support/Timer.h"
117 #include "llvm/Support/VersionTuple.h"
118 #include "llvm/Support/raw_ostream.h"
130 #include <system_error>
135 using namespace clang;
136 using namespace clang::serialization;
137 using namespace clang::serialization::reader;
138 using llvm::BitstreamCursor;
140 //===----------------------------------------------------------------------===//
141 // ChainedASTReaderListener implementation
142 //===----------------------------------------------------------------------===//
145 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
146 return First->ReadFullVersionInformation(FullVersion) ||
147 Second->ReadFullVersionInformation(FullVersion);
150 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151 First->ReadModuleName(ModuleName);
152 Second->ReadModuleName(ModuleName);
155 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156 First->ReadModuleMapFile(ModuleMapPath);
157 Second->ReadModuleMapFile(ModuleMapPath);
161 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
163 bool AllowCompatibleDifferences) {
164 return First->ReadLanguageOptions(LangOpts, Complain,
165 AllowCompatibleDifferences) ||
166 Second->ReadLanguageOptions(LangOpts, Complain,
167 AllowCompatibleDifferences);
170 bool ChainedASTReaderListener::ReadTargetOptions(
171 const TargetOptions &TargetOpts, bool Complain,
172 bool AllowCompatibleDifferences) {
173 return First->ReadTargetOptions(TargetOpts, Complain,
174 AllowCompatibleDifferences) ||
175 Second->ReadTargetOptions(TargetOpts, Complain,
176 AllowCompatibleDifferences);
179 bool ChainedASTReaderListener::ReadDiagnosticOptions(
180 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182 Second->ReadDiagnosticOptions(DiagOpts, Complain);
186 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
188 return First->ReadFileSystemOptions(FSOpts, Complain) ||
189 Second->ReadFileSystemOptions(FSOpts, Complain);
192 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
193 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
195 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
197 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
201 bool ChainedASTReaderListener::ReadPreprocessorOptions(
202 const PreprocessorOptions &PPOpts, bool Complain,
203 std::string &SuggestedPredefines) {
204 return First->ReadPreprocessorOptions(PPOpts, Complain,
205 SuggestedPredefines) ||
206 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
209 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
211 First->ReadCounter(M, Value);
212 Second->ReadCounter(M, Value);
215 bool ChainedASTReaderListener::needsInputFileVisitation() {
216 return First->needsInputFileVisitation() ||
217 Second->needsInputFileVisitation();
220 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
221 return First->needsSystemInputFileVisitation() ||
222 Second->needsSystemInputFileVisitation();
225 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
227 First->visitModuleFile(Filename, Kind);
228 Second->visitModuleFile(Filename, Kind);
231 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
234 bool isExplicitModule) {
235 bool Continue = false;
236 if (First->needsInputFileVisitation() &&
237 (!isSystem || First->needsSystemInputFileVisitation()))
238 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
240 if (Second->needsInputFileVisitation() &&
241 (!isSystem || Second->needsSystemInputFileVisitation()))
242 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
247 void ChainedASTReaderListener::readModuleFileExtension(
248 const ModuleFileExtensionMetadata &Metadata) {
249 First->readModuleFileExtension(Metadata);
250 Second->readModuleFileExtension(Metadata);
253 //===----------------------------------------------------------------------===//
254 // PCH validator implementation
255 //===----------------------------------------------------------------------===//
257 ASTReaderListener::~ASTReaderListener() = default;
259 /// Compare the given set of language options against an existing set of
260 /// language options.
262 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263 /// \param AllowCompatibleDifferences If true, differences between compatible
264 /// language options will be permitted.
266 /// \returns true if the languagae options mis-match, false otherwise.
267 static bool checkLanguageOptions(const LangOptions &LangOpts,
268 const LangOptions &ExistingLangOpts,
269 DiagnosticsEngine *Diags,
270 bool AllowCompatibleDifferences = true) {
271 #define LANGOPT(Name, Bits, Default, Description) \
272 if (ExistingLangOpts.Name != LangOpts.Name) { \
274 Diags->Report(diag::err_pch_langopt_mismatch) \
275 << Description << LangOpts.Name << ExistingLangOpts.Name; \
279 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
280 if (ExistingLangOpts.Name != LangOpts.Name) { \
282 Diags->Report(diag::err_pch_langopt_value_mismatch) \
287 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
288 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
290 Diags->Report(diag::err_pch_langopt_value_mismatch) \
295 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
296 if (!AllowCompatibleDifferences) \
297 LANGOPT(Name, Bits, Default, Description)
299 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
300 if (!AllowCompatibleDifferences) \
301 ENUM_LANGOPT(Name, Bits, Default, Description)
303 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304 if (!AllowCompatibleDifferences) \
305 VALUE_LANGOPT(Name, Bits, Default, Description)
307 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
308 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310 #include "clang/Basic/LangOptions.def"
312 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
314 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
318 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
320 Diags->Report(diag::err_pch_langopt_value_mismatch)
321 << "target Objective-C runtime";
325 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326 LangOpts.CommentOpts.BlockCommandNames) {
328 Diags->Report(diag::err_pch_langopt_value_mismatch)
329 << "block command names";
333 // Sanitizer feature mismatches are treated as compatible differences. If
334 // compatible differences aren't allowed, we still only want to check for
335 // mismatches of non-modular sanitizers (the only ones which can affect AST
337 if (!AllowCompatibleDifferences) {
338 SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339 SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340 SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341 ExistingSanitizers.clear(ModularSanitizers);
342 ImportedSanitizers.clear(ModularSanitizers);
343 if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344 const std::string Flag = "-fsanitize=";
346 #define SANITIZER(NAME, ID) \
348 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
349 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
350 if (InExistingModule != InImportedModule) \
351 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
352 << InExistingModule << (Flag + NAME); \
354 #include "clang/Basic/Sanitizers.def"
363 /// Compare the given set of target options against an existing set of
366 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
368 /// \returns true if the target options mis-match, false otherwise.
369 static bool checkTargetOptions(const TargetOptions &TargetOpts,
370 const TargetOptions &ExistingTargetOpts,
371 DiagnosticsEngine *Diags,
372 bool AllowCompatibleDifferences = true) {
373 #define CHECK_TARGET_OPT(Field, Name) \
374 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
376 Diags->Report(diag::err_pch_targetopt_mismatch) \
377 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
381 // The triple and ABI must match exactly.
382 CHECK_TARGET_OPT(Triple, "target");
383 CHECK_TARGET_OPT(ABI, "target ABI");
385 // We can tolerate different CPUs in many cases, notably when one CPU
386 // supports a strict superset of another. When allowing compatible
387 // differences skip this check.
388 if (!AllowCompatibleDifferences)
389 CHECK_TARGET_OPT(CPU, "target CPU");
391 #undef CHECK_TARGET_OPT
393 // Compare feature sets.
394 SmallVector<StringRef, 4> ExistingFeatures(
395 ExistingTargetOpts.FeaturesAsWritten.begin(),
396 ExistingTargetOpts.FeaturesAsWritten.end());
397 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398 TargetOpts.FeaturesAsWritten.end());
399 llvm::sort(ExistingFeatures.begin(), ExistingFeatures.end());
400 llvm::sort(ReadFeatures.begin(), ReadFeatures.end());
402 // We compute the set difference in both directions explicitly so that we can
403 // diagnose the differences differently.
404 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
406 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409 ExistingFeatures.begin(), ExistingFeatures.end(),
410 std::back_inserter(UnmatchedReadFeatures));
412 // If we are allowing compatible differences and the read feature set is
413 // a strict subset of the existing feature set, there is nothing to diagnose.
414 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
418 for (StringRef Feature : UnmatchedReadFeatures)
419 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420 << /* is-existing-feature */ false << Feature;
421 for (StringRef Feature : UnmatchedExistingFeatures)
422 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423 << /* is-existing-feature */ true << Feature;
426 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
430 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
432 bool AllowCompatibleDifferences) {
433 const LangOptions &ExistingLangOpts = PP.getLangOpts();
434 return checkLanguageOptions(LangOpts, ExistingLangOpts,
435 Complain ? &Reader.Diags : nullptr,
436 AllowCompatibleDifferences);
439 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
441 bool AllowCompatibleDifferences) {
442 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444 Complain ? &Reader.Diags : nullptr,
445 AllowCompatibleDifferences);
450 using MacroDefinitionsMap =
451 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
456 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
457 DiagnosticsEngine &Diags,
459 using Level = DiagnosticsEngine::Level;
461 // Check current mappings for new -Werror mappings, and the stored mappings
462 // for cases that were explicitly mapped to *not* be errors that are now
463 // errors because of options like -Werror.
464 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
466 for (DiagnosticsEngine *MappingSource : MappingSources) {
467 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468 diag::kind DiagID = DiagIDMappingPair.first;
469 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470 if (CurLevel < DiagnosticsEngine::Error)
471 continue; // not significant
473 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474 if (StoredLevel < DiagnosticsEngine::Error) {
476 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
486 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
487 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
488 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
490 return Ext >= diag::Severity::Error;
493 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
494 DiagnosticsEngine &Diags,
495 bool IsSystem, bool Complain) {
498 if (Diags.getSuppressSystemWarnings())
500 // If -Wsystem-headers was not enabled before, be conservative
501 if (StoredDiags.getSuppressSystemWarnings()) {
503 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
508 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
510 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
514 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515 !StoredDiags.getEnableAllWarnings()) {
517 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
521 if (isExtHandlingFromDiagsError(Diags) &&
522 !isExtHandlingFromDiagsError(StoredDiags)) {
524 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
528 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
531 /// Return the top import module if it is implicit, nullptr otherwise.
532 static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
534 // If the original import came from a file explicitly generated by the user,
535 // don't check the diagnostic mappings.
536 // FIXME: currently this is approximated by checking whether this is not a
537 // module import of an implicitly-loaded module file.
538 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539 // the transitive closure of its imports, since unrelated modules cannot be
540 // imported until after this module finishes validation.
541 ModuleFile *TopImport = &*ModuleMgr.rbegin();
542 while (!TopImport->ImportedBy.empty())
543 TopImport = TopImport->ImportedBy[0];
544 if (TopImport->Kind != MK_ImplicitModule)
547 StringRef ModuleName = TopImport->ModuleName;
548 assert(!ModuleName.empty() && "diagnostic options read before module name");
550 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551 assert(M && "missing module");
555 bool PCHValidator::ReadDiagnosticOptions(
556 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
559 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
560 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561 // This should never fail, because we would have processed these options
562 // before writing them to an ASTFile.
563 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
565 ModuleManager &ModuleMgr = Reader.getModuleManager();
566 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
568 Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
572 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573 // contains the union of their flags.
574 return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
578 /// Collect the macro definitions provided by the given preprocessor
581 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
582 MacroDefinitionsMap &Macros,
583 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585 StringRef Macro = PPOpts.Macros[I].first;
586 bool IsUndef = PPOpts.Macros[I].second;
588 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589 StringRef MacroName = MacroPair.first;
590 StringRef MacroBody = MacroPair.second;
592 // For an #undef'd macro, we only care about the name.
594 if (MacroNames && !Macros.count(MacroName))
595 MacroNames->push_back(MacroName);
597 Macros[MacroName] = std::make_pair("", true);
601 // For a #define'd macro, figure out the actual definition.
602 if (MacroName.size() == Macro.size())
605 // Note: GCC drops anything following an end-of-line character.
606 StringRef::size_type End = MacroBody.find_first_of("\n\r");
607 MacroBody = MacroBody.substr(0, End);
610 if (MacroNames && !Macros.count(MacroName))
611 MacroNames->push_back(MacroName);
612 Macros[MacroName] = std::make_pair(MacroBody, false);
616 /// Check the preprocessor options deserialized from the control block
617 /// against the preprocessor options in an existing preprocessor.
619 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620 /// \param Validate If true, validate preprocessor options. If false, allow
621 /// macros defined by \p ExistingPPOpts to override those defined by
622 /// \p PPOpts in SuggestedPredefines.
623 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
624 const PreprocessorOptions &ExistingPPOpts,
625 DiagnosticsEngine *Diags,
626 FileManager &FileMgr,
627 std::string &SuggestedPredefines,
628 const LangOptions &LangOpts,
629 bool Validate = true) {
630 // Check macro definitions.
631 MacroDefinitionsMap ASTFileMacros;
632 collectMacroDefinitions(PPOpts, ASTFileMacros);
633 MacroDefinitionsMap ExistingMacros;
634 SmallVector<StringRef, 4> ExistingMacroNames;
635 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
637 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638 // Dig out the macro definition in the existing preprocessor options.
639 StringRef MacroName = ExistingMacroNames[I];
640 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
642 // Check whether we know anything about this macro name or not.
643 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644 ASTFileMacros.find(MacroName);
645 if (!Validate || Known == ASTFileMacros.end()) {
646 // FIXME: Check whether this identifier was referenced anywhere in the
647 // AST file. If so, we should reject the AST file. Unfortunately, this
648 // information isn't in the control block. What shall we do about it?
650 if (Existing.second) {
651 SuggestedPredefines += "#undef ";
652 SuggestedPredefines += MacroName.str();
653 SuggestedPredefines += '\n';
655 SuggestedPredefines += "#define ";
656 SuggestedPredefines += MacroName.str();
657 SuggestedPredefines += ' ';
658 SuggestedPredefines += Existing.first.str();
659 SuggestedPredefines += '\n';
664 // If the macro was defined in one but undef'd in the other, we have a
666 if (Existing.second != Known->second.second) {
668 Diags->Report(diag::err_pch_macro_def_undef)
669 << MacroName << Known->second.second;
674 // If the macro was #undef'd in both, or if the macro bodies are identical,
676 if (Existing.second || Existing.first == Known->second.first)
679 // The macro bodies differ; complain.
681 Diags->Report(diag::err_pch_macro_def_conflict)
682 << MacroName << Known->second.first << Existing.first;
687 // Check whether we're using predefines.
688 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
690 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
695 // Detailed record is important since it is used for the module cache hash.
696 if (LangOpts.Modules &&
697 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
699 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
704 // Compute the #include and #include_macros lines we need.
705 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706 StringRef File = ExistingPPOpts.Includes[I];
708 if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709 !ExistingPPOpts.PCHThroughHeader.empty()) {
710 // In case the through header is an include, we must add all the includes
711 // to the predefines so the start point can be determined.
712 SuggestedPredefines += "#include \"";
713 SuggestedPredefines += File;
714 SuggestedPredefines += "\"\n";
718 if (File == ExistingPPOpts.ImplicitPCHInclude)
721 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722 != PPOpts.Includes.end())
725 SuggestedPredefines += "#include \"";
726 SuggestedPredefines += File;
727 SuggestedPredefines += "\"\n";
730 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731 StringRef File = ExistingPPOpts.MacroIncludes[I];
732 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
734 != PPOpts.MacroIncludes.end())
737 SuggestedPredefines += "#__include_macros \"";
738 SuggestedPredefines += File;
739 SuggestedPredefines += "\"\n##\n";
745 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
747 std::string &SuggestedPredefines) {
748 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
750 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751 Complain? &Reader.Diags : nullptr,
757 bool SimpleASTReaderListener::ReadPreprocessorOptions(
758 const PreprocessorOptions &PPOpts,
760 std::string &SuggestedPredefines) {
761 return checkPreprocessorOptions(PPOpts,
762 PP.getPreprocessorOpts(),
770 /// Check the header search options deserialized from the control block
771 /// against the header search options in an existing preprocessor.
773 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
774 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
775 StringRef SpecificModuleCachePath,
776 StringRef ExistingModuleCachePath,
777 DiagnosticsEngine *Diags,
778 const LangOptions &LangOpts) {
779 if (LangOpts.Modules) {
780 if (SpecificModuleCachePath != ExistingModuleCachePath) {
782 Diags->Report(diag::err_pch_modulecache_mismatch)
783 << SpecificModuleCachePath << ExistingModuleCachePath;
791 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
792 StringRef SpecificModuleCachePath,
794 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795 PP.getHeaderSearchInfo().getModuleCachePath(),
796 Complain ? &Reader.Diags : nullptr,
800 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801 PP.setCounterValue(Value);
804 //===----------------------------------------------------------------------===//
805 // AST reader implementation
806 //===----------------------------------------------------------------------===//
808 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
809 bool TakeOwnership) {
810 DeserializationListener = Listener;
811 OwnsDeserializationListener = TakeOwnership;
814 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
815 return serialization::ComputeHash(Sel);
818 std::pair<unsigned, unsigned>
819 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
820 using namespace llvm::support;
822 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824 return std::make_pair(KeyLen, DataLen);
827 ASTSelectorLookupTrait::internal_key_type
828 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829 using namespace llvm::support;
831 SelectorTable &SelTable = Reader.getContext().Selectors;
832 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834 F, endian::readNext<uint32_t, little, unaligned>(d));
836 return SelTable.getNullarySelector(FirstII);
838 return SelTable.getUnarySelector(FirstII);
840 SmallVector<IdentifierInfo *, 16> Args;
841 Args.push_back(FirstII);
842 for (unsigned I = 1; I != N; ++I)
843 Args.push_back(Reader.getLocalIdentifier(
844 F, endian::readNext<uint32_t, little, unaligned>(d)));
846 return SelTable.getSelector(N, Args.data());
849 ASTSelectorLookupTrait::data_type
850 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
852 using namespace llvm::support;
856 Result.ID = Reader.getGlobalSelectorID(
857 F, endian::readNext<uint32_t, little, unaligned>(d));
858 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860 Result.InstanceBits = FullInstanceBits & 0x3;
861 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862 Result.FactoryBits = FullFactoryBits & 0x3;
863 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864 unsigned NumInstanceMethods = FullInstanceBits >> 3;
865 unsigned NumFactoryMethods = FullFactoryBits >> 3;
867 // Load instance methods
868 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870 F, endian::readNext<uint32_t, little, unaligned>(d)))
871 Result.Instance.push_back(Method);
874 // Load factory methods
875 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877 F, endian::readNext<uint32_t, little, unaligned>(d)))
878 Result.Factory.push_back(Method);
884 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
885 return llvm::djbHash(a);
888 std::pair<unsigned, unsigned>
889 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
890 using namespace llvm::support;
892 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894 return std::make_pair(KeyLen, DataLen);
897 ASTIdentifierLookupTraitBase::internal_key_type
898 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899 assert(n >= 2 && d[n-1] == '\0');
900 return StringRef((const char*) d, n-1);
903 /// Whether the given identifier is "interesting".
904 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
906 return II.hadMacroDefinition() ||
908 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
909 II.hasRevertedTokenIDToIdentifier() ||
910 (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911 II.getFETokenInfo<void>());
914 static bool readBit(unsigned &Bits) {
915 bool Value = Bits & 0x1;
920 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
921 using namespace llvm::support;
923 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924 return Reader.getGlobalIdentifierID(F, RawID >> 1);
927 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928 if (!II.isFromAST()) {
930 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931 if (isInterestingIdentifier(Reader, II, IsModule))
932 II.setChangedSinceDeserialization();
936 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
937 const unsigned char* d,
939 using namespace llvm::support;
941 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942 bool IsInteresting = RawID & 0x01;
944 // Wipe out the "is interesting" bit.
947 // Build the IdentifierInfo and link the identifier ID with it.
948 IdentifierInfo *II = KnownII;
950 II = &Reader.getIdentifierTable().getOwn(k);
953 markIdentifierFromAST(Reader, *II);
954 Reader.markIdentifierUpToDate(II);
956 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957 if (!IsInteresting) {
958 // For uninteresting identifiers, there's nothing else to do. Just notify
959 // the reader that we've finished loading this identifier.
960 Reader.SetIdentifierInfo(ID, II);
964 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966 bool CPlusPlusOperatorKeyword = readBit(Bits);
967 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968 bool HasRevertedBuiltin = readBit(Bits);
969 bool Poisoned = readBit(Bits);
970 bool ExtensionToken = readBit(Bits);
971 bool HadMacroDefinition = readBit(Bits);
973 assert(Bits == 0 && "Extra bits in the identifier?");
976 // Set or check the various bits in the IdentifierInfo structure.
977 // Token IDs are read-only.
978 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
979 II->revertTokenIDToIdentifier();
981 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982 else if (HasRevertedBuiltin && II->getBuiltinID()) {
984 assert((II->hasRevertedBuiltin() ||
985 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
986 "Incorrect ObjC keyword or builtin ID");
988 assert(II->isExtensionToken() == ExtensionToken &&
989 "Incorrect extension token flag");
990 (void)ExtensionToken;
992 II->setIsPoisoned(true);
993 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
994 "Incorrect C++ operator keyword flag");
995 (void)CPlusPlusOperatorKeyword;
997 // If this identifier is a macro, deserialize the macro
999 if (HadMacroDefinition) {
1000 uint32_t MacroDirectivesOffset =
1001 endian::readNext<uint32_t, little, unaligned>(d);
1004 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1007 Reader.SetIdentifierInfo(ID, II);
1009 // Read all of the declarations visible at global scope with this
1012 SmallVector<uint32_t, 4> DeclIDs;
1013 for (; DataLen > 0; DataLen -= 4)
1014 DeclIDs.push_back(Reader.getGlobalDeclID(
1015 F, endian::readNext<uint32_t, little, unaligned>(d)));
1016 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1022 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1023 : Kind(Name.getNameKind()) {
1025 case DeclarationName::Identifier:
1026 Data = (uint64_t)Name.getAsIdentifierInfo();
1028 case DeclarationName::ObjCZeroArgSelector:
1029 case DeclarationName::ObjCOneArgSelector:
1030 case DeclarationName::ObjCMultiArgSelector:
1031 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1033 case DeclarationName::CXXOperatorName:
1034 Data = Name.getCXXOverloadedOperator();
1036 case DeclarationName::CXXLiteralOperatorName:
1037 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1039 case DeclarationName::CXXDeductionGuideName:
1040 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1041 ->getDeclName().getAsIdentifierInfo();
1043 case DeclarationName::CXXConstructorName:
1044 case DeclarationName::CXXDestructorName:
1045 case DeclarationName::CXXConversionFunctionName:
1046 case DeclarationName::CXXUsingDirective:
1052 unsigned DeclarationNameKey::getHash() const {
1053 llvm::FoldingSetNodeID ID;
1054 ID.AddInteger(Kind);
1057 case DeclarationName::Identifier:
1058 case DeclarationName::CXXLiteralOperatorName:
1059 case DeclarationName::CXXDeductionGuideName:
1060 ID.AddString(((IdentifierInfo*)Data)->getName());
1062 case DeclarationName::ObjCZeroArgSelector:
1063 case DeclarationName::ObjCOneArgSelector:
1064 case DeclarationName::ObjCMultiArgSelector:
1065 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1067 case DeclarationName::CXXOperatorName:
1068 ID.AddInteger((OverloadedOperatorKind)Data);
1070 case DeclarationName::CXXConstructorName:
1071 case DeclarationName::CXXDestructorName:
1072 case DeclarationName::CXXConversionFunctionName:
1073 case DeclarationName::CXXUsingDirective:
1077 return ID.ComputeHash();
1081 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082 using namespace llvm::support;
1084 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085 return Reader.getLocalModuleFile(F, ModuleFileID);
1088 std::pair<unsigned, unsigned>
1089 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090 using namespace llvm::support;
1092 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094 return std::make_pair(KeyLen, DataLen);
1097 ASTDeclContextNameLookupTrait::internal_key_type
1098 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099 using namespace llvm::support;
1101 auto Kind = (DeclarationName::NameKind)*d++;
1104 case DeclarationName::Identifier:
1105 case DeclarationName::CXXLiteralOperatorName:
1106 case DeclarationName::CXXDeductionGuideName:
1107 Data = (uint64_t)Reader.getLocalIdentifier(
1108 F, endian::readNext<uint32_t, little, unaligned>(d));
1110 case DeclarationName::ObjCZeroArgSelector:
1111 case DeclarationName::ObjCOneArgSelector:
1112 case DeclarationName::ObjCMultiArgSelector:
1114 (uint64_t)Reader.getLocalSelector(
1115 F, endian::readNext<uint32_t, little, unaligned>(
1116 d)).getAsOpaquePtr();
1118 case DeclarationName::CXXOperatorName:
1119 Data = *d++; // OverloadedOperatorKind
1121 case DeclarationName::CXXConstructorName:
1122 case DeclarationName::CXXDestructorName:
1123 case DeclarationName::CXXConversionFunctionName:
1124 case DeclarationName::CXXUsingDirective:
1129 return DeclarationNameKey(Kind, Data);
1132 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133 const unsigned char *d,
1135 data_type_builder &Val) {
1136 using namespace llvm::support;
1138 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1144 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145 BitstreamCursor &Cursor,
1148 assert(Offset != 0);
1150 SavedStreamPosition SavedPosition(Cursor);
1151 Cursor.JumpToBit(Offset);
1155 unsigned Code = Cursor.ReadCode();
1156 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1157 if (RecCode != DECL_CONTEXT_LEXICAL) {
1158 Error("Expected lexical block");
1162 assert(!isa<TranslationUnitDecl>(DC) &&
1163 "expected a TU_UPDATE_LEXICAL record for TU");
1164 // If we are handling a C++ class template instantiation, we can see multiple
1165 // lexical updates for the same record. It's important that we select only one
1166 // of them, so that field numbering works properly. Just pick the first one we
1168 auto &Lex = LexicalDecls[DC];
1170 Lex = std::make_pair(
1171 &M, llvm::makeArrayRef(
1172 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1176 DC->setHasExternalLexicalStorage(true);
1180 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1181 BitstreamCursor &Cursor,
1184 assert(Offset != 0);
1186 SavedStreamPosition SavedPosition(Cursor);
1187 Cursor.JumpToBit(Offset);
1191 unsigned Code = Cursor.ReadCode();
1192 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1193 if (RecCode != DECL_CONTEXT_VISIBLE) {
1194 Error("Expected visible lookup table block");
1198 // We can't safely determine the primary context yet, so delay attaching the
1199 // lookup table until we're done with recursive deserialization.
1200 auto *Data = (const unsigned char*)Blob.data();
1201 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1205 void ASTReader::Error(StringRef Msg) const {
1206 Error(diag::err_fe_pch_malformed, Msg);
1207 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1208 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1209 Diag(diag::note_module_cache_path)
1210 << PP.getHeaderSearchInfo().getModuleCachePath();
1214 void ASTReader::Error(unsigned DiagID,
1215 StringRef Arg1, StringRef Arg2) const {
1216 if (Diags.isDiagnosticInFlight())
1217 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1219 Diag(DiagID) << Arg1 << Arg2;
1222 //===----------------------------------------------------------------------===//
1223 // Source Manager Deserialization
1224 //===----------------------------------------------------------------------===//
1226 /// Read the line table in the source manager block.
1227 /// \returns true if there was an error.
1228 bool ASTReader::ParseLineTable(ModuleFile &F,
1229 const RecordData &Record) {
1231 LineTableInfo &LineTable = SourceMgr.getLineTable();
1233 // Parse the file names
1234 std::map<int, int> FileIDs;
1235 FileIDs[-1] = -1; // For unspecified filenames.
1236 for (unsigned I = 0; Record[Idx]; ++I) {
1237 // Extract the file name
1238 auto Filename = ReadPath(F, Record, Idx);
1239 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1243 // Parse the line entries
1244 std::vector<LineEntry> Entries;
1245 while (Idx < Record.size()) {
1246 int FID = Record[Idx++];
1247 assert(FID >= 0 && "Serialized line entries for non-local file.");
1248 // Remap FileID from 1-based old view.
1249 FID += F.SLocEntryBaseID - 1;
1251 // Extract the line entries
1252 unsigned NumEntries = Record[Idx++];
1253 assert(NumEntries && "no line entries for file ID");
1255 Entries.reserve(NumEntries);
1256 for (unsigned I = 0; I != NumEntries; ++I) {
1257 unsigned FileOffset = Record[Idx++];
1258 unsigned LineNo = Record[Idx++];
1259 int FilenameID = FileIDs[Record[Idx++]];
1260 SrcMgr::CharacteristicKind FileKind
1261 = (SrcMgr::CharacteristicKind)Record[Idx++];
1262 unsigned IncludeOffset = Record[Idx++];
1263 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1264 FileKind, IncludeOffset));
1266 LineTable.AddEntry(FileID::get(FID), Entries);
1272 /// Read a source manager block
1273 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1274 using namespace SrcMgr;
1276 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1278 // Set the source-location entry cursor to the current position in
1279 // the stream. This cursor will be used to read the contents of the
1280 // source manager block initially, and then lazily read
1281 // source-location entries as needed.
1282 SLocEntryCursor = F.Stream;
1284 // The stream itself is going to skip over the source manager block.
1285 if (F.Stream.SkipBlock()) {
1286 Error("malformed block record in AST file");
1290 // Enter the source manager block.
1291 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1292 Error("malformed source manager block record in AST file");
1298 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1301 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1302 case llvm::BitstreamEntry::Error:
1303 Error("malformed block record in AST file");
1305 case llvm::BitstreamEntry::EndBlock:
1307 case llvm::BitstreamEntry::Record:
1308 // The interesting case.
1315 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1316 default: // Default behavior: ignore.
1319 case SM_SLOC_FILE_ENTRY:
1320 case SM_SLOC_BUFFER_ENTRY:
1321 case SM_SLOC_EXPANSION_ENTRY:
1322 // Once we hit one of the source location entries, we're done.
1328 /// If a header file is not found at the path that we expect it to be
1329 /// and the PCH file was moved from its original location, try to resolve the
1330 /// file by assuming that header+PCH were moved together and the header is in
1331 /// the same place relative to the PCH.
1333 resolveFileRelativeToOriginalDir(const std::string &Filename,
1334 const std::string &OriginalDir,
1335 const std::string &CurrDir) {
1336 assert(OriginalDir != CurrDir &&
1337 "No point trying to resolve the file if the PCH dir didn't change");
1339 using namespace llvm::sys;
1341 SmallString<128> filePath(Filename);
1342 fs::make_absolute(filePath);
1343 assert(path::is_absolute(OriginalDir));
1344 SmallString<128> currPCHPath(CurrDir);
1346 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1347 fileDirE = path::end(path::parent_path(filePath));
1348 path::const_iterator origDirI = path::begin(OriginalDir),
1349 origDirE = path::end(OriginalDir);
1350 // Skip the common path components from filePath and OriginalDir.
1351 while (fileDirI != fileDirE && origDirI != origDirE &&
1352 *fileDirI == *origDirI) {
1356 for (; origDirI != origDirE; ++origDirI)
1357 path::append(currPCHPath, "..");
1358 path::append(currPCHPath, fileDirI, fileDirE);
1359 path::append(currPCHPath, path::filename(Filename));
1360 return currPCHPath.str();
1363 bool ASTReader::ReadSLocEntry(int ID) {
1367 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1368 Error("source location entry ID out-of-range for AST file");
1372 // Local helper to read the (possibly-compressed) buffer data following the
1374 auto ReadBuffer = [this](
1375 BitstreamCursor &SLocEntryCursor,
1376 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1379 unsigned Code = SLocEntryCursor.ReadCode();
1380 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1382 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1383 if (!llvm::zlib::isAvailable()) {
1384 Error("zlib is not available");
1387 SmallString<0> Uncompressed;
1389 llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1390 Error("could not decompress embedded file contents: " +
1391 llvm::toString(std::move(E)));
1394 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1395 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1396 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1398 Error("AST record has invalid code");
1403 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1404 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1405 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1406 unsigned BaseOffset = F->SLocEntryBaseOffset;
1408 ++NumSLocEntriesRead;
1409 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1410 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1411 Error("incorrectly-formatted source location entry in AST file");
1417 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1419 Error("incorrectly-formatted source location entry in AST file");
1422 case SM_SLOC_FILE_ENTRY: {
1423 // We will detect whether a file changed and return 'Failure' for it, but
1424 // we will also try to fail gracefully by setting up the SLocEntry.
1425 unsigned InputID = Record[4];
1426 InputFile IF = getInputFile(*F, InputID);
1427 const FileEntry *File = IF.getFile();
1428 bool OverriddenBuffer = IF.isOverridden();
1430 // Note that we only check if a File was returned. If it was out-of-date
1431 // we have complained but we will continue creating a FileID to recover
1436 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1437 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1438 // This is the module's main file.
1439 IncludeLoc = getImportLocation(F);
1441 SrcMgr::CharacteristicKind
1442 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1443 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1444 ID, BaseOffset + Record[0]);
1445 SrcMgr::FileInfo &FileInfo =
1446 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1447 FileInfo.NumCreatedFIDs = Record[5];
1449 FileInfo.setHasLineDirectives();
1451 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1452 unsigned NumFileDecls = Record[7];
1453 if (NumFileDecls && ContextObj) {
1454 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1455 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1459 const SrcMgr::ContentCache *ContentCache
1460 = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1461 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1462 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1463 !ContentCache->getRawBuffer()) {
1464 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1467 SourceMgr.overrideFileContents(File, std::move(Buffer));
1473 case SM_SLOC_BUFFER_ENTRY: {
1474 const char *Name = Blob.data();
1475 unsigned Offset = Record[0];
1476 SrcMgr::CharacteristicKind
1477 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1478 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1479 if (IncludeLoc.isInvalid() && F->isModule()) {
1480 IncludeLoc = getImportLocation(F);
1483 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1486 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1487 BaseOffset + Offset, IncludeLoc);
1491 case SM_SLOC_EXPANSION_ENTRY: {
1492 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1493 SourceMgr.createExpansionLoc(SpellingLoc,
1494 ReadSourceLocation(*F, Record[2]),
1495 ReadSourceLocation(*F, Record[3]),
1499 BaseOffset + Record[0]);
1507 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1509 return std::make_pair(SourceLocation(), "");
1511 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1512 Error("source location entry ID out-of-range for AST file");
1513 return std::make_pair(SourceLocation(), "");
1516 // Find which module file this entry lands in.
1517 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1519 return std::make_pair(SourceLocation(), "");
1521 // FIXME: Can we map this down to a particular submodule? That would be
1523 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1526 /// Find the location where the module F is imported.
1527 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1528 if (F->ImportLoc.isValid())
1529 return F->ImportLoc;
1531 // Otherwise we have a PCH. It's considered to be "imported" at the first
1532 // location of its includer.
1533 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1534 // Main file is the importer.
1535 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1536 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1538 return F->ImportedBy[0]->FirstLoc;
1541 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1542 /// specified cursor. Read the abbreviations that are at the top of the block
1543 /// and then leave the cursor pointing into the block.
1544 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1545 if (Cursor.EnterSubBlock(BlockID))
1549 uint64_t Offset = Cursor.GetCurrentBitNo();
1550 unsigned Code = Cursor.ReadCode();
1552 // We expect all abbrevs to be at the start of the block.
1553 if (Code != llvm::bitc::DEFINE_ABBREV) {
1554 Cursor.JumpToBit(Offset);
1557 Cursor.ReadAbbrevRecord();
1561 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1565 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1566 Tok.setLength(Record[Idx++]);
1567 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1568 Tok.setIdentifierInfo(II);
1569 Tok.setKind((tok::TokenKind)Record[Idx++]);
1570 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1574 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1575 BitstreamCursor &Stream = F.MacroCursor;
1577 // Keep track of where we are in the stream, then jump back there
1578 // after reading this macro.
1579 SavedStreamPosition SavedPosition(Stream);
1581 Stream.JumpToBit(Offset);
1583 SmallVector<IdentifierInfo*, 16> MacroParams;
1584 MacroInfo *Macro = nullptr;
1587 // Advance to the next record, but if we get to the end of the block, don't
1588 // pop it (removing all the abbreviations from the cursor) since we want to
1589 // be able to reseek within the block and read entries.
1590 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1591 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1593 switch (Entry.Kind) {
1594 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1595 case llvm::BitstreamEntry::Error:
1596 Error("malformed block record in AST file");
1598 case llvm::BitstreamEntry::EndBlock:
1600 case llvm::BitstreamEntry::Record:
1601 // The interesting case.
1607 PreprocessorRecordTypes RecType =
1608 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1610 case PP_MODULE_MACRO:
1611 case PP_MACRO_DIRECTIVE_HISTORY:
1614 case PP_MACRO_OBJECT_LIKE:
1615 case PP_MACRO_FUNCTION_LIKE: {
1616 // If we already have a macro, that means that we've hit the end
1617 // of the definition of the macro we were looking for. We're
1622 unsigned NextIndex = 1; // Skip identifier ID.
1623 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1624 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1625 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1626 MI->setIsUsed(Record[NextIndex++]);
1627 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1629 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1630 // Decode function-like macro info.
1631 bool isC99VarArgs = Record[NextIndex++];
1632 bool isGNUVarArgs = Record[NextIndex++];
1633 bool hasCommaPasting = Record[NextIndex++];
1634 MacroParams.clear();
1635 unsigned NumArgs = Record[NextIndex++];
1636 for (unsigned i = 0; i != NumArgs; ++i)
1637 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1639 // Install function-like macro info.
1640 MI->setIsFunctionLike();
1641 if (isC99VarArgs) MI->setIsC99Varargs();
1642 if (isGNUVarArgs) MI->setIsGNUVarargs();
1643 if (hasCommaPasting) MI->setHasCommaPasting();
1644 MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1647 // Remember that we saw this macro last so that we add the tokens that
1648 // form its body to it.
1651 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1652 Record[NextIndex]) {
1653 // We have a macro definition. Register the association
1654 PreprocessedEntityID
1655 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1656 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1657 PreprocessingRecord::PPEntityID PPID =
1658 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1659 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1660 PPRec.getPreprocessedEntity(PPID));
1662 PPRec.RegisterMacroDefinition(Macro, PPDef);
1670 // If we see a TOKEN before a PP_MACRO_*, then the file is
1671 // erroneous, just pretend we didn't see this.
1675 Token Tok = ReadToken(F, Record, Idx);
1676 Macro->AddTokenToBody(Tok);
1683 PreprocessedEntityID
1684 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1685 unsigned LocalID) const {
1686 if (!M.ModuleOffsetMap.empty())
1687 ReadModuleOffsetMap(M);
1689 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1690 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1691 assert(I != M.PreprocessedEntityRemap.end()
1692 && "Invalid index into preprocessed entity index remap");
1694 return LocalID + I->second;
1697 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1698 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1701 HeaderFileInfoTrait::internal_key_type
1702 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1703 internal_key_type ikey = {FE->getSize(),
1704 M.HasTimestamps ? FE->getModificationTime() : 0,
1705 FE->getName(), /*Imported*/ false};
1709 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1710 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1713 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1716 // Determine whether the actual files are equivalent.
1717 FileManager &FileMgr = Reader.getFileManager();
1718 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1720 return FileMgr.getFile(Key.Filename);
1722 std::string Resolved = Key.Filename;
1723 Reader.ResolveImportedPath(M, Resolved);
1724 return FileMgr.getFile(Resolved);
1727 const FileEntry *FEA = GetFile(a);
1728 const FileEntry *FEB = GetFile(b);
1729 return FEA && FEA == FEB;
1732 std::pair<unsigned, unsigned>
1733 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1734 using namespace llvm::support;
1736 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1737 unsigned DataLen = (unsigned) *d++;
1738 return std::make_pair(KeyLen, DataLen);
1741 HeaderFileInfoTrait::internal_key_type
1742 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1743 using namespace llvm::support;
1745 internal_key_type ikey;
1746 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1747 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1748 ikey.Filename = (const char *)d;
1749 ikey.Imported = true;
1753 HeaderFileInfoTrait::data_type
1754 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1756 using namespace llvm::support;
1758 const unsigned char *End = d + DataLen;
1760 unsigned Flags = *d++;
1761 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1762 HFI.isImport |= (Flags >> 5) & 0x01;
1763 HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1764 HFI.DirInfo = (Flags >> 1) & 0x07;
1765 HFI.IndexHeaderMapHeader = Flags & 0x01;
1766 // FIXME: Find a better way to handle this. Maybe just store a
1767 // "has been included" flag?
1768 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1770 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1771 M, endian::readNext<uint32_t, little, unaligned>(d));
1772 if (unsigned FrameworkOffset =
1773 endian::readNext<uint32_t, little, unaligned>(d)) {
1774 // The framework offset is 1 greater than the actual offset,
1775 // since 0 is used as an indicator for "no framework name".
1776 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1777 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1780 assert((End - d) % 4 == 0 &&
1781 "Wrong data length in HeaderFileInfo deserialization");
1783 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1784 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1787 // This header is part of a module. Associate it with the module to enable
1788 // implicit module import.
1789 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1790 Module *Mod = Reader.getSubmodule(GlobalSMID);
1791 FileManager &FileMgr = Reader.getFileManager();
1793 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1795 std::string Filename = key.Filename;
1797 Reader.ResolveImportedPath(M, Filename);
1798 // FIXME: This is not always the right filename-as-written, but we're not
1799 // going to use this information to rebuild the module, so it doesn't make
1800 // a lot of difference.
1801 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1802 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1803 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1806 // This HeaderFileInfo was externally loaded.
1807 HFI.External = true;
1812 void ASTReader::addPendingMacro(IdentifierInfo *II,
1814 uint64_t MacroDirectivesOffset) {
1815 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1816 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1819 void ASTReader::ReadDefinedMacros() {
1820 // Note that we are loading defined macros.
1821 Deserializing Macros(this);
1823 for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1824 BitstreamCursor &MacroCursor = I.MacroCursor;
1826 // If there was no preprocessor block, skip this file.
1827 if (MacroCursor.getBitcodeBytes().empty())
1830 BitstreamCursor Cursor = MacroCursor;
1831 Cursor.JumpToBit(I.MacroStartOffset);
1835 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1838 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1839 case llvm::BitstreamEntry::Error:
1840 Error("malformed block record in AST file");
1842 case llvm::BitstreamEntry::EndBlock:
1845 case llvm::BitstreamEntry::Record:
1847 switch (Cursor.readRecord(E.ID, Record)) {
1848 default: // Default behavior: ignore.
1851 case PP_MACRO_OBJECT_LIKE:
1852 case PP_MACRO_FUNCTION_LIKE: {
1853 IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1854 if (II->isOutOfDate())
1855 updateOutOfDateIdentifier(*II);
1872 /// Visitor class used to look up identifirs in an AST file.
1873 class IdentifierLookupVisitor {
1876 unsigned PriorGeneration;
1877 unsigned &NumIdentifierLookups;
1878 unsigned &NumIdentifierLookupHits;
1879 IdentifierInfo *Found = nullptr;
1882 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1883 unsigned &NumIdentifierLookups,
1884 unsigned &NumIdentifierLookupHits)
1885 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1886 PriorGeneration(PriorGeneration),
1887 NumIdentifierLookups(NumIdentifierLookups),
1888 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1890 bool operator()(ModuleFile &M) {
1891 // If we've already searched this module file, skip it now.
1892 if (M.Generation <= PriorGeneration)
1895 ASTIdentifierLookupTable *IdTable
1896 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1900 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1902 ++NumIdentifierLookups;
1903 ASTIdentifierLookupTable::iterator Pos =
1904 IdTable->find_hashed(Name, NameHash, &Trait);
1905 if (Pos == IdTable->end())
1908 // Dereferencing the iterator has the effect of building the
1909 // IdentifierInfo node and populating it with the various
1910 // declarations it needs.
1911 ++NumIdentifierLookupHits;
1916 // Retrieve the identifier info found within the module
1918 IdentifierInfo *getIdentifierInfo() const { return Found; }
1923 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1924 // Note that we are loading an identifier.
1925 Deserializing AnIdentifier(this);
1927 unsigned PriorGeneration = 0;
1928 if (getContext().getLangOpts().Modules)
1929 PriorGeneration = IdentifierGeneration[&II];
1931 // If there is a global index, look there first to determine which modules
1932 // provably do not have any results for this identifier.
1933 GlobalModuleIndex::HitSet Hits;
1934 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1935 if (!loadGlobalIndex()) {
1936 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1941 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1942 NumIdentifierLookups,
1943 NumIdentifierLookupHits);
1944 ModuleMgr.visit(Visitor, HitsPtr);
1945 markIdentifierUpToDate(&II);
1948 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1952 II->setOutOfDate(false);
1954 // Update the generation for this identifier.
1955 if (getContext().getLangOpts().Modules)
1956 IdentifierGeneration[II] = getGeneration();
1959 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1960 const PendingMacroInfo &PMInfo) {
1961 ModuleFile &M = *PMInfo.M;
1963 BitstreamCursor &Cursor = M.MacroCursor;
1964 SavedStreamPosition SavedPosition(Cursor);
1965 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1967 struct ModuleMacroRecord {
1968 SubmoduleID SubModID;
1970 SmallVector<SubmoduleID, 8> Overrides;
1972 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1974 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1975 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1979 llvm::BitstreamEntry Entry =
1980 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1981 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1982 Error("malformed block record in AST file");
1987 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1988 case PP_MACRO_DIRECTIVE_HISTORY:
1991 case PP_MODULE_MACRO: {
1992 ModuleMacros.push_back(ModuleMacroRecord());
1993 auto &Info = ModuleMacros.back();
1994 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1995 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1996 for (int I = 2, N = Record.size(); I != N; ++I)
1997 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2002 Error("malformed block record in AST file");
2006 // We found the macro directive history; that's the last record
2011 // Module macros are listed in reverse dependency order.
2013 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2014 llvm::SmallVector<ModuleMacro*, 8> Overrides;
2015 for (auto &MMR : ModuleMacros) {
2017 for (unsigned ModID : MMR.Overrides) {
2018 Module *Mod = getSubmodule(ModID);
2019 auto *Macro = PP.getModuleMacro(Mod, II);
2020 assert(Macro && "missing definition for overridden macro");
2021 Overrides.push_back(Macro);
2024 bool Inserted = false;
2025 Module *Owner = getSubmodule(MMR.SubModID);
2026 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2030 // Don't read the directive history for a module; we don't have anywhere
2035 // Deserialize the macro directives history in reverse source-order.
2036 MacroDirective *Latest = nullptr, *Earliest = nullptr;
2037 unsigned Idx = 0, N = Record.size();
2039 MacroDirective *MD = nullptr;
2040 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2041 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2043 case MacroDirective::MD_Define: {
2044 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2045 MD = PP.AllocateDefMacroDirective(MI, Loc);
2048 case MacroDirective::MD_Undefine:
2049 MD = PP.AllocateUndefMacroDirective(Loc);
2051 case MacroDirective::MD_Visibility:
2052 bool isPublic = Record[Idx++];
2053 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2060 Earliest->setPrevious(MD);
2065 PP.setLoadedMacroDirective(II, Earliest, Latest);
2068 ASTReader::InputFileInfo
2069 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2070 // Go find this input file.
2071 BitstreamCursor &Cursor = F.InputFilesCursor;
2072 SavedStreamPosition SavedPosition(Cursor);
2073 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2075 unsigned Code = Cursor.ReadCode();
2079 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2080 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2081 "invalid record type for input file");
2084 assert(Record[0] == ID && "Bogus stored ID or offset");
2086 R.StoredSize = static_cast<off_t>(Record[1]);
2087 R.StoredTime = static_cast<time_t>(Record[2]);
2088 R.Overridden = static_cast<bool>(Record[3]);
2089 R.Transient = static_cast<bool>(Record[4]);
2090 R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2092 ResolveImportedPath(F, R.Filename);
2096 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2097 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2098 // If this ID is bogus, just return an empty input file.
2099 if (ID == 0 || ID > F.InputFilesLoaded.size())
2102 // If we've already loaded this input file, return it.
2103 if (F.InputFilesLoaded[ID-1].getFile())
2104 return F.InputFilesLoaded[ID-1];
2106 if (F.InputFilesLoaded[ID-1].isNotFound())
2109 // Go find this input file.
2110 BitstreamCursor &Cursor = F.InputFilesCursor;
2111 SavedStreamPosition SavedPosition(Cursor);
2112 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2114 InputFileInfo FI = readInputFileInfo(F, ID);
2115 off_t StoredSize = FI.StoredSize;
2116 time_t StoredTime = FI.StoredTime;
2117 bool Overridden = FI.Overridden;
2118 bool Transient = FI.Transient;
2119 StringRef Filename = FI.Filename;
2121 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2122 // If we didn't find the file, resolve it relative to the
2123 // original directory from which this AST file was created.
2124 if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2125 F.OriginalDir != F.BaseDirectory) {
2126 std::string Resolved = resolveFileRelativeToOriginalDir(
2127 Filename, F.OriginalDir, F.BaseDirectory);
2128 if (!Resolved.empty())
2129 File = FileMgr.getFile(Resolved);
2132 // For an overridden file, create a virtual file with the stored
2134 if ((Overridden || Transient) && File == nullptr)
2135 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2137 if (File == nullptr) {
2139 std::string ErrorStr = "could not find file '";
2140 ErrorStr += Filename;
2141 ErrorStr += "' referenced by AST file '";
2142 ErrorStr += F.FileName;
2146 // Record that we didn't find the file.
2147 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2151 // Check if there was a request to override the contents of the file
2152 // that was part of the precompiled header. Overriding such a file
2153 // can lead to problems when lexing using the source locations from the
2155 SourceManager &SM = getSourceManager();
2156 // FIXME: Reject if the overrides are different.
2157 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2159 Error(diag::err_fe_pch_file_overridden, Filename);
2160 // After emitting the diagnostic, recover by disabling the override so
2161 // that the original file will be used.
2163 // FIXME: This recovery is just as broken as the original state; there may
2164 // be another precompiled module that's using the overridden contents, or
2165 // we might be half way through parsing it. Instead, we should treat the
2166 // overridden contents as belonging to a separate FileEntry.
2167 SM.disableFileContentsOverride(File);
2168 // The FileEntry is a virtual file entry with the size of the contents
2169 // that would override the original contents. Set it to the original's
2171 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2172 StoredSize, StoredTime);
2175 bool IsOutOfDate = false;
2177 // For an overridden file, there is nothing to validate.
2178 if (!Overridden && //
2179 (StoredSize != File->getSize() ||
2180 (StoredTime && StoredTime != File->getModificationTime() &&
2184 // Build a list of the PCH imports that got us here (in reverse).
2185 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2186 while (!ImportStack.back()->ImportedBy.empty())
2187 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2189 // The top-level PCH is stale.
2190 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2191 unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2192 if (DiagnosticKind == 0)
2193 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2194 else if (DiagnosticKind == 1)
2195 Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2197 Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2199 // Print the import stack.
2200 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2201 Diag(diag::note_pch_required_by)
2202 << Filename << ImportStack[0]->FileName;
2203 for (unsigned I = 1; I < ImportStack.size(); ++I)
2204 Diag(diag::note_pch_required_by)
2205 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2208 if (!Diags.isDiagnosticInFlight())
2209 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2214 // FIXME: If the file is overridden and we've already opened it,
2215 // issue an error (or split it into a separate FileEntry).
2217 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2219 // Note that we've loaded this input file.
2220 F.InputFilesLoaded[ID-1] = IF;
2224 /// If we are loading a relocatable PCH or module file, and the filename
2225 /// is not an absolute path, add the system or module root to the beginning of
2227 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2228 // Resolve relative to the base directory, if we have one.
2229 if (!M.BaseDirectory.empty())
2230 return ResolveImportedPath(Filename, M.BaseDirectory);
2233 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2234 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2237 SmallString<128> Buffer;
2238 llvm::sys::path::append(Buffer, Prefix, Filename);
2239 Filename.assign(Buffer.begin(), Buffer.end());
2242 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2244 case ASTReader::Failure: return true;
2245 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2246 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2247 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2248 case ASTReader::ConfigurationMismatch:
2249 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2250 case ASTReader::HadErrors: return true;
2251 case ASTReader::Success: return false;
2254 llvm_unreachable("unknown ASTReadResult");
2257 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2258 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2259 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2260 std::string &SuggestedPredefines) {
2261 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2264 // Read all of the records in the options block.
2266 ASTReadResult Result = Success;
2268 llvm::BitstreamEntry Entry = Stream.advance();
2270 switch (Entry.Kind) {
2271 case llvm::BitstreamEntry::Error:
2272 case llvm::BitstreamEntry::SubBlock:
2275 case llvm::BitstreamEntry::EndBlock:
2278 case llvm::BitstreamEntry::Record:
2279 // The interesting case.
2283 // Read and process a record.
2285 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2286 case LANGUAGE_OPTIONS: {
2287 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2288 if (ParseLanguageOptions(Record, Complain, Listener,
2289 AllowCompatibleConfigurationMismatch))
2290 Result = ConfigurationMismatch;
2294 case TARGET_OPTIONS: {
2295 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2296 if (ParseTargetOptions(Record, Complain, Listener,
2297 AllowCompatibleConfigurationMismatch))
2298 Result = ConfigurationMismatch;
2302 case FILE_SYSTEM_OPTIONS: {
2303 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2304 if (!AllowCompatibleConfigurationMismatch &&
2305 ParseFileSystemOptions(Record, Complain, Listener))
2306 Result = ConfigurationMismatch;
2310 case HEADER_SEARCH_OPTIONS: {
2311 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2312 if (!AllowCompatibleConfigurationMismatch &&
2313 ParseHeaderSearchOptions(Record, Complain, Listener))
2314 Result = ConfigurationMismatch;
2318 case PREPROCESSOR_OPTIONS:
2319 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2320 if (!AllowCompatibleConfigurationMismatch &&
2321 ParsePreprocessorOptions(Record, Complain, Listener,
2322 SuggestedPredefines))
2323 Result = ConfigurationMismatch;
2329 ASTReader::ASTReadResult
2330 ASTReader::ReadControlBlock(ModuleFile &F,
2331 SmallVectorImpl<ImportedModule> &Loaded,
2332 const ModuleFile *ImportedBy,
2333 unsigned ClientLoadCapabilities) {
2334 BitstreamCursor &Stream = F.Stream;
2335 ASTReadResult Result = Success;
2337 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2338 Error("malformed block record in AST file");
2342 // Lambda to read the unhashed control block the first time it's called.
2344 // For PCM files, the unhashed control block cannot be read until after the
2345 // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2346 // need to look ahead before reading the IMPORTS record. For consistency,
2347 // this block is always read somehow (see BitstreamEntry::EndBlock).
2348 bool HasReadUnhashedControlBlock = false;
2349 auto readUnhashedControlBlockOnce = [&]() {
2350 if (!HasReadUnhashedControlBlock) {
2351 HasReadUnhashedControlBlock = true;
2352 if (ASTReadResult Result =
2353 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2359 // Read all of the records and blocks in the control block.
2361 unsigned NumInputs = 0;
2362 unsigned NumUserInputs = 0;
2364 llvm::BitstreamEntry Entry = Stream.advance();
2366 switch (Entry.Kind) {
2367 case llvm::BitstreamEntry::Error:
2368 Error("malformed block record in AST file");
2370 case llvm::BitstreamEntry::EndBlock: {
2371 // Validate the module before returning. This call catches an AST with
2372 // no module name and no imports.
2373 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2376 // Validate input files.
2377 const HeaderSearchOptions &HSOpts =
2378 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2380 // All user input files reside at the index range [0, NumUserInputs), and
2381 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2382 // loaded module files, ignore missing inputs.
2383 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2384 F.Kind != MK_PrebuiltModule) {
2385 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2387 // If we are reading a module, we will create a verification timestamp,
2388 // so we verify all input files. Otherwise, verify only user input
2391 unsigned N = NumUserInputs;
2392 if (ValidateSystemInputs ||
2393 (HSOpts.ModulesValidateOncePerBuildSession &&
2394 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2395 F.Kind == MK_ImplicitModule))
2398 for (unsigned I = 0; I < N; ++I) {
2399 InputFile IF = getInputFile(F, I+1, Complain);
2400 if (!IF.getFile() || IF.isOutOfDate())
2406 Listener->visitModuleFile(F.FileName, F.Kind);
2408 if (Listener && Listener->needsInputFileVisitation()) {
2409 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2411 for (unsigned I = 0; I < N; ++I) {
2412 bool IsSystem = I >= NumUserInputs;
2413 InputFileInfo FI = readInputFileInfo(F, I+1);
2414 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2415 F.Kind == MK_ExplicitModule ||
2416 F.Kind == MK_PrebuiltModule);
2423 case llvm::BitstreamEntry::SubBlock:
2425 case INPUT_FILES_BLOCK_ID:
2426 F.InputFilesCursor = Stream;
2427 if (Stream.SkipBlock() || // Skip with the main cursor
2428 // Read the abbreviations
2429 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2430 Error("malformed block record in AST file");
2435 case OPTIONS_BLOCK_ID:
2436 // If we're reading the first module for this group, check its options
2437 // are compatible with ours. For modules it imports, no further checking
2438 // is required, because we checked them when we built it.
2439 if (Listener && !ImportedBy) {
2440 // Should we allow the configuration of the module file to differ from
2441 // the configuration of the current translation unit in a compatible
2444 // FIXME: Allow this for files explicitly specified with -include-pch.
2445 bool AllowCompatibleConfigurationMismatch =
2446 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2448 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2449 AllowCompatibleConfigurationMismatch,
2450 *Listener, SuggestedPredefines);
2451 if (Result == Failure) {
2452 Error("malformed block record in AST file");
2456 if (DisableValidation ||
2457 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2460 // If we can't load the module, exit early since we likely
2461 // will rebuild the module anyway. The stream may be in the
2462 // middle of a block.
2463 if (Result != Success)
2465 } else if (Stream.SkipBlock()) {
2466 Error("malformed block record in AST file");
2472 if (Stream.SkipBlock()) {
2473 Error("malformed block record in AST file");
2479 case llvm::BitstreamEntry::Record:
2480 // The interesting case.
2484 // Read and process a record.
2487 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2489 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2490 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2491 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2492 : diag::err_pch_version_too_new);
2493 return VersionMismatch;
2496 bool hasErrors = Record[7];
2497 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2498 Diag(diag::err_pch_with_compiler_errors);
2502 Diags.ErrorOccurred = true;
2503 Diags.UncompilableErrorOccurred = true;
2504 Diags.UnrecoverableErrorOccurred = true;
2507 F.RelocatablePCH = Record[4];
2508 // Relative paths in a relocatable PCH are relative to our sysroot.
2509 if (F.RelocatablePCH)
2510 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2512 F.HasTimestamps = Record[5];
2514 F.PCHHasObjectFile = Record[6];
2516 const std::string &CurBranch = getClangFullRepositoryVersion();
2517 StringRef ASTBranch = Blob;
2518 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2519 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2520 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2521 return VersionMismatch;
2527 // Validate the AST before processing any imports (otherwise, untangling
2528 // them can be error-prone and expensive). A module will have a name and
2529 // will already have been validated, but this catches the PCH case.
2530 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2533 // Load each of the imported PCH files.
2534 unsigned Idx = 0, N = Record.size();
2536 // Read information about the AST file.
2537 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2538 // The import location will be the local one for now; we will adjust
2539 // all import locations of module imports after the global source
2540 // location info are setup, in ReadAST.
2541 SourceLocation ImportLoc =
2542 ReadUntranslatedSourceLocation(Record[Idx++]);
2543 off_t StoredSize = (off_t)Record[Idx++];
2544 time_t StoredModTime = (time_t)Record[Idx++];
2545 ASTFileSignature StoredSignature = {
2546 {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2547 (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2548 (uint32_t)Record[Idx++]}}};
2550 std::string ImportedName = ReadString(Record, Idx);
2551 std::string ImportedFile;
2553 // For prebuilt and explicit modules first consult the file map for
2554 // an override. Note that here we don't search prebuilt module
2555 // directories, only the explicit name to file mappings. Also, we will
2556 // still verify the size/signature making sure it is essentially the
2557 // same file but perhaps in a different location.
2558 if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2559 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2560 ImportedName, /*FileMapOnly*/ true);
2562 if (ImportedFile.empty())
2563 ImportedFile = ReadPath(F, Record, Idx);
2565 SkipPath(Record, Idx);
2567 // If our client can't cope with us being out of date, we can't cope with
2568 // our dependency being missing.
2569 unsigned Capabilities = ClientLoadCapabilities;
2570 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2571 Capabilities &= ~ARR_Missing;
2573 // Load the AST file.
2574 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2575 Loaded, StoredSize, StoredModTime,
2576 StoredSignature, Capabilities);
2578 // If we diagnosed a problem, produce a backtrace.
2579 if (isDiagnosedResult(Result, Capabilities))
2580 Diag(diag::note_module_file_imported_by)
2581 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2584 case Failure: return Failure;
2585 // If we have to ignore the dependency, we'll have to ignore this too.
2587 case OutOfDate: return OutOfDate;
2588 case VersionMismatch: return VersionMismatch;
2589 case ConfigurationMismatch: return ConfigurationMismatch;
2590 case HadErrors: return HadErrors;
2591 case Success: break;
2598 F.OriginalSourceFileID = FileID::get(Record[0]);
2599 F.ActualOriginalSourceFileName = Blob;
2600 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2601 ResolveImportedPath(F, F.OriginalSourceFileName);
2604 case ORIGINAL_FILE_ID:
2605 F.OriginalSourceFileID = FileID::get(Record[0]);
2608 case ORIGINAL_PCH_DIR:
2609 F.OriginalDir = Blob;
2613 F.ModuleName = Blob;
2615 Listener->ReadModuleName(F.ModuleName);
2617 // Validate the AST as soon as we have a name so we can exit early on
2619 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2624 case MODULE_DIRECTORY: {
2625 assert(!F.ModuleName.empty() &&
2626 "MODULE_DIRECTORY found before MODULE_NAME");
2627 // If we've already loaded a module map file covering this module, we may
2628 // have a better path for it (relative to the current build).
2629 Module *M = PP.getHeaderSearchInfo().lookupModule(
2630 F.ModuleName, /*AllowSearch*/ true,
2631 /*AllowExtraModuleMapSearch*/ true);
2632 if (M && M->Directory) {
2633 // If we're implicitly loading a module, the base directory can't
2634 // change between the build and use.
2635 // Don't emit module relocation error if we have -fno-validate-pch
2636 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2637 F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2638 const DirectoryEntry *BuildDir =
2639 PP.getFileManager().getDirectory(Blob);
2640 if (!BuildDir || BuildDir != M->Directory) {
2641 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2642 Diag(diag::err_imported_module_relocated)
2643 << F.ModuleName << Blob << M->Directory->getName();
2647 F.BaseDirectory = M->Directory->getName();
2649 F.BaseDirectory = Blob;
2654 case MODULE_MAP_FILE:
2655 if (ASTReadResult Result =
2656 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2660 case INPUT_FILE_OFFSETS:
2661 NumInputs = Record[0];
2662 NumUserInputs = Record[1];
2663 F.InputFileOffsets =
2664 (const llvm::support::unaligned_uint64_t *)Blob.data();
2665 F.InputFilesLoaded.resize(NumInputs);
2666 F.NumUserInputFiles = NumUserInputs;
2672 ASTReader::ASTReadResult
2673 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2674 BitstreamCursor &Stream = F.Stream;
2676 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2677 Error("malformed block record in AST file");
2681 // Read all of the records and blocks for the AST file.
2684 llvm::BitstreamEntry Entry = Stream.advance();
2686 switch (Entry.Kind) {
2687 case llvm::BitstreamEntry::Error:
2688 Error("error at end of module block in AST file");
2690 case llvm::BitstreamEntry::EndBlock:
2691 // Outside of C++, we do not store a lookup map for the translation unit.
2692 // Instead, mark it as needing a lookup map to be built if this module
2693 // contains any declarations lexically within it (which it always does!).
2694 // This usually has no cost, since we very rarely need the lookup map for
2695 // the translation unit outside C++.
2696 if (ASTContext *Ctx = ContextObj) {
2697 DeclContext *DC = Ctx->getTranslationUnitDecl();
2698 if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2699 DC->setMustBuildLookupTable();
2703 case llvm::BitstreamEntry::SubBlock:
2705 case DECLTYPES_BLOCK_ID:
2706 // We lazily load the decls block, but we want to set up the
2707 // DeclsCursor cursor to point into it. Clone our current bitcode
2708 // cursor to it, enter the block and read the abbrevs in that block.
2709 // With the main cursor, we just skip over it.
2710 F.DeclsCursor = Stream;
2711 if (Stream.SkipBlock() || // Skip with the main cursor.
2712 // Read the abbrevs.
2713 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2714 Error("malformed block record in AST file");
2719 case PREPROCESSOR_BLOCK_ID:
2720 F.MacroCursor = Stream;
2721 if (!PP.getExternalSource())
2722 PP.setExternalSource(this);
2724 if (Stream.SkipBlock() ||
2725 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2726 Error("malformed block record in AST file");
2729 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2732 case PREPROCESSOR_DETAIL_BLOCK_ID:
2733 F.PreprocessorDetailCursor = Stream;
2734 if (Stream.SkipBlock() ||
2735 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2736 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2737 Error("malformed preprocessor detail record in AST file");
2740 F.PreprocessorDetailStartOffset
2741 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2743 if (!PP.getPreprocessingRecord())
2744 PP.createPreprocessingRecord();
2745 if (!PP.getPreprocessingRecord()->getExternalSource())
2746 PP.getPreprocessingRecord()->SetExternalSource(*this);
2749 case SOURCE_MANAGER_BLOCK_ID:
2750 if (ReadSourceManagerBlock(F))
2754 case SUBMODULE_BLOCK_ID:
2755 if (ASTReadResult Result =
2756 ReadSubmoduleBlock(F, ClientLoadCapabilities))
2760 case COMMENTS_BLOCK_ID: {
2761 BitstreamCursor C = Stream;
2762 if (Stream.SkipBlock() ||
2763 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2764 Error("malformed comments block in AST file");
2767 CommentsCursors.push_back(std::make_pair(C, &F));
2772 if (Stream.SkipBlock()) {
2773 Error("malformed block record in AST file");
2780 case llvm::BitstreamEntry::Record:
2781 // The interesting case.
2785 // Read and process a record.
2789 (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2791 // If we're not loading an AST context, we don't care about most records.
2793 switch (RecordType) {
2794 case IDENTIFIER_TABLE:
2795 case IDENTIFIER_OFFSET:
2796 case INTERESTING_IDENTIFIERS:
2798 case PP_CONDITIONAL_STACK:
2799 case PP_COUNTER_VALUE:
2800 case SOURCE_LOCATION_OFFSETS:
2801 case MODULE_OFFSET_MAP:
2802 case SOURCE_MANAGER_LINE_TABLE:
2803 case SOURCE_LOCATION_PRELOADS:
2804 case PPD_ENTITIES_OFFSETS:
2805 case HEADER_SEARCH_TABLE:
2806 case IMPORTED_MODULES:
2814 switch (RecordType) {
2815 default: // Default behavior: ignore.
2819 if (F.LocalNumTypes != 0) {
2820 Error("duplicate TYPE_OFFSET record in AST file");
2823 F.TypeOffsets = (const uint32_t *)Blob.data();
2824 F.LocalNumTypes = Record[0];
2825 unsigned LocalBaseTypeIndex = Record[1];
2826 F.BaseTypeIndex = getTotalNumTypes();
2828 if (F.LocalNumTypes > 0) {
2829 // Introduce the global -> local mapping for types within this module.
2830 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2832 // Introduce the local -> global mapping for types within this module.
2833 F.TypeRemap.insertOrReplace(
2834 std::make_pair(LocalBaseTypeIndex,
2835 F.BaseTypeIndex - LocalBaseTypeIndex));
2837 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2843 if (F.LocalNumDecls != 0) {
2844 Error("duplicate DECL_OFFSET record in AST file");
2847 F.DeclOffsets = (const DeclOffset *)Blob.data();
2848 F.LocalNumDecls = Record[0];
2849 unsigned LocalBaseDeclID = Record[1];
2850 F.BaseDeclID = getTotalNumDecls();
2852 if (F.LocalNumDecls > 0) {
2853 // Introduce the global -> local mapping for declarations within this
2855 GlobalDeclMap.insert(
2856 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2858 // Introduce the local -> global mapping for declarations within this
2860 F.DeclRemap.insertOrReplace(
2861 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2863 // Introduce the global -> local mapping for declarations within this
2865 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2867 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2872 case TU_UPDATE_LEXICAL: {
2873 DeclContext *TU = ContextObj->getTranslationUnitDecl();
2874 LexicalContents Contents(
2875 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2877 static_cast<unsigned int>(Blob.size() / 4));
2878 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2879 TU->setHasExternalLexicalStorage(true);
2883 case UPDATE_VISIBLE: {
2885 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2886 auto *Data = (const unsigned char*)Blob.data();
2887 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2888 // If we've already loaded the decl, perform the updates when we finish
2889 // loading this block.
2890 if (Decl *D = GetExistingDecl(ID))
2891 PendingUpdateRecords.push_back(
2892 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2896 case IDENTIFIER_TABLE:
2897 F.IdentifierTableData = Blob.data();
2899 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2900 (const unsigned char *)F.IdentifierTableData + Record[0],
2901 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2902 (const unsigned char *)F.IdentifierTableData,
2903 ASTIdentifierLookupTrait(*this, F));
2905 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2909 case IDENTIFIER_OFFSET: {
2910 if (F.LocalNumIdentifiers != 0) {
2911 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2914 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2915 F.LocalNumIdentifiers = Record[0];
2916 unsigned LocalBaseIdentifierID = Record[1];
2917 F.BaseIdentifierID = getTotalNumIdentifiers();
2919 if (F.LocalNumIdentifiers > 0) {
2920 // Introduce the global -> local mapping for identifiers within this
2922 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2925 // Introduce the local -> global mapping for identifiers within this
2927 F.IdentifierRemap.insertOrReplace(
2928 std::make_pair(LocalBaseIdentifierID,
2929 F.BaseIdentifierID - LocalBaseIdentifierID));
2931 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2932 + F.LocalNumIdentifiers);
2937 case INTERESTING_IDENTIFIERS:
2938 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2941 case EAGERLY_DESERIALIZED_DECLS:
2942 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2943 // about "interesting" decls (for instance, if we're building a module).
2944 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2945 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2948 case MODULAR_CODEGEN_DECLS:
2949 // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2950 // them (ie: if we're not codegenerating this module).
2951 if (F.Kind == MK_MainFile)
2952 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2953 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2957 if (SpecialTypes.empty()) {
2958 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2959 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2963 if (SpecialTypes.size() != Record.size()) {
2964 Error("invalid special-types record");
2968 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2969 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2970 if (!SpecialTypes[I])
2971 SpecialTypes[I] = ID;
2972 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2978 TotalNumStatements += Record[0];
2979 TotalNumMacros += Record[1];
2980 TotalLexicalDeclContexts += Record[2];
2981 TotalVisibleDeclContexts += Record[3];
2984 case UNUSED_FILESCOPED_DECLS:
2985 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2986 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2989 case DELEGATING_CTORS:
2990 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2991 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2994 case WEAK_UNDECLARED_IDENTIFIERS:
2995 if (Record.size() % 4 != 0) {
2996 Error("invalid weak identifiers record");
3000 // FIXME: Ignore weak undeclared identifiers from non-original PCH
3001 // files. This isn't the way to do it :)
3002 WeakUndeclaredIdentifiers.clear();
3004 // Translate the weak, undeclared identifiers into global IDs.
3005 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3006 WeakUndeclaredIdentifiers.push_back(
3007 getGlobalIdentifierID(F, Record[I++]));
3008 WeakUndeclaredIdentifiers.push_back(
3009 getGlobalIdentifierID(F, Record[I++]));
3010 WeakUndeclaredIdentifiers.push_back(
3011 ReadSourceLocation(F, Record, I).getRawEncoding());
3012 WeakUndeclaredIdentifiers.push_back(Record[I++]);
3016 case SELECTOR_OFFSETS: {
3017 F.SelectorOffsets = (const uint32_t *)Blob.data();
3018 F.LocalNumSelectors = Record[0];
3019 unsigned LocalBaseSelectorID = Record[1];
3020 F.BaseSelectorID = getTotalNumSelectors();
3022 if (F.LocalNumSelectors > 0) {
3023 // Introduce the global -> local mapping for selectors within this
3025 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3027 // Introduce the local -> global mapping for selectors within this
3029 F.SelectorRemap.insertOrReplace(
3030 std::make_pair(LocalBaseSelectorID,
3031 F.BaseSelectorID - LocalBaseSelectorID));
3033 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3039 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3041 F.SelectorLookupTable
3042 = ASTSelectorLookupTable::Create(
3043 F.SelectorLookupTableData + Record[0],
3044 F.SelectorLookupTableData,
3045 ASTSelectorLookupTrait(*this, F));
3046 TotalNumMethodPoolEntries += Record[1];
3049 case REFERENCED_SELECTOR_POOL:
3050 if (!Record.empty()) {
3051 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3052 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3054 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3060 case PP_CONDITIONAL_STACK:
3061 if (!Record.empty()) {
3062 unsigned Idx = 0, End = Record.size() - 1;
3063 bool ReachedEOFWhileSkipping = Record[Idx++];
3064 llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3065 if (ReachedEOFWhileSkipping) {
3066 SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3067 SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3068 bool FoundNonSkipPortion = Record[Idx++];
3069 bool FoundElse = Record[Idx++];
3070 SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3071 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3072 FoundElse, ElseLoc);
3074 SmallVector<PPConditionalInfo, 4> ConditionalStack;
3076 auto Loc = ReadSourceLocation(F, Record, Idx);
3077 bool WasSkipping = Record[Idx++];
3078 bool FoundNonSkip = Record[Idx++];
3079 bool FoundElse = Record[Idx++];
3080 ConditionalStack.push_back(
3081 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3083 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3087 case PP_COUNTER_VALUE:
3088 if (!Record.empty() && Listener)
3089 Listener->ReadCounter(F, Record[0]);
3092 case FILE_SORTED_DECLS:
3093 F.FileSortedDecls = (const DeclID *)Blob.data();
3094 F.NumFileSortedDecls = Record[0];
3097 case SOURCE_LOCATION_OFFSETS: {
3098 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3099 F.LocalNumSLocEntries = Record[0];
3100 unsigned SLocSpaceSize = Record[1];
3101 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3102 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3104 if (!F.SLocEntryBaseID) {
3105 Error("ran out of source locations");
3108 // Make our entry in the range map. BaseID is negative and growing, so
3109 // we invert it. Because we invert it, though, we need the other end of
3111 unsigned RangeStart =
3112 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3113 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3114 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3116 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3117 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3118 GlobalSLocOffsetMap.insert(
3119 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3120 - SLocSpaceSize,&F));
3122 // Initialize the remapping table.
3123 // Invalid stays invalid.
3124 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3125 // This module. Base was 2 when being compiled.
3126 F.SLocRemap.insertOrReplace(std::make_pair(2U,
3127 static_cast<int>(F.SLocEntryBaseOffset - 2)));
3129 TotalNumSLocEntries += F.LocalNumSLocEntries;
3133 case MODULE_OFFSET_MAP:
3134 F.ModuleOffsetMap = Blob;
3137 case SOURCE_MANAGER_LINE_TABLE:
3138 if (ParseLineTable(F, Record))
3142 case SOURCE_LOCATION_PRELOADS: {
3143 // Need to transform from the local view (1-based IDs) to the global view,
3144 // which is based off F.SLocEntryBaseID.
3145 if (!F.PreloadSLocEntries.empty()) {
3146 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3150 F.PreloadSLocEntries.swap(Record);
3154 case EXT_VECTOR_DECLS:
3155 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3156 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3160 if (Record.size() % 3 != 0) {
3161 Error("Invalid VTABLE_USES record");
3165 // Later tables overwrite earlier ones.
3166 // FIXME: Modules will have some trouble with this. This is clearly not
3167 // the right way to do this.
3170 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3171 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3172 VTableUses.push_back(
3173 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3174 VTableUses.push_back(Record[Idx++]);
3178 case PENDING_IMPLICIT_INSTANTIATIONS:
3179 if (PendingInstantiations.size() % 2 != 0) {
3180 Error("Invalid existing PendingInstantiations");
3184 if (Record.size() % 2 != 0) {
3185 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3189 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3190 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3191 PendingInstantiations.push_back(
3192 ReadSourceLocation(F, Record, I).getRawEncoding());
3196 case SEMA_DECL_REFS:
3197 if (Record.size() != 3) {
3198 Error("Invalid SEMA_DECL_REFS block");
3201 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3202 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3205 case PPD_ENTITIES_OFFSETS: {
3206 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3207 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3208 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3210 unsigned LocalBasePreprocessedEntityID = Record[0];
3212 unsigned StartingID;
3213 if (!PP.getPreprocessingRecord())
3214 PP.createPreprocessingRecord();
3215 if (!PP.getPreprocessingRecord()->getExternalSource())
3216 PP.getPreprocessingRecord()->SetExternalSource(*this);
3218 = PP.getPreprocessingRecord()
3219 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3220 F.BasePreprocessedEntityID = StartingID;
3222 if (F.NumPreprocessedEntities > 0) {
3223 // Introduce the global -> local mapping for preprocessed entities in
3225 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3227 // Introduce the local -> global mapping for preprocessed entities in
3229 F.PreprocessedEntityRemap.insertOrReplace(
3230 std::make_pair(LocalBasePreprocessedEntityID,
3231 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3237 case PPD_SKIPPED_RANGES: {
3238 F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3239 assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3240 F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3242 if (!PP.getPreprocessingRecord())
3243 PP.createPreprocessingRecord();
3244 if (!PP.getPreprocessingRecord()->getExternalSource())
3245 PP.getPreprocessingRecord()->SetExternalSource(*this);
3246 F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3247 ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3249 if (F.NumPreprocessedSkippedRanges > 0)
3250 GlobalSkippedRangeMap.insert(
3251 std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3255 case DECL_UPDATE_OFFSETS:
3256 if (Record.size() % 2 != 0) {
3257 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3260 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3261 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3262 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3264 // If we've already loaded the decl, perform the updates when we finish
3265 // loading this block.
3266 if (Decl *D = GetExistingDecl(ID))
3267 PendingUpdateRecords.push_back(
3268 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3272 case OBJC_CATEGORIES_MAP:
3273 if (F.LocalNumObjCCategoriesInMap != 0) {
3274 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3278 F.LocalNumObjCCategoriesInMap = Record[0];
3279 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3282 case OBJC_CATEGORIES:
3283 F.ObjCCategories.swap(Record);
3286 case CUDA_SPECIAL_DECL_REFS:
3287 // Later tables overwrite earlier ones.
3288 // FIXME: Modules will have trouble with this.
3289 CUDASpecialDeclRefs.clear();
3290 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3291 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3294 case HEADER_SEARCH_TABLE:
3295 F.HeaderFileInfoTableData = Blob.data();
3296 F.LocalNumHeaderFileInfos = Record[1];
3298 F.HeaderFileInfoTable
3299 = HeaderFileInfoLookupTable::Create(
3300 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3301 (const unsigned char *)F.HeaderFileInfoTableData,
3302 HeaderFileInfoTrait(*this, F,
3303 &PP.getHeaderSearchInfo(),
3304 Blob.data() + Record[2]));
3306 PP.getHeaderSearchInfo().SetExternalSource(this);
3307 if (!PP.getHeaderSearchInfo().getExternalLookup())
3308 PP.getHeaderSearchInfo().SetExternalLookup(this);
3312 case FP_PRAGMA_OPTIONS:
3313 // Later tables overwrite earlier ones.
3314 FPPragmaOptions.swap(Record);
3317 case OPENCL_EXTENSIONS:
3318 for (unsigned I = 0, E = Record.size(); I != E; ) {
3319 auto Name = ReadString(Record, I);
3320 auto &Opt = OpenCLExtensions.OptMap[Name];
3321 Opt.Supported = Record[I++] != 0;
3322 Opt.Enabled = Record[I++] != 0;
3323 Opt.Avail = Record[I++];
3324 Opt.Core = Record[I++];
3328 case OPENCL_EXTENSION_TYPES:
3329 for (unsigned I = 0, E = Record.size(); I != E;) {
3330 auto TypeID = static_cast<::TypeID>(Record[I++]);
3331 auto *Type = GetType(TypeID).getTypePtr();
3332 auto NumExt = static_cast<unsigned>(Record[I++]);
3333 for (unsigned II = 0; II != NumExt; ++II) {
3334 auto Ext = ReadString(Record, I);
3335 OpenCLTypeExtMap[Type].insert(Ext);
3340 case OPENCL_EXTENSION_DECLS:
3341 for (unsigned I = 0, E = Record.size(); I != E;) {
3342 auto DeclID = static_cast<::DeclID>(Record[I++]);
3343 auto *Decl = GetDecl(DeclID);
3344 auto NumExt = static_cast<unsigned>(Record[I++]);
3345 for (unsigned II = 0; II != NumExt; ++II) {
3346 auto Ext = ReadString(Record, I);
3347 OpenCLDeclExtMap[Decl].insert(Ext);
3352 case TENTATIVE_DEFINITIONS:
3353 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3354 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3357 case KNOWN_NAMESPACES:
3358 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3359 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3362 case UNDEFINED_BUT_USED:
3363 if (UndefinedButUsed.size() % 2 != 0) {
3364 Error("Invalid existing UndefinedButUsed");
3368 if (Record.size() % 2 != 0) {
3369 Error("invalid undefined-but-used record");
3372 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3373 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3374 UndefinedButUsed.push_back(
3375 ReadSourceLocation(F, Record, I).getRawEncoding());
3379 case DELETE_EXPRS_TO_ANALYZE:
3380 for (unsigned I = 0, N = Record.size(); I != N;) {
3381 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3382 const uint64_t Count = Record[I++];
3383 DelayedDeleteExprs.push_back(Count);
3384 for (uint64_t C = 0; C < Count; ++C) {
3385 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3386 bool IsArrayForm = Record[I++] == 1;
3387 DelayedDeleteExprs.push_back(IsArrayForm);
3392 case IMPORTED_MODULES:
3393 if (!F.isModule()) {
3394 // If we aren't loading a module (which has its own exports), make
3395 // all of the imported modules visible.
3396 // FIXME: Deal with macros-only imports.
3397 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3398 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3399 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3401 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3402 if (DeserializationListener)
3403 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3409 case MACRO_OFFSET: {
3410 if (F.LocalNumMacros != 0) {
3411 Error("duplicate MACRO_OFFSET record in AST file");
3414 F.MacroOffsets = (const uint32_t *)Blob.data();
3415 F.LocalNumMacros = Record[0];
3416 unsigned LocalBaseMacroID = Record[1];
3417 F.BaseMacroID = getTotalNumMacros();
3419 if (F.LocalNumMacros > 0) {
3420 // Introduce the global -> local mapping for macros within this module.
3421 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3423 // Introduce the local -> global mapping for macros within this module.
3424 F.MacroRemap.insertOrReplace(
3425 std::make_pair(LocalBaseMacroID,
3426 F.BaseMacroID - LocalBaseMacroID));
3428 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3433 case LATE_PARSED_TEMPLATE:
3434 LateParsedTemplates.append(Record.begin(), Record.end());
3437 case OPTIMIZE_PRAGMA_OPTIONS:
3438 if (Record.size() != 1) {
3439 Error("invalid pragma optimize record");
3442 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3445 case MSSTRUCT_PRAGMA_OPTIONS:
3446 if (Record.size() != 1) {
3447 Error("invalid pragma ms_struct record");
3450 PragmaMSStructState = Record[0];
3453 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3454 if (Record.size() != 2) {
3455 Error("invalid pragma ms_struct record");
3458 PragmaMSPointersToMembersState = Record[0];
3459 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3462 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3463 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3464 UnusedLocalTypedefNameCandidates.push_back(
3465 getGlobalDeclID(F, Record[I]));
3468 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3469 if (Record.size() != 1) {
3470 Error("invalid cuda pragma options record");
3473 ForceCUDAHostDeviceDepth = Record[0];
3476 case PACK_PRAGMA_OPTIONS: {
3477 if (Record.size() < 3) {
3478 Error("invalid pragma pack record");
3481 PragmaPackCurrentValue = Record[0];
3482 PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3483 unsigned NumStackEntries = Record[2];
3485 // Reset the stack when importing a new module.
3486 PragmaPackStack.clear();
3487 for (unsigned I = 0; I < NumStackEntries; ++I) {
3488 PragmaPackStackEntry Entry;
3489 Entry.Value = Record[Idx++];
3490 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3491 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3492 PragmaPackStrings.push_back(ReadString(Record, Idx));
3493 Entry.SlotLabel = PragmaPackStrings.back();
3494 PragmaPackStack.push_back(Entry);
3502 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3503 assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3505 // Additional remapping information.
3506 const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3507 const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3508 F.ModuleOffsetMap = StringRef();
3510 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3511 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3512 F.SLocRemap.insert(std::make_pair(0U, 0));
3513 F.SLocRemap.insert(std::make_pair(2U, 1));
3516 // Continuous range maps we may be updating in our module.
3517 using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3518 RemapBuilder SLocRemap(F.SLocRemap);
3519 RemapBuilder IdentifierRemap(F.IdentifierRemap);
3520 RemapBuilder MacroRemap(F.MacroRemap);
3521 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3522 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3523 RemapBuilder SelectorRemap(F.SelectorRemap);
3524 RemapBuilder DeclRemap(F.DeclRemap);
3525 RemapBuilder TypeRemap(F.TypeRemap);
3527 while (Data < DataEnd) {
3528 // FIXME: Looking up dependency modules by filename is horrible. Let's
3529 // start fixing this with prebuilt and explicit modules and see how it
3531 using namespace llvm::support;
3532 ModuleKind Kind = static_cast<ModuleKind>(
3533 endian::readNext<uint8_t, little, unaligned>(Data));
3534 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3535 StringRef Name = StringRef((const char*)Data, Len);
3537 ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3538 ? ModuleMgr.lookupByModuleName(Name)
3539 : ModuleMgr.lookupByFileName(Name));
3542 "SourceLocation remap refers to unknown module, cannot find ";
3548 uint32_t SLocOffset =
3549 endian::readNext<uint32_t, little, unaligned>(Data);
3550 uint32_t IdentifierIDOffset =
3551 endian::readNext<uint32_t, little, unaligned>(Data);
3552 uint32_t MacroIDOffset =
3553 endian::readNext<uint32_t, little, unaligned>(Data);
3554 uint32_t PreprocessedEntityIDOffset =
3555 endian::readNext<uint32_t, little, unaligned>(Data);
3556 uint32_t SubmoduleIDOffset =
3557 endian::readNext<uint32_t, little, unaligned>(Data);
3558 uint32_t SelectorIDOffset =
3559 endian::readNext<uint32_t, little, unaligned>(Data);
3560 uint32_t DeclIDOffset =
3561 endian::readNext<uint32_t, little, unaligned>(Data);
3562 uint32_t TypeIndexOffset =
3563 endian::readNext<uint32_t, little, unaligned>(Data);
3565 uint32_t None = std::numeric_limits<uint32_t>::max();
3567 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3568 RemapBuilder &Remap) {
3570 Remap.insert(std::make_pair(Offset,
3571 static_cast<int>(BaseOffset - Offset)));
3573 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3574 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3575 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3576 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3577 PreprocessedEntityRemap);
3578 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3579 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3580 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3581 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3583 // Global -> local mappings.
3584 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3588 ASTReader::ASTReadResult
3589 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3590 const ModuleFile *ImportedBy,
3591 unsigned ClientLoadCapabilities) {
3593 F.ModuleMapPath = ReadPath(F, Record, Idx);
3595 // Try to resolve ModuleName in the current header search context and
3596 // verify that it is found in the same module map file as we saved. If the
3597 // top-level AST file is a main file, skip this check because there is no
3598 // usable header search context.
3599 assert(!F.ModuleName.empty() &&
3600 "MODULE_NAME should come before MODULE_MAP_FILE");
3601 if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3602 // An implicitly-loaded module file should have its module listed in some
3603 // module map file that we've already loaded.
3604 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3605 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3606 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3607 // Don't emit module relocation error if we have -fno-validate-pch
3608 if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3609 assert(ImportedBy && "top-level import should be verified");
3610 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3611 if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3612 // This module was defined by an imported (explicit) module.
3613 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3614 << ASTFE->getName();
3616 // This module was built with a different module map.
3617 Diag(diag::err_imported_module_not_found)
3618 << F.ModuleName << F.FileName << ImportedBy->FileName
3620 // In case it was imported by a PCH, there's a chance the user is
3621 // just missing to include the search path to the directory containing
3623 if (ImportedBy->Kind == MK_PCH)
3624 Diag(diag::note_imported_by_pch_module_not_found)
3625 << llvm::sys::path::parent_path(F.ModuleMapPath);
3631 assert(M->Name == F.ModuleName && "found module with different name");
3633 // Check the primary module map file.
3634 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3635 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3636 assert(ModMap && "found module is missing module map file");
3637 assert(ImportedBy && "top-level import should be verified");
3638 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3639 Diag(diag::err_imported_module_modmap_changed)
3640 << F.ModuleName << ImportedBy->FileName
3641 << ModMap->getName() << F.ModuleMapPath;
3645 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3646 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3647 // FIXME: we should use input files rather than storing names.
3648 std::string Filename = ReadPath(F, Record, Idx);
3649 const FileEntry *F =
3650 FileMgr.getFile(Filename, false, false);
3652 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3653 Error("could not find file '" + Filename +"' referenced by AST file");
3656 AdditionalStoredMaps.insert(F);
3659 // Check any additional module map files (e.g. module.private.modulemap)
3660 // that are not in the pcm.
3661 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3662 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3663 // Remove files that match
3664 // Note: SmallPtrSet::erase is really remove
3665 if (!AdditionalStoredMaps.erase(ModMap)) {
3666 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3667 Diag(diag::err_module_different_modmap)
3668 << F.ModuleName << /*new*/0 << ModMap->getName();
3674 // Check any additional module map files that are in the pcm, but not
3675 // found in header search. Cases that match are already removed.
3676 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3677 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3678 Diag(diag::err_module_different_modmap)
3679 << F.ModuleName << /*not new*/1 << ModMap->getName();
3685 Listener->ReadModuleMapFile(F.ModuleMapPath);
3689 /// Move the given method to the back of the global list of methods.
3690 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3691 // Find the entry for this selector in the method pool.
3692 Sema::GlobalMethodPool::iterator Known
3693 = S.MethodPool.find(Method->getSelector());
3694 if (Known == S.MethodPool.end())
3697 // Retrieve the appropriate method list.
3698 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3699 : Known->second.second;
3701 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3703 if (List->getMethod() == Method) {
3711 if (List->getNext())
3712 List->setMethod(List->getNext()->getMethod());
3714 List->setMethod(Method);
3718 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3719 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3720 for (Decl *D : Names) {
3721 bool wasHidden = D->isHidden();
3722 D->setVisibleDespiteOwningModule();
3724 if (wasHidden && SemaObj) {
3725 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3726 moveMethodToBackOfGlobalList(*SemaObj, Method);
3732 void ASTReader::makeModuleVisible(Module *Mod,
3733 Module::NameVisibilityKind NameVisibility,
3734 SourceLocation ImportLoc) {
3735 llvm::SmallPtrSet<Module *, 4> Visited;
3736 SmallVector<Module *, 4> Stack;
3737 Stack.push_back(Mod);
3738 while (!Stack.empty()) {
3739 Mod = Stack.pop_back_val();
3741 if (NameVisibility <= Mod->NameVisibility) {
3742 // This module already has this level of visibility (or greater), so
3743 // there is nothing more to do.
3747 if (!Mod->isAvailable()) {
3748 // Modules that aren't available cannot be made visible.
3752 // Update the module's name visibility.
3753 Mod->NameVisibility = NameVisibility;
3755 // If we've already deserialized any names from this module,
3756 // mark them as visible.
3757 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3758 if (Hidden != HiddenNamesMap.end()) {
3759 auto HiddenNames = std::move(*Hidden);
3760 HiddenNamesMap.erase(Hidden);
3761 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3762 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3763 "making names visible added hidden names");
3766 // Push any exported modules onto the stack to be marked as visible.
3767 SmallVector<Module *, 16> Exports;
3768 Mod->getExportedModules(Exports);
3769 for (SmallVectorImpl<Module *>::iterator
3770 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3771 Module *Exported = *I;
3772 if (Visited.insert(Exported).second)
3773 Stack.push_back(Exported);
3778 /// We've merged the definition \p MergedDef into the existing definition
3779 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3781 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
3782 NamedDecl *MergedDef) {
3783 // FIXME: This doesn't correctly handle the case where MergedDef is visible
3784 // in modules other than its owning module. We should instead give the
3785 // ASTContext a list of merged definitions for Def.
3786 if (Def->isHidden()) {
3787 // If MergedDef is visible or becomes visible, make the definition visible.
3788 if (!MergedDef->isHidden())
3789 Def->setVisibleDespiteOwningModule();
3790 else if (getContext().getLangOpts().ModulesLocalVisibility) {
3791 getContext().mergeDefinitionIntoModule(
3792 Def, MergedDef->getImportedOwningModule(),
3793 /*NotifyListeners*/ false);
3794 PendingMergedDefinitionsToDeduplicate.insert(Def);
3796 auto SubmoduleID = MergedDef->getOwningModuleID();
3797 assert(SubmoduleID && "hidden definition in no module");
3798 HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
3803 bool ASTReader::loadGlobalIndex() {
3807 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3808 !PP.getLangOpts().Modules)
3811 // Try to load the global index.
3812 TriedLoadingGlobalIndex = true;
3813 StringRef ModuleCachePath
3814 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3815 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3816 = GlobalModuleIndex::readIndex(ModuleCachePath);
3820 GlobalIndex.reset(Result.first);
3821 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3825 bool ASTReader::isGlobalIndexUnavailable() const {
3826 return PP.getLangOpts().Modules && UseGlobalIndex &&
3827 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3830 static void updateModuleTimestamp(ModuleFile &MF) {
3831 // Overwrite the timestamp file contents so that file's mtime changes.
3832 std::string TimestampFilename = MF.getTimestampFilename();
3834 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3837 OS << "Timestamp file\n";
3839 OS.clear_error(); // Avoid triggering a fatal error.
3842 /// Given a cursor at the start of an AST file, scan ahead and drop the
3843 /// cursor into the start of the given block ID, returning false on success and
3844 /// true on failure.
3845 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3847 llvm::BitstreamEntry Entry = Cursor.advance();
3848 switch (Entry.Kind) {
3849 case llvm::BitstreamEntry::Error:
3850 case llvm::BitstreamEntry::EndBlock:
3853 case llvm::BitstreamEntry::Record:
3854 // Ignore top-level records.
3855 Cursor.skipRecord(Entry.ID);
3858 case llvm::BitstreamEntry::SubBlock:
3859 if (Entry.ID == BlockID) {
3860 if (Cursor.EnterSubBlock(BlockID))
3866 if (Cursor.SkipBlock())
3872 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3874 SourceLocation ImportLoc,
3875 unsigned ClientLoadCapabilities,
3876 SmallVectorImpl<ImportedSubmodule> *Imported) {
3877 llvm::SaveAndRestore<SourceLocation>
3878 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3880 // Defer any pending actions until we get to the end of reading the AST file.
3881 Deserializing AnASTFile(this);
3883 // Bump the generation number.
3884 unsigned PreviousGeneration = 0;
3886 PreviousGeneration = incrementGeneration(*ContextObj);
3888 unsigned NumModules = ModuleMgr.size();
3889 SmallVector<ImportedModule, 4> Loaded;
3890 switch (ASTReadResult ReadResult =
3891 ReadASTCore(FileName, Type, ImportLoc,
3892 /*ImportedBy=*/nullptr, Loaded, 0, 0,
3893 ASTFileSignature(), ClientLoadCapabilities)) {
3897 case VersionMismatch:
3898 case ConfigurationMismatch:
3900 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3901 for (const ImportedModule &IM : Loaded)
3902 LoadedSet.insert(IM.Mod);
3904 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3905 PP.getLangOpts().Modules
3906 ? &PP.getHeaderSearchInfo().getModuleMap()
3909 // If we find that any modules are unusable, the global index is going
3910 // to be out-of-date. Just remove it.
3911 GlobalIndex.reset();
3912 ModuleMgr.setGlobalIndex(nullptr);
3919 // Here comes stuff that we only do once the entire chain is loaded.
3921 // Load the AST blocks of all of the modules that we loaded.
3922 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3923 MEnd = Loaded.end();
3925 ModuleFile &F = *M->Mod;
3927 // Read the AST block.
3928 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3931 // Read the extension blocks.
3932 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3933 if (ASTReadResult Result = ReadExtensionBlock(F))
3937 // Once read, set the ModuleFile bit base offset and update the size in
3938 // bits of all files we've seen.
3939 F.GlobalBitOffset = TotalModulesSizeInBits;
3940 TotalModulesSizeInBits += F.SizeInBits;
3941 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3943 // Preload SLocEntries.
3944 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3945 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3946 // Load it through the SourceManager and don't call ReadSLocEntry()
3947 // directly because the entry may have already been loaded in which case
3948 // calling ReadSLocEntry() directly would trigger an assertion in
3950 SourceMgr.getLoadedSLocEntryByID(Index);
3953 // Map the original source file ID into the ID space of the current
3955 if (F.OriginalSourceFileID.isValid()) {
3956 F.OriginalSourceFileID = FileID::get(
3957 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3960 // Preload all the pending interesting identifiers by marking them out of
3962 for (auto Offset : F.PreloadIdentifierOffsets) {
3963 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3964 F.IdentifierTableData + Offset);
3966 ASTIdentifierLookupTrait Trait(*this, F);
3967 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3968 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3969 auto &II = PP.getIdentifierTable().getOwn(Key);
3970 II.setOutOfDate(true);
3972 // Mark this identifier as being from an AST file so that we can track
3973 // whether we need to serialize it.
3974 markIdentifierFromAST(*this, II);
3976 // Associate the ID with the identifier so that the writer can reuse it.
3977 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3978 SetIdentifierInfo(ID, &II);
3982 // Setup the import locations and notify the module manager that we've
3983 // committed to these module files.
3984 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3985 MEnd = Loaded.end();
3987 ModuleFile &F = *M->Mod;
3989 ModuleMgr.moduleFileAccepted(&F);
3991 // Set the import location.
3992 F.DirectImportLoc = ImportLoc;
3993 // FIXME: We assume that locations from PCH / preamble do not need
3996 F.ImportLoc = M->ImportLoc;
3998 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
4001 if (!PP.getLangOpts().CPlusPlus ||
4002 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4003 Type != MK_PrebuiltModule)) {
4004 // Mark all of the identifiers in the identifier table as being out of date,
4005 // so that various accessors know to check the loaded modules when the
4006 // identifier is used.
4008 // For C++ modules, we don't need information on many identifiers (just
4009 // those that provide macros or are poisoned), so we mark all of
4010 // the interesting ones via PreloadIdentifierOffsets.
4011 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4012 IdEnd = PP.getIdentifierTable().end();
4014 Id->second->setOutOfDate(true);
4016 // Mark selectors as out of date.
4017 for (auto Sel : SelectorGeneration)
4018 SelectorOutOfDate[Sel.first] = true;
4020 // Resolve any unresolved module exports.
4021 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4022 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4023 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4024 Module *ResolvedMod = getSubmodule(GlobalID);
4026 switch (Unresolved.Kind) {
4027 case UnresolvedModuleRef::Conflict:
4029 Module::Conflict Conflict;
4030 Conflict.Other = ResolvedMod;
4031 Conflict.Message = Unresolved.String.str();
4032 Unresolved.Mod->Conflicts.push_back(Conflict);
4036 case UnresolvedModuleRef::Import:
4038 Unresolved.Mod->Imports.insert(ResolvedMod);
4041 case UnresolvedModuleRef::Export:
4042 if (ResolvedMod || Unresolved.IsWildcard)
4043 Unresolved.Mod->Exports.push_back(
4044 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4048 UnresolvedModuleRefs.clear();
4051 Imported->append(ImportedModules.begin(),
4052 ImportedModules.end());
4054 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4055 // Might be unnecessary as use declarations are only used to build the
4059 InitializeContext();
4064 if (DeserializationListener)
4065 DeserializationListener->ReaderInitialized(this);
4067 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4068 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4069 // If this AST file is a precompiled preamble, then set the
4070 // preamble file ID of the source manager to the file source file
4071 // from which the preamble was built.
4072 if (Type == MK_Preamble) {
4073 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4074 } else if (Type == MK_MainFile) {
4075 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4079 // For any Objective-C class definitions we have already loaded, make sure
4080 // that we load any additional categories.
4082 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4083 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4084 ObjCClassesLoaded[I],
4085 PreviousGeneration);
4089 if (PP.getHeaderSearchInfo()
4090 .getHeaderSearchOpts()
4091 .ModulesValidateOncePerBuildSession) {
4092 // Now we are certain that the module and all modules it depends on are
4093 // up to date. Create or update timestamp files for modules that are
4094 // located in the module cache (not for PCH files that could be anywhere
4095 // in the filesystem).
4096 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4097 ImportedModule &M = Loaded[I];
4098 if (M.Mod->Kind == MK_ImplicitModule) {
4099 updateModuleTimestamp(*M.Mod);
4107 static ASTFileSignature readASTFileSignature(StringRef PCH);
4109 /// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4110 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4111 return Stream.canSkipToPos(4) &&
4112 Stream.Read(8) == 'C' &&
4113 Stream.Read(8) == 'P' &&
4114 Stream.Read(8) == 'C' &&
4115 Stream.Read(8) == 'H';
4118 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4122 case MK_ImplicitModule:
4123 case MK_ExplicitModule:
4124 case MK_PrebuiltModule:
4128 return 2; // main source file
4130 llvm_unreachable("unknown module kind");
4133 ASTReader::ASTReadResult
4134 ASTReader::ReadASTCore(StringRef FileName,
4136 SourceLocation ImportLoc,
4137 ModuleFile *ImportedBy,
4138 SmallVectorImpl<ImportedModule> &Loaded,
4139 off_t ExpectedSize, time_t ExpectedModTime,
4140 ASTFileSignature ExpectedSignature,
4141 unsigned ClientLoadCapabilities) {
4143 std::string ErrorStr;
4144 ModuleManager::AddModuleResult AddResult
4145 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4146 getGeneration(), ExpectedSize, ExpectedModTime,
4147 ExpectedSignature, readASTFileSignature,
4150 switch (AddResult) {
4151 case ModuleManager::AlreadyLoaded:
4154 case ModuleManager::NewlyLoaded:
4155 // Load module file below.
4158 case ModuleManager::Missing:
4159 // The module file was missing; if the client can handle that, return
4161 if (ClientLoadCapabilities & ARR_Missing)
4164 // Otherwise, return an error.
4165 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4166 << FileName << !ErrorStr.empty()
4170 case ModuleManager::OutOfDate:
4171 // We couldn't load the module file because it is out-of-date. If the
4172 // client can handle out-of-date, return it.
4173 if (ClientLoadCapabilities & ARR_OutOfDate)
4176 // Otherwise, return an error.
4177 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4178 << FileName << !ErrorStr.empty()
4183 assert(M && "Missing module file");
4186 BitstreamCursor &Stream = F.Stream;
4187 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4188 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4190 // Sniff for the signature.
4191 if (!startsWithASTFileMagic(Stream)) {
4192 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4197 // This is used for compatibility with older PCH formats.
4198 bool HaveReadControlBlock = false;
4200 llvm::BitstreamEntry Entry = Stream.advance();
4202 switch (Entry.Kind) {
4203 case llvm::BitstreamEntry::Error:
4204 case llvm::BitstreamEntry::Record:
4205 case llvm::BitstreamEntry::EndBlock:
4206 Error("invalid record at top-level of AST file");
4209 case llvm::BitstreamEntry::SubBlock:
4214 case CONTROL_BLOCK_ID:
4215 HaveReadControlBlock = true;
4216 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4218 // Check that we didn't try to load a non-module AST file as a module.
4220 // FIXME: Should we also perform the converse check? Loading a module as
4221 // a PCH file sort of works, but it's a bit wonky.
4222 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4223 Type == MK_PrebuiltModule) &&
4224 F.ModuleName.empty()) {
4225 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4226 if (Result != OutOfDate ||
4227 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4228 Diag(diag::err_module_file_not_module) << FileName;
4233 case Failure: return Failure;
4234 case Missing: return Missing;
4235 case OutOfDate: return OutOfDate;
4236 case VersionMismatch: return VersionMismatch;
4237 case ConfigurationMismatch: return ConfigurationMismatch;
4238 case HadErrors: return HadErrors;
4243 if (!HaveReadControlBlock) {
4244 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4245 Diag(diag::err_pch_version_too_old);
4246 return VersionMismatch;
4249 // Record that we've loaded this module.
4250 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4253 case UNHASHED_CONTROL_BLOCK_ID:
4254 // This block is handled using look-ahead during ReadControlBlock. We
4255 // shouldn't get here!
4256 Error("malformed block record in AST file");
4260 if (Stream.SkipBlock()) {
4261 Error("malformed block record in AST file");
4271 ASTReader::ASTReadResult
4272 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4273 unsigned ClientLoadCapabilities) {
4274 const HeaderSearchOptions &HSOpts =
4275 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4276 bool AllowCompatibleConfigurationMismatch =
4277 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4279 ASTReadResult Result = readUnhashedControlBlockImpl(
4280 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4282 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4284 // If F was directly imported by another module, it's implicitly validated by
4285 // the importing module.
4286 if (DisableValidation || WasImportedBy ||
4287 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4290 if (Result == Failure) {
4291 Error("malformed block record in AST file");
4295 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4296 // If this module has already been finalized in the PCMCache, we're stuck
4297 // with it; we can only load a single version of each module.
4299 // This can happen when a module is imported in two contexts: in one, as a
4300 // user module; in another, as a system module (due to an import from
4301 // another module marked with the [system] flag). It usually indicates a
4302 // bug in the module map: this module should also be marked with [system].
4304 // If -Wno-system-headers (the default), and the first import is as a
4305 // system module, then validation will fail during the as-user import,
4306 // since -Werror flags won't have been validated. However, it's reasonable
4307 // to treat this consistently as a system module.
4309 // If -Wsystem-headers, the PCM on disk was built with
4310 // -Wno-system-headers, and the first import is as a user module, then
4311 // validation will fail during the as-system import since the PCM on disk
4312 // doesn't guarantee that -Werror was respected. However, the -Werror
4313 // flags were checked during the initial as-user import.
4314 if (PCMCache.isBufferFinal(F.FileName)) {
4315 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4323 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4324 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4325 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4326 bool ValidateDiagnosticOptions) {
4327 // Initialize a stream.
4328 BitstreamCursor Stream(StreamData);
4330 // Sniff for the signature.
4331 if (!startsWithASTFileMagic(Stream))
4334 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4335 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4338 // Read all of the records in the options block.
4340 ASTReadResult Result = Success;
4342 llvm::BitstreamEntry Entry = Stream.advance();
4344 switch (Entry.Kind) {
4345 case llvm::BitstreamEntry::Error:
4346 case llvm::BitstreamEntry::SubBlock:
4349 case llvm::BitstreamEntry::EndBlock:
4352 case llvm::BitstreamEntry::Record:
4353 // The interesting case.
4357 // Read and process a record.
4360 (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4363 std::copy(Record.begin(), Record.end(), F->Signature.data());
4365 case DIAGNOSTIC_OPTIONS: {
4366 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4367 if (Listener && ValidateDiagnosticOptions &&
4368 !AllowCompatibleConfigurationMismatch &&
4369 ParseDiagnosticOptions(Record, Complain, *Listener))
4370 Result = OutOfDate; // Don't return early. Read the signature.
4373 case DIAG_PRAGMA_MAPPINGS:
4376 if (F->PragmaDiagMappings.empty())
4377 F->PragmaDiagMappings.swap(Record);
4379 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4380 Record.begin(), Record.end());
4386 /// Parse a record and blob containing module file extension metadata.
4387 static bool parseModuleFileExtensionMetadata(
4388 const SmallVectorImpl<uint64_t> &Record,
4390 ModuleFileExtensionMetadata &Metadata) {
4391 if (Record.size() < 4) return true;
4393 Metadata.MajorVersion = Record[0];
4394 Metadata.MinorVersion = Record[1];
4396 unsigned BlockNameLen = Record[2];
4397 unsigned UserInfoLen = Record[3];
4399 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4401 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4402 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4403 Blob.data() + BlockNameLen + UserInfoLen);
4407 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4408 BitstreamCursor &Stream = F.Stream;
4412 llvm::BitstreamEntry Entry = Stream.advance();
4413 switch (Entry.Kind) {
4414 case llvm::BitstreamEntry::SubBlock:
4415 if (Stream.SkipBlock())
4420 case llvm::BitstreamEntry::EndBlock:
4423 case llvm::BitstreamEntry::Error:
4426 case llvm::BitstreamEntry::Record:
4432 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4434 case EXTENSION_METADATA: {
4435 ModuleFileExtensionMetadata Metadata;
4436 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4439 // Find a module file extension with this block name.
4440 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4441 if (Known == ModuleFileExtensions.end()) break;
4444 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4446 F.ExtensionReaders.push_back(std::move(Reader));
4457 void ASTReader::InitializeContext() {
4458 assert(ContextObj && "no context to initialize");
4459 ASTContext &Context = *ContextObj;
4461 // If there's a listener, notify them that we "read" the translation unit.
4462 if (DeserializationListener)
4463 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4464 Context.getTranslationUnitDecl());
4466 // FIXME: Find a better way to deal with collisions between these
4467 // built-in types. Right now, we just ignore the problem.
4469 // Load the special types.
4470 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4471 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4472 if (!Context.CFConstantStringTypeDecl)
4473 Context.setCFConstantStringType(GetType(String));
4476 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4477 QualType FileType = GetType(File);
4478 if (FileType.isNull()) {
4479 Error("FILE type is NULL");
4483 if (!Context.FILEDecl) {
4484 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4485 Context.setFILEDecl(Typedef->getDecl());
4487 const TagType *Tag = FileType->getAs<TagType>();
4489 Error("Invalid FILE type in AST file");
4492 Context.setFILEDecl(Tag->getDecl());
4497 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4498 QualType Jmp_bufType = GetType(Jmp_buf);
4499 if (Jmp_bufType.isNull()) {
4500 Error("jmp_buf type is NULL");
4504 if (!Context.jmp_bufDecl) {
4505 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4506 Context.setjmp_bufDecl(Typedef->getDecl());
4508 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4510 Error("Invalid jmp_buf type in AST file");
4513 Context.setjmp_bufDecl(Tag->getDecl());
4518 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4519 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4520 if (Sigjmp_bufType.isNull()) {
4521 Error("sigjmp_buf type is NULL");
4525 if (!Context.sigjmp_bufDecl) {
4526 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4527 Context.setsigjmp_bufDecl(Typedef->getDecl());
4529 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4530 assert(Tag && "Invalid sigjmp_buf type in AST file");
4531 Context.setsigjmp_bufDecl(Tag->getDecl());
4536 if (unsigned ObjCIdRedef
4537 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4538 if (Context.ObjCIdRedefinitionType.isNull())
4539 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4542 if (unsigned ObjCClassRedef
4543 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4544 if (Context.ObjCClassRedefinitionType.isNull())
4545 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4548 if (unsigned ObjCSelRedef
4549 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4550 if (Context.ObjCSelRedefinitionType.isNull())
4551 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4554 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4555 QualType Ucontext_tType = GetType(Ucontext_t);
4556 if (Ucontext_tType.isNull()) {
4557 Error("ucontext_t type is NULL");
4561 if (!Context.ucontext_tDecl) {
4562 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4563 Context.setucontext_tDecl(Typedef->getDecl());
4565 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4566 assert(Tag && "Invalid ucontext_t type in AST file");
4567 Context.setucontext_tDecl(Tag->getDecl());
4573 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4575 // If there were any CUDA special declarations, deserialize them.
4576 if (!CUDASpecialDeclRefs.empty()) {
4577 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4578 Context.setcudaConfigureCallDecl(
4579 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4582 // Re-export any modules that were imported by a non-module AST file.
4583 // FIXME: This does not make macro-only imports visible again.
4584 for (auto &Import : ImportedModules) {
4585 if (Module *Imported = getSubmodule(Import.ID)) {
4586 makeModuleVisible(Imported, Module::AllVisible,
4587 /*ImportLoc=*/Import.ImportLoc);
4588 if (Import.ImportLoc.isValid())
4589 PP.makeModuleVisible(Imported, Import.ImportLoc);
4590 // FIXME: should we tell Sema to make the module visible too?
4593 ImportedModules.clear();
4596 void ASTReader::finalizeForWriting() {
4597 // Nothing to do for now.
4600 /// Reads and return the signature record from \p PCH's control block, or
4602 static ASTFileSignature readASTFileSignature(StringRef PCH) {
4603 BitstreamCursor Stream(PCH);
4604 if (!startsWithASTFileMagic(Stream))
4605 return ASTFileSignature();
4607 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4608 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4609 return ASTFileSignature();
4611 // Scan for SIGNATURE inside the diagnostic options block.
4612 ASTReader::RecordData Record;
4614 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4615 if (Entry.Kind != llvm::BitstreamEntry::Record)
4616 return ASTFileSignature();
4620 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4621 return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4622 (uint32_t)Record[3], (uint32_t)Record[4]}}};
4626 /// Retrieve the name of the original source file name
4627 /// directly from the AST file, without actually loading the AST
4629 std::string ASTReader::getOriginalSourceFile(
4630 const std::string &ASTFileName, FileManager &FileMgr,
4631 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4632 // Open the AST file.
4633 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4635 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4636 << ASTFileName << Buffer.getError().message();
4637 return std::string();
4640 // Initialize the stream
4641 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4643 // Sniff for the signature.
4644 if (!startsWithASTFileMagic(Stream)) {
4645 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4646 return std::string();
4649 // Scan for the CONTROL_BLOCK_ID block.
4650 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4651 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4652 return std::string();
4655 // Scan for ORIGINAL_FILE inside the control block.
4658 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4659 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4660 return std::string();
4662 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4663 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4664 return std::string();
4669 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4676 class SimplePCHValidator : public ASTReaderListener {
4677 const LangOptions &ExistingLangOpts;
4678 const TargetOptions &ExistingTargetOpts;
4679 const PreprocessorOptions &ExistingPPOpts;
4680 std::string ExistingModuleCachePath;
4681 FileManager &FileMgr;
4684 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4685 const TargetOptions &ExistingTargetOpts,
4686 const PreprocessorOptions &ExistingPPOpts,
4687 StringRef ExistingModuleCachePath,
4688 FileManager &FileMgr)
4689 : ExistingLangOpts(ExistingLangOpts),
4690 ExistingTargetOpts(ExistingTargetOpts),
4691 ExistingPPOpts(ExistingPPOpts),
4692 ExistingModuleCachePath(ExistingModuleCachePath),
4695 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4696 bool AllowCompatibleDifferences) override {
4697 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4698 AllowCompatibleDifferences);
4701 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4702 bool AllowCompatibleDifferences) override {
4703 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4704 AllowCompatibleDifferences);
4707 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4708 StringRef SpecificModuleCachePath,
4709 bool Complain) override {
4710 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4711 ExistingModuleCachePath,
4712 nullptr, ExistingLangOpts);
4715 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4717 std::string &SuggestedPredefines) override {
4718 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4719 SuggestedPredefines, ExistingLangOpts);
4725 bool ASTReader::readASTFileControlBlock(
4726 StringRef Filename, FileManager &FileMgr,
4727 const PCHContainerReader &PCHContainerRdr,
4728 bool FindModuleFileExtensions,
4729 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4730 // Open the AST file.
4731 // FIXME: This allows use of the VFS; we do not allow use of the
4732 // VFS when actually loading a module.
4733 auto Buffer = FileMgr.getBufferForFile(Filename);
4738 // Initialize the stream
4739 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4740 BitstreamCursor Stream(Bytes);
4742 // Sniff for the signature.
4743 if (!startsWithASTFileMagic(Stream))
4746 // Scan for the CONTROL_BLOCK_ID block.
4747 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4750 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4751 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4752 bool NeedsImports = Listener.needsImportVisitation();
4753 BitstreamCursor InputFilesCursor;
4756 std::string ModuleDir;
4757 bool DoneWithControlBlock = false;
4758 while (!DoneWithControlBlock) {
4759 llvm::BitstreamEntry Entry = Stream.advance();
4761 switch (Entry.Kind) {
4762 case llvm::BitstreamEntry::SubBlock: {
4764 case OPTIONS_BLOCK_ID: {
4765 std::string IgnoredSuggestedPredefines;
4766 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4767 /*AllowCompatibleConfigurationMismatch*/ false,
4768 Listener, IgnoredSuggestedPredefines) != Success)
4773 case INPUT_FILES_BLOCK_ID:
4774 InputFilesCursor = Stream;
4775 if (Stream.SkipBlock() ||
4777 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4782 if (Stream.SkipBlock())
4790 case llvm::BitstreamEntry::EndBlock:
4791 DoneWithControlBlock = true;
4794 case llvm::BitstreamEntry::Error:
4797 case llvm::BitstreamEntry::Record:
4801 if (DoneWithControlBlock) break;
4805 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4806 switch ((ControlRecordTypes)RecCode) {
4808 if (Record[0] != VERSION_MAJOR)
4810 if (Listener.ReadFullVersionInformation(Blob))
4814 Listener.ReadModuleName(Blob);
4816 case MODULE_DIRECTORY:
4819 case MODULE_MAP_FILE: {
4821 auto Path = ReadString(Record, Idx);
4822 ResolveImportedPath(Path, ModuleDir);
4823 Listener.ReadModuleMapFile(Path);
4826 case INPUT_FILE_OFFSETS: {
4827 if (!NeedsInputFiles)
4830 unsigned NumInputFiles = Record[0];
4831 unsigned NumUserFiles = Record[1];
4832 const llvm::support::unaligned_uint64_t *InputFileOffs =
4833 (const llvm::support::unaligned_uint64_t *)Blob.data();
4834 for (unsigned I = 0; I != NumInputFiles; ++I) {
4835 // Go find this input file.
4836 bool isSystemFile = I >= NumUserFiles;
4838 if (isSystemFile && !NeedsSystemInputFiles)
4839 break; // the rest are system input files
4841 BitstreamCursor &Cursor = InputFilesCursor;
4842 SavedStreamPosition SavedPosition(Cursor);
4843 Cursor.JumpToBit(InputFileOffs[I]);
4845 unsigned Code = Cursor.ReadCode();
4848 bool shouldContinue = false;
4849 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4851 bool Overridden = static_cast<bool>(Record[3]);
4852 std::string Filename = Blob;
4853 ResolveImportedPath(Filename, ModuleDir);
4854 shouldContinue = Listener.visitInputFile(
4855 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4858 if (!shouldContinue)
4868 unsigned Idx = 0, N = Record.size();
4870 // Read information about the AST file.
4871 Idx += 5; // ImportLoc, Size, ModTime, Signature
4872 SkipString(Record, Idx); // Module name; FIXME: pass to listener?
4873 std::string Filename = ReadString(Record, Idx);
4874 ResolveImportedPath(Filename, ModuleDir);
4875 Listener.visitImport(Filename);
4881 // No other validation to perform.
4886 // Look for module file extension blocks, if requested.
4887 if (FindModuleFileExtensions) {
4888 BitstreamCursor SavedStream = Stream;
4889 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4890 bool DoneWithExtensionBlock = false;
4891 while (!DoneWithExtensionBlock) {
4892 llvm::BitstreamEntry Entry = Stream.advance();
4894 switch (Entry.Kind) {
4895 case llvm::BitstreamEntry::SubBlock:
4896 if (Stream.SkipBlock())
4901 case llvm::BitstreamEntry::EndBlock:
4902 DoneWithExtensionBlock = true;
4905 case llvm::BitstreamEntry::Error:
4908 case llvm::BitstreamEntry::Record:
4914 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4916 case EXTENSION_METADATA: {
4917 ModuleFileExtensionMetadata Metadata;
4918 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4921 Listener.readModuleFileExtension(Metadata);
4927 Stream = SavedStream;
4930 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4931 if (readUnhashedControlBlockImpl(
4932 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4933 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4934 ValidateDiagnosticOptions) != Success)
4940 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
4941 const PCHContainerReader &PCHContainerRdr,
4942 const LangOptions &LangOpts,
4943 const TargetOptions &TargetOpts,
4944 const PreprocessorOptions &PPOpts,
4945 StringRef ExistingModuleCachePath) {
4946 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4947 ExistingModuleCachePath, FileMgr);
4948 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4949 /*FindModuleFileExtensions=*/false,
4951 /*ValidateDiagnosticOptions=*/true);
4954 ASTReader::ASTReadResult
4955 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4956 // Enter the submodule block.
4957 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4958 Error("malformed submodule block record in AST file");
4962 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4964 Module *CurrentModule = nullptr;
4967 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4969 switch (Entry.Kind) {
4970 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4971 case llvm::BitstreamEntry::Error:
4972 Error("malformed block record in AST file");
4974 case llvm::BitstreamEntry::EndBlock:
4976 case llvm::BitstreamEntry::Record:
4977 // The interesting case.
4984 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4986 if ((Kind == SUBMODULE_METADATA) != First) {
4987 Error("submodule metadata record should be at beginning of block");
4992 // Submodule information is only valid if we have a current module.
4993 // FIXME: Should we error on these cases?
4994 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4995 Kind != SUBMODULE_DEFINITION)
4999 default: // Default behavior: ignore.
5002 case SUBMODULE_DEFINITION: {
5003 if (Record.size() < 12) {
5004 Error("malformed module definition");
5008 StringRef Name = Blob;
5010 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5011 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5012 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5013 bool IsFramework = Record[Idx++];
5014 bool IsExplicit = Record[Idx++];
5015 bool IsSystem = Record[Idx++];
5016 bool IsExternC = Record[Idx++];
5017 bool InferSubmodules = Record[Idx++];
5018 bool InferExplicitSubmodules = Record[Idx++];
5019 bool InferExportWildcard = Record[Idx++];
5020 bool ConfigMacrosExhaustive = Record[Idx++];
5021 bool ModuleMapIsPrivate = Record[Idx++];
5023 Module *ParentModule = nullptr;
5025 ParentModule = getSubmodule(Parent);
5027 // Retrieve this (sub)module from the module map, creating it if
5030 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5033 // FIXME: set the definition loc for CurrentModule, or call
5034 // ModMap.setInferredModuleAllowedBy()
5036 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5037 if (GlobalIndex >= SubmodulesLoaded.size() ||
5038 SubmodulesLoaded[GlobalIndex]) {
5039 Error("too many submodules");
5043 if (!ParentModule) {
5044 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5045 // Don't emit module relocation error if we have -fno-validate-pch
5046 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5047 CurFile != F.File) {
5048 if (!Diags.isDiagnosticInFlight()) {
5049 Diag(diag::err_module_file_conflict)
5050 << CurrentModule->getTopLevelModuleName()
5051 << CurFile->getName()
5052 << F.File->getName();
5058 CurrentModule->setASTFile(F.File);
5059 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5062 CurrentModule->Kind = Kind;
5063 CurrentModule->Signature = F.Signature;
5064 CurrentModule->IsFromModuleFile = true;
5065 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5066 CurrentModule->IsExternC = IsExternC;
5067 CurrentModule->InferSubmodules = InferSubmodules;
5068 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5069 CurrentModule->InferExportWildcard = InferExportWildcard;
5070 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5071 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5072 if (DeserializationListener)
5073 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5075 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5077 // Clear out data that will be replaced by what is in the module file.
5078 CurrentModule->LinkLibraries.clear();
5079 CurrentModule->ConfigMacros.clear();
5080 CurrentModule->UnresolvedConflicts.clear();
5081 CurrentModule->Conflicts.clear();
5083 // The module is available unless it's missing a requirement; relevant
5084 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5085 // Missing headers that were present when the module was built do not
5086 // make it unavailable -- if we got this far, this must be an explicitly
5087 // imported module file.
5088 CurrentModule->Requirements.clear();
5089 CurrentModule->MissingHeaders.clear();
5090 CurrentModule->IsMissingRequirement =
5091 ParentModule && ParentModule->IsMissingRequirement;
5092 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5096 case SUBMODULE_UMBRELLA_HEADER: {
5097 std::string Filename = Blob;
5098 ResolveImportedPath(F, Filename);
5099 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5100 if (!CurrentModule->getUmbrellaHeader())
5101 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5102 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5103 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5104 Error("mismatched umbrella headers in submodule");
5111 case SUBMODULE_HEADER:
5112 case SUBMODULE_EXCLUDED_HEADER:
5113 case SUBMODULE_PRIVATE_HEADER:
5114 // We lazily associate headers with their modules via the HeaderInfo table.
5115 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5116 // of complete filenames or remove it entirely.
5119 case SUBMODULE_TEXTUAL_HEADER:
5120 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5121 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5125 case SUBMODULE_TOPHEADER:
5126 CurrentModule->addTopHeaderFilename(Blob);
5129 case SUBMODULE_UMBRELLA_DIR: {
5130 std::string Dirname = Blob;
5131 ResolveImportedPath(F, Dirname);
5132 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5133 if (!CurrentModule->getUmbrellaDir())
5134 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5135 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5136 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5137 Error("mismatched umbrella directories in submodule");
5144 case SUBMODULE_METADATA: {
5145 F.BaseSubmoduleID = getTotalNumSubmodules();
5146 F.LocalNumSubmodules = Record[0];
5147 unsigned LocalBaseSubmoduleID = Record[1];
5148 if (F.LocalNumSubmodules > 0) {
5149 // Introduce the global -> local mapping for submodules within this
5151 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5153 // Introduce the local -> global mapping for submodules within this
5155 F.SubmoduleRemap.insertOrReplace(
5156 std::make_pair(LocalBaseSubmoduleID,
5157 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5159 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5164 case SUBMODULE_IMPORTS:
5165 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5166 UnresolvedModuleRef Unresolved;
5167 Unresolved.File = &F;
5168 Unresolved.Mod = CurrentModule;
5169 Unresolved.ID = Record[Idx];
5170 Unresolved.Kind = UnresolvedModuleRef::Import;
5171 Unresolved.IsWildcard = false;
5172 UnresolvedModuleRefs.push_back(Unresolved);
5176 case SUBMODULE_EXPORTS:
5177 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5178 UnresolvedModuleRef Unresolved;
5179 Unresolved.File = &F;
5180 Unresolved.Mod = CurrentModule;
5181 Unresolved.ID = Record[Idx];
5182 Unresolved.Kind = UnresolvedModuleRef::Export;
5183 Unresolved.IsWildcard = Record[Idx + 1];
5184 UnresolvedModuleRefs.push_back(Unresolved);
5187 // Once we've loaded the set of exports, there's no reason to keep
5188 // the parsed, unresolved exports around.
5189 CurrentModule->UnresolvedExports.clear();
5192 case SUBMODULE_REQUIRES:
5193 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5194 PP.getTargetInfo());
5197 case SUBMODULE_LINK_LIBRARY:
5198 ModMap.resolveLinkAsDependencies(CurrentModule);
5199 CurrentModule->LinkLibraries.push_back(
5200 Module::LinkLibrary(Blob, Record[0]));
5203 case SUBMODULE_CONFIG_MACRO:
5204 CurrentModule->ConfigMacros.push_back(Blob.str());
5207 case SUBMODULE_CONFLICT: {
5208 UnresolvedModuleRef Unresolved;
5209 Unresolved.File = &F;
5210 Unresolved.Mod = CurrentModule;
5211 Unresolved.ID = Record[0];
5212 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5213 Unresolved.IsWildcard = false;
5214 Unresolved.String = Blob;
5215 UnresolvedModuleRefs.push_back(Unresolved);
5219 case SUBMODULE_INITIALIZERS: {
5222 SmallVector<uint32_t, 16> Inits;
5223 for (auto &ID : Record)
5224 Inits.push_back(getGlobalDeclID(F, ID));
5225 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5229 case SUBMODULE_EXPORT_AS:
5230 CurrentModule->ExportAsModule = Blob.str();
5231 ModMap.addLinkAsDependency(CurrentModule);
5237 /// Parse the record that corresponds to a LangOptions data
5240 /// This routine parses the language options from the AST file and then gives
5241 /// them to the AST listener if one is set.
5243 /// \returns true if the listener deems the file unacceptable, false otherwise.
5244 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5246 ASTReaderListener &Listener,
5247 bool AllowCompatibleDifferences) {
5248 LangOptions LangOpts;
5250 #define LANGOPT(Name, Bits, Default, Description) \
5251 LangOpts.Name = Record[Idx++];
5252 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5253 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5254 #include "clang/Basic/LangOptions.def"
5255 #define SANITIZER(NAME, ID) \
5256 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5257 #include "clang/Basic/Sanitizers.def"
5259 for (unsigned N = Record[Idx++]; N; --N)
5260 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5262 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5263 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5264 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5266 LangOpts.CurrentModule = ReadString(Record, Idx);
5269 for (unsigned N = Record[Idx++]; N; --N) {
5270 LangOpts.CommentOpts.BlockCommandNames.push_back(
5271 ReadString(Record, Idx));
5273 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5275 // OpenMP offloading options.
5276 for (unsigned N = Record[Idx++]; N; --N) {
5277 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5280 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5282 return Listener.ReadLanguageOptions(LangOpts, Complain,
5283 AllowCompatibleDifferences);
5286 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5287 ASTReaderListener &Listener,
5288 bool AllowCompatibleDifferences) {
5290 TargetOptions TargetOpts;
5291 TargetOpts.Triple = ReadString(Record, Idx);
5292 TargetOpts.CPU = ReadString(Record, Idx);
5293 TargetOpts.ABI = ReadString(Record, Idx);
5294 for (unsigned N = Record[Idx++]; N; --N) {
5295 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5297 for (unsigned N = Record[Idx++]; N; --N) {
5298 TargetOpts.Features.push_back(ReadString(Record, Idx));
5301 return Listener.ReadTargetOptions(TargetOpts, Complain,
5302 AllowCompatibleDifferences);
5305 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5306 ASTReaderListener &Listener) {
5307 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5309 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5310 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5311 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5312 #include "clang/Basic/DiagnosticOptions.def"
5314 for (unsigned N = Record[Idx++]; N; --N)
5315 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5316 for (unsigned N = Record[Idx++]; N; --N)
5317 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5319 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5322 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5323 ASTReaderListener &Listener) {
5324 FileSystemOptions FSOpts;
5326 FSOpts.WorkingDir = ReadString(Record, Idx);
5327 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5330 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5332 ASTReaderListener &Listener) {
5333 HeaderSearchOptions HSOpts;
5335 HSOpts.Sysroot = ReadString(Record, Idx);
5338 for (unsigned N = Record[Idx++]; N; --N) {
5339 std::string Path = ReadString(Record, Idx);
5340 frontend::IncludeDirGroup Group
5341 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5342 bool IsFramework = Record[Idx++];
5343 bool IgnoreSysRoot = Record[Idx++];
5344 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5348 // System header prefixes.
5349 for (unsigned N = Record[Idx++]; N; --N) {
5350 std::string Prefix = ReadString(Record, Idx);
5351 bool IsSystemHeader = Record[Idx++];
5352 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5355 HSOpts.ResourceDir = ReadString(Record, Idx);
5356 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5357 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5358 HSOpts.DisableModuleHash = Record[Idx++];
5359 HSOpts.ImplicitModuleMaps = Record[Idx++];
5360 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5361 HSOpts.UseBuiltinIncludes = Record[Idx++];
5362 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5363 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5364 HSOpts.UseLibcxx = Record[Idx++];
5365 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5367 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5371 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5373 ASTReaderListener &Listener,
5374 std::string &SuggestedPredefines) {
5375 PreprocessorOptions PPOpts;
5378 // Macro definitions/undefs
5379 for (unsigned N = Record[Idx++]; N; --N) {
5380 std::string Macro = ReadString(Record, Idx);
5381 bool IsUndef = Record[Idx++];
5382 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5386 for (unsigned N = Record[Idx++]; N; --N) {
5387 PPOpts.Includes.push_back(ReadString(Record, Idx));
5391 for (unsigned N = Record[Idx++]; N; --N) {
5392 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5395 PPOpts.UsePredefines = Record[Idx++];
5396 PPOpts.DetailedRecord = Record[Idx++];
5397 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5398 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
5399 PPOpts.ObjCXXARCStandardLibrary =
5400 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5401 SuggestedPredefines.clear();
5402 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5403 SuggestedPredefines);
5406 std::pair<ModuleFile *, unsigned>
5407 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5408 GlobalPreprocessedEntityMapType::iterator
5409 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5410 assert(I != GlobalPreprocessedEntityMap.end() &&
5411 "Corrupted global preprocessed entity map");
5412 ModuleFile *M = I->second;
5413 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5414 return std::make_pair(M, LocalIndex);
5417 llvm::iterator_range<PreprocessingRecord::iterator>
5418 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5419 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5420 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5421 Mod.NumPreprocessedEntities);
5423 return llvm::make_range(PreprocessingRecord::iterator(),
5424 PreprocessingRecord::iterator());
5427 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5428 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5429 return llvm::make_range(
5430 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5431 ModuleDeclIterator(this, &Mod,
5432 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5435 SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5436 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5437 assert(I != GlobalSkippedRangeMap.end() &&
5438 "Corrupted global skipped range map");
5439 ModuleFile *M = I->second;
5440 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5441 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5442 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5443 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5444 TranslateSourceLocation(*M, RawRange.getEnd()));
5445 assert(Range.isValid());
5449 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5450 PreprocessedEntityID PPID = Index+1;
5451 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5452 ModuleFile &M = *PPInfo.first;
5453 unsigned LocalIndex = PPInfo.second;
5454 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5456 if (!PP.getPreprocessingRecord()) {
5457 Error("no preprocessing record");
5461 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5462 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5464 llvm::BitstreamEntry Entry =
5465 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5466 if (Entry.Kind != llvm::BitstreamEntry::Record)
5470 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5471 TranslateSourceLocation(M, PPOffs.getEnd()));
5472 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5475 PreprocessorDetailRecordTypes RecType =
5476 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
5477 Entry.ID, Record, &Blob);
5479 case PPD_MACRO_EXPANSION: {
5480 bool isBuiltin = Record[0];
5481 IdentifierInfo *Name = nullptr;
5482 MacroDefinitionRecord *Def = nullptr;
5484 Name = getLocalIdentifier(M, Record[1]);
5486 PreprocessedEntityID GlobalID =
5487 getGlobalPreprocessedEntityID(M, Record[1]);
5488 Def = cast<MacroDefinitionRecord>(
5489 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5494 ME = new (PPRec) MacroExpansion(Name, Range);
5496 ME = new (PPRec) MacroExpansion(Def, Range);
5501 case PPD_MACRO_DEFINITION: {
5502 // Decode the identifier info and then check again; if the macro is
5503 // still defined and associated with the identifier,
5504 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5505 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5507 if (DeserializationListener)
5508 DeserializationListener->MacroDefinitionRead(PPID, MD);
5513 case PPD_INCLUSION_DIRECTIVE: {
5514 const char *FullFileNameStart = Blob.data() + Record[0];
5515 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5516 const FileEntry *File = nullptr;
5517 if (!FullFileName.empty())
5518 File = PP.getFileManager().getFile(FullFileName);
5520 // FIXME: Stable encoding
5521 InclusionDirective::InclusionKind Kind
5522 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5523 InclusionDirective *ID
5524 = new (PPRec) InclusionDirective(PPRec, Kind,
5525 StringRef(Blob.data(), Record[0]),
5526 Record[1], Record[3],
5533 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5536 /// Find the next module that contains entities and return the ID
5537 /// of the first entry.
5539 /// \param SLocMapI points at a chunk of a module that contains no
5540 /// preprocessed entities or the entities it contains are not the ones we are
5542 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5543 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5545 for (GlobalSLocOffsetMapType::const_iterator
5546 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5547 ModuleFile &M = *SLocMapI->second;
5548 if (M.NumPreprocessedEntities)
5549 return M.BasePreprocessedEntityID;
5552 return getTotalNumPreprocessedEntities();
5557 struct PPEntityComp {
5558 const ASTReader &Reader;
5561 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5563 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5564 SourceLocation LHS = getLoc(L);
5565 SourceLocation RHS = getLoc(R);
5566 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5569 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5570 SourceLocation LHS = getLoc(L);
5571 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5574 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5575 SourceLocation RHS = getLoc(R);
5576 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5579 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5580 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5586 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5587 bool EndsAfter) const {
5588 if (SourceMgr.isLocalSourceLocation(Loc))
5589 return getTotalNumPreprocessedEntities();
5591 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5592 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5593 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5594 "Corrupted global sloc offset map");
5596 if (SLocMapI->second->NumPreprocessedEntities == 0)
5597 return findNextPreprocessedEntity(SLocMapI);
5599 ModuleFile &M = *SLocMapI->second;
5601 using pp_iterator = const PPEntityOffset *;
5603 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5604 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5606 size_t Count = M.NumPreprocessedEntities;
5608 pp_iterator First = pp_begin;
5612 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5613 PPEntityComp(*this, M));
5615 // Do a binary search manually instead of using std::lower_bound because
5616 // The end locations of entities may be unordered (when a macro expansion
5617 // is inside another macro argument), but for this case it is not important
5618 // whether we get the first macro expansion or its containing macro.
5622 std::advance(PPI, Half);
5623 if (SourceMgr.isBeforeInTranslationUnit(
5624 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5627 Count = Count - Half - 1;
5634 return findNextPreprocessedEntity(SLocMapI);
5636 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5639 /// Returns a pair of [Begin, End) indices of preallocated
5640 /// preprocessed entities that \arg Range encompasses.
5641 std::pair<unsigned, unsigned>
5642 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5643 if (Range.isInvalid())
5644 return std::make_pair(0,0);
5645 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5647 PreprocessedEntityID BeginID =
5648 findPreprocessedEntity(Range.getBegin(), false);
5649 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5650 return std::make_pair(BeginID, EndID);
5653 /// Optionally returns true or false if the preallocated preprocessed
5654 /// entity with index \arg Index came from file \arg FID.
5655 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5657 if (FID.isInvalid())
5660 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5661 ModuleFile &M = *PPInfo.first;
5662 unsigned LocalIndex = PPInfo.second;
5663 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5665 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5666 if (Loc.isInvalid())
5669 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5677 /// Visitor used to search for information about a header file.
5678 class HeaderFileInfoVisitor {
5679 const FileEntry *FE;
5680 Optional<HeaderFileInfo> HFI;
5683 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5685 bool operator()(ModuleFile &M) {
5686 HeaderFileInfoLookupTable *Table
5687 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5691 // Look in the on-disk hash table for an entry for this file name.
5692 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5693 if (Pos == Table->end())
5700 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5705 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5706 HeaderFileInfoVisitor Visitor(FE);
5707 ModuleMgr.visit(Visitor);
5708 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5711 return HeaderFileInfo();
5714 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5715 using DiagState = DiagnosticsEngine::DiagState;
5716 SmallVector<DiagState *, 32> DiagStates;
5718 for (ModuleFile &F : ModuleMgr) {
5720 auto &Record = F.PragmaDiagMappings;
5726 auto ReadDiagState =
5727 [&](const DiagState &BasedOn, SourceLocation Loc,
5728 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5729 unsigned BackrefID = Record[Idx++];
5731 return DiagStates[BackrefID - 1];
5733 // A new DiagState was created here.
5734 Diag.DiagStates.push_back(BasedOn);
5735 DiagState *NewState = &Diag.DiagStates.back();
5736 DiagStates.push_back(NewState);
5737 unsigned Size = Record[Idx++];
5738 assert(Idx + Size * 2 <= Record.size() &&
5739 "Invalid data, not enough diag/map pairs");
5741 unsigned DiagID = Record[Idx++];
5742 DiagnosticMapping NewMapping =
5743 DiagnosticMapping::deserialize(Record[Idx++]);
5744 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5747 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5749 // If this mapping was specified as a warning but the severity was
5750 // upgraded due to diagnostic settings, simulate the current diagnostic
5751 // settings (and use a warning).
5752 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5753 NewMapping.setSeverity(diag::Severity::Warning);
5754 NewMapping.setUpgradedFromWarning(false);
5757 Mapping = NewMapping;
5762 // Read the first state.
5763 DiagState *FirstState;
5764 if (F.Kind == MK_ImplicitModule) {
5765 // Implicitly-built modules are reused with different diagnostic
5766 // settings. Use the initial diagnostic state from Diag to simulate this
5767 // compilation's diagnostic settings.
5768 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5769 DiagStates.push_back(FirstState);
5771 // Skip the initial diagnostic state from the serialized module.
5772 assert(Record[1] == 0 &&
5773 "Invalid data, unexpected backref in initial state");
5774 Idx = 3 + Record[2] * 2;
5775 assert(Idx < Record.size() &&
5776 "Invalid data, not enough state change pairs in initial state");
5777 } else if (F.isModule()) {
5778 // For an explicit module, preserve the flags from the module build
5779 // command line (-w, -Weverything, -Werror, ...) along with any explicit
5781 unsigned Flags = Record[Idx++];
5783 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5784 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5785 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5786 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5787 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5788 Initial.ExtBehavior = (diag::Severity)Flags;
5789 FirstState = ReadDiagState(Initial, SourceLocation(), true);
5791 assert(F.OriginalSourceFileID.isValid());
5793 // Set up the root buffer of the module to start with the initial
5794 // diagnostic state of the module itself, to cover files that contain no
5795 // explicit transitions (for which we did not serialize anything).
5796 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5797 .StateTransitions.push_back({FirstState, 0});
5799 // For prefix ASTs, start with whatever the user configured on the
5801 Idx++; // Skip flags.
5802 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5803 SourceLocation(), false);
5806 // Read the state transitions.
5807 unsigned NumLocations = Record[Idx++];
5808 while (NumLocations--) {
5809 assert(Idx < Record.size() &&
5810 "Invalid data, missing pragma diagnostic states");
5811 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5812 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5813 assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
5814 assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5815 unsigned Transitions = Record[Idx++];
5817 // Note that we don't need to set up Parent/ParentOffset here, because
5818 // we won't be changing the diagnostic state within imported FileIDs
5819 // (other than perhaps appending to the main source file, which has no
5821 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5822 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5823 for (unsigned I = 0; I != Transitions; ++I) {
5824 unsigned Offset = Record[Idx++];
5826 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5827 F.StateTransitions.push_back({State, Offset});
5831 // Read the final state.
5832 assert(Idx < Record.size() &&
5833 "Invalid data, missing final pragma diagnostic state");
5834 SourceLocation CurStateLoc =
5835 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5836 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5838 if (!F.isModule()) {
5839 Diag.DiagStatesByLoc.CurDiagState = CurState;
5840 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5842 // Preserve the property that the imaginary root file describes the
5845 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5847 T.push_back({CurState, 0});
5849 T[0].State = CurState;
5852 // Don't try to read these mappings again.
5857 /// Get the correct cursor and offset for loading a type.
5858 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5859 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5860 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5861 ModuleFile *M = I->second;
5862 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5865 /// Read and return the type with the given index..
5867 /// The index is the type ID, shifted and minus the number of predefs. This
5868 /// routine actually reads the record corresponding to the type at the given
5869 /// location. It is a helper routine for GetType, which deals with reading type
5871 QualType ASTReader::readTypeRecord(unsigned Index) {
5872 assert(ContextObj && "reading type with no AST context");
5873 ASTContext &Context = *ContextObj;
5874 RecordLocation Loc = TypeCursorForIndex(Index);
5875 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5877 // Keep track of where we are in the stream, then jump back there
5878 // after reading this type.
5879 SavedStreamPosition SavedPosition(DeclsCursor);
5881 ReadingKindTracker ReadingKind(Read_Type, *this);
5883 // Note that we are loading a type record.
5884 Deserializing AType(this);
5887 DeclsCursor.JumpToBit(Loc.Offset);
5889 unsigned Code = DeclsCursor.ReadCode();
5890 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5891 case TYPE_EXT_QUAL: {
5892 if (Record.size() != 2) {
5893 Error("Incorrect encoding of extended qualifier type");
5896 QualType Base = readType(*Loc.F, Record, Idx);
5897 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5898 return Context.getQualifiedType(Base, Quals);
5901 case TYPE_COMPLEX: {
5902 if (Record.size() != 1) {
5903 Error("Incorrect encoding of complex type");
5906 QualType ElemType = readType(*Loc.F, Record, Idx);
5907 return Context.getComplexType(ElemType);
5910 case TYPE_POINTER: {
5911 if (Record.size() != 1) {
5912 Error("Incorrect encoding of pointer type");
5915 QualType PointeeType = readType(*Loc.F, Record, Idx);
5916 return Context.getPointerType(PointeeType);
5919 case TYPE_DECAYED: {
5920 if (Record.size() != 1) {
5921 Error("Incorrect encoding of decayed type");
5924 QualType OriginalType = readType(*Loc.F, Record, Idx);
5925 QualType DT = Context.getAdjustedParameterType(OriginalType);
5926 if (!isa<DecayedType>(DT))
5927 Error("Decayed type does not decay");
5931 case TYPE_ADJUSTED: {
5932 if (Record.size() != 2) {
5933 Error("Incorrect encoding of adjusted type");
5936 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5937 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5938 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5941 case TYPE_BLOCK_POINTER: {
5942 if (Record.size() != 1) {
5943 Error("Incorrect encoding of block pointer type");
5946 QualType PointeeType = readType(*Loc.F, Record, Idx);
5947 return Context.getBlockPointerType(PointeeType);
5950 case TYPE_LVALUE_REFERENCE: {
5951 if (Record.size() != 2) {
5952 Error("Incorrect encoding of lvalue reference type");
5955 QualType PointeeType = readType(*Loc.F, Record, Idx);
5956 return Context.getLValueReferenceType(PointeeType, Record[1]);
5959 case TYPE_RVALUE_REFERENCE: {
5960 if (Record.size() != 1) {
5961 Error("Incorrect encoding of rvalue reference type");
5964 QualType PointeeType = readType(*Loc.F, Record, Idx);
5965 return Context.getRValueReferenceType(PointeeType);
5968 case TYPE_MEMBER_POINTER: {
5969 if (Record.size() != 2) {
5970 Error("Incorrect encoding of member pointer type");
5973 QualType PointeeType = readType(*Loc.F, Record, Idx);
5974 QualType ClassType = readType(*Loc.F, Record, Idx);
5975 if (PointeeType.isNull() || ClassType.isNull())
5978 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5981 case TYPE_CONSTANT_ARRAY: {
5982 QualType ElementType = readType(*Loc.F, Record, Idx);
5983 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5984 unsigned IndexTypeQuals = Record[2];
5986 llvm::APInt Size = ReadAPInt(Record, Idx);
5987 return Context.getConstantArrayType(ElementType, Size,
5988 ASM, IndexTypeQuals);
5991 case TYPE_INCOMPLETE_ARRAY: {
5992 QualType ElementType = readType(*Loc.F, Record, Idx);
5993 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5994 unsigned IndexTypeQuals = Record[2];
5995 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5998 case TYPE_VARIABLE_ARRAY: {
5999 QualType ElementType = readType(*Loc.F, Record, Idx);
6000 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6001 unsigned IndexTypeQuals = Record[2];
6002 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
6003 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
6004 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
6005 ASM, IndexTypeQuals,
6006 SourceRange(LBLoc, RBLoc));
6010 if (Record.size() != 3) {
6011 Error("incorrect encoding of vector type in AST file");
6015 QualType ElementType = readType(*Loc.F, Record, Idx);
6016 unsigned NumElements = Record[1];
6017 unsigned VecKind = Record[2];
6018 return Context.getVectorType(ElementType, NumElements,
6019 (VectorType::VectorKind)VecKind);
6022 case TYPE_EXT_VECTOR: {
6023 if (Record.size() != 3) {
6024 Error("incorrect encoding of extended vector type in AST file");
6028 QualType ElementType = readType(*Loc.F, Record, Idx);
6029 unsigned NumElements = Record[1];
6030 return Context.getExtVectorType(ElementType, NumElements);
6033 case TYPE_FUNCTION_NO_PROTO: {
6034 if (Record.size() != 8) {
6035 Error("incorrect encoding of no-proto function type");
6038 QualType ResultType = readType(*Loc.F, Record, Idx);
6039 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6040 (CallingConv)Record[4], Record[5], Record[6],
6042 return Context.getFunctionNoProtoType(ResultType, Info);
6045 case TYPE_FUNCTION_PROTO: {
6046 QualType ResultType = readType(*Loc.F, Record, Idx);
6048 FunctionProtoType::ExtProtoInfo EPI;
6049 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
6050 /*hasregparm*/ Record[2],
6051 /*regparm*/ Record[3],
6052 static_cast<CallingConv>(Record[4]),
6053 /*produces*/ Record[5],
6054 /*nocallersavedregs*/ Record[6],
6055 /*nocfcheck*/ Record[7]);
6059 EPI.Variadic = Record[Idx++];
6060 EPI.HasTrailingReturn = Record[Idx++];
6061 EPI.TypeQuals = Record[Idx++];
6062 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
6063 SmallVector<QualType, 8> ExceptionStorage;
6064 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6066 unsigned NumParams = Record[Idx++];
6067 SmallVector<QualType, 16> ParamTypes;
6068 for (unsigned I = 0; I != NumParams; ++I)
6069 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6071 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
6072 if (Idx != Record.size()) {
6073 for (unsigned I = 0; I != NumParams; ++I)
6074 ExtParameterInfos.push_back(
6075 FunctionProtoType::ExtParameterInfo
6076 ::getFromOpaqueValue(Record[Idx++]));
6077 EPI.ExtParameterInfos = ExtParameterInfos.data();
6080 assert(Idx == Record.size());
6082 return Context.getFunctionType(ResultType, ParamTypes, EPI);
6085 case TYPE_UNRESOLVED_USING: {
6087 return Context.getTypeDeclType(
6088 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6091 case TYPE_TYPEDEF: {
6092 if (Record.size() != 2) {
6093 Error("incorrect encoding of typedef type");
6097 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6098 QualType Canonical = readType(*Loc.F, Record, Idx);
6099 if (!Canonical.isNull())
6100 Canonical = Context.getCanonicalType(Canonical);
6101 return Context.getTypedefType(Decl, Canonical);
6104 case TYPE_TYPEOF_EXPR:
6105 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6108 if (Record.size() != 1) {
6109 Error("incorrect encoding of typeof(type) in AST file");
6112 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6113 return Context.getTypeOfType(UnderlyingType);
6116 case TYPE_DECLTYPE: {
6117 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6118 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6121 case TYPE_UNARY_TRANSFORM: {
6122 QualType BaseType = readType(*Loc.F, Record, Idx);
6123 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6124 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
6125 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6129 QualType Deduced = readType(*Loc.F, Record, Idx);
6130 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6131 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6132 return Context.getAutoType(Deduced, Keyword, IsDependent);
6135 case TYPE_DEDUCED_TEMPLATE_SPECIALIZATION: {
6136 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6137 QualType Deduced = readType(*Loc.F, Record, Idx);
6138 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6139 return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6144 if (Record.size() != 2) {
6145 Error("incorrect encoding of record type");
6149 bool IsDependent = Record[Idx++];
6150 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6151 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6152 QualType T = Context.getRecordType(RD);
6153 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6158 if (Record.size() != 2) {
6159 Error("incorrect encoding of enum type");
6163 bool IsDependent = Record[Idx++];
6165 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6166 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6170 case TYPE_ATTRIBUTED: {
6171 if (Record.size() != 3) {
6172 Error("incorrect encoding of attributed type");
6175 QualType modifiedType = readType(*Loc.F, Record, Idx);
6176 QualType equivalentType = readType(*Loc.F, Record, Idx);
6177 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6178 return Context.getAttributedType(kind, modifiedType, equivalentType);
6182 if (Record.size() != 1) {
6183 Error("incorrect encoding of paren type");
6186 QualType InnerType = readType(*Loc.F, Record, Idx);
6187 return Context.getParenType(InnerType);
6190 case TYPE_PACK_EXPANSION: {
6191 if (Record.size() != 2) {
6192 Error("incorrect encoding of pack expansion type");
6195 QualType Pattern = readType(*Loc.F, Record, Idx);
6196 if (Pattern.isNull())
6198 Optional<unsigned> NumExpansions;
6200 NumExpansions = Record[1] - 1;
6201 return Context.getPackExpansionType(Pattern, NumExpansions);
6204 case TYPE_ELABORATED: {
6206 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6207 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6208 QualType NamedType = readType(*Loc.F, Record, Idx);
6209 TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
6210 return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
6213 case TYPE_OBJC_INTERFACE: {
6215 ObjCInterfaceDecl *ItfD
6216 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6217 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6220 case TYPE_OBJC_TYPE_PARAM: {
6222 ObjCTypeParamDecl *Decl
6223 = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6224 unsigned NumProtos = Record[Idx++];
6225 SmallVector<ObjCProtocolDecl*, 4> Protos;
6226 for (unsigned I = 0; I != NumProtos; ++I)
6227 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6228 return Context.getObjCTypeParamType(Decl, Protos);
6231 case TYPE_OBJC_OBJECT: {
6233 QualType Base = readType(*Loc.F, Record, Idx);
6234 unsigned NumTypeArgs = Record[Idx++];
6235 SmallVector<QualType, 4> TypeArgs;
6236 for (unsigned I = 0; I != NumTypeArgs; ++I)
6237 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6238 unsigned NumProtos = Record[Idx++];
6239 SmallVector<ObjCProtocolDecl*, 4> Protos;
6240 for (unsigned I = 0; I != NumProtos; ++I)
6241 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6242 bool IsKindOf = Record[Idx++];
6243 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6246 case TYPE_OBJC_OBJECT_POINTER: {
6248 QualType Pointee = readType(*Loc.F, Record, Idx);
6249 return Context.getObjCObjectPointerType(Pointee);
6252 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
6254 QualType Parm = readType(*Loc.F, Record, Idx);
6255 QualType Replacement = readType(*Loc.F, Record, Idx);
6256 return Context.getSubstTemplateTypeParmType(
6257 cast<TemplateTypeParmType>(Parm),
6258 Context.getCanonicalType(Replacement));
6261 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
6263 QualType Parm = readType(*Loc.F, Record, Idx);
6264 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6265 return Context.getSubstTemplateTypeParmPackType(
6266 cast<TemplateTypeParmType>(Parm),
6270 case TYPE_INJECTED_CLASS_NAME: {
6271 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6272 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6273 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6274 // for AST reading, too much interdependencies.
6275 const Type *T = nullptr;
6276 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6277 if (const Type *Existing = DI->getTypeForDecl()) {
6283 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6284 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6285 DI->setTypeForDecl(T);
6287 return QualType(T, 0);
6290 case TYPE_TEMPLATE_TYPE_PARM: {
6292 unsigned Depth = Record[Idx++];
6293 unsigned Index = Record[Idx++];
6294 bool Pack = Record[Idx++];
6295 TemplateTypeParmDecl *D
6296 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6297 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6300 case TYPE_DEPENDENT_NAME: {
6302 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6303 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6304 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6305 QualType Canon = readType(*Loc.F, Record, Idx);
6306 if (!Canon.isNull())
6307 Canon = Context.getCanonicalType(Canon);
6308 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6311 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
6313 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6314 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6315 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6316 unsigned NumArgs = Record[Idx++];
6317 SmallVector<TemplateArgument, 8> Args;
6318 Args.reserve(NumArgs);
6320 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6321 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6325 case TYPE_DEPENDENT_SIZED_ARRAY: {
6329 QualType ElementType = readType(*Loc.F, Record, Idx);
6330 ArrayType::ArraySizeModifier ASM
6331 = (ArrayType::ArraySizeModifier)Record[Idx++];
6332 unsigned IndexTypeQuals = Record[Idx++];
6334 // DependentSizedArrayType
6335 Expr *NumElts = ReadExpr(*Loc.F);
6336 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6338 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6339 IndexTypeQuals, Brackets);
6342 case TYPE_TEMPLATE_SPECIALIZATION: {
6344 bool IsDependent = Record[Idx++];
6345 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6346 SmallVector<TemplateArgument, 8> Args;
6347 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6348 QualType Underlying = readType(*Loc.F, Record, Idx);
6350 if (Underlying.isNull())
6351 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6353 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6354 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6359 if (Record.size() != 1) {
6360 Error("Incorrect encoding of atomic type");
6363 QualType ValueType = readType(*Loc.F, Record, Idx);
6364 return Context.getAtomicType(ValueType);
6368 if (Record.size() != 2) {
6369 Error("Incorrect encoding of pipe type");
6373 // Reading the pipe element type.
6374 QualType ElementType = readType(*Loc.F, Record, Idx);
6375 unsigned ReadOnly = Record[1];
6376 return Context.getPipeType(ElementType, ReadOnly);
6379 case TYPE_DEPENDENT_SIZED_VECTOR: {
6381 QualType ElementType = readType(*Loc.F, Record, Idx);
6382 Expr *SizeExpr = ReadExpr(*Loc.F);
6383 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6384 unsigned VecKind = Record[Idx];
6386 return Context.getDependentVectorType(ElementType, SizeExpr, AttrLoc,
6387 (VectorType::VectorKind)VecKind);
6390 case TYPE_DEPENDENT_SIZED_EXT_VECTOR: {
6393 // DependentSizedExtVectorType
6394 QualType ElementType = readType(*Loc.F, Record, Idx);
6395 Expr *SizeExpr = ReadExpr(*Loc.F);
6396 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6398 return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6402 case TYPE_DEPENDENT_ADDRESS_SPACE: {
6405 // DependentAddressSpaceType
6406 QualType PointeeType = readType(*Loc.F, Record, Idx);
6407 Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6408 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6410 return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6414 llvm_unreachable("Invalid TypeCode!");
6417 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6418 SmallVectorImpl<QualType> &Exceptions,
6419 FunctionProtoType::ExceptionSpecInfo &ESI,
6420 const RecordData &Record, unsigned &Idx) {
6421 ExceptionSpecificationType EST =
6422 static_cast<ExceptionSpecificationType>(Record[Idx++]);
6424 if (EST == EST_Dynamic) {
6425 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6426 Exceptions.push_back(readType(ModuleFile, Record, Idx));
6427 ESI.Exceptions = Exceptions;
6428 } else if (isComputedNoexcept(EST)) {
6429 ESI.NoexceptExpr = ReadExpr(ModuleFile);
6430 } else if (EST == EST_Uninstantiated) {
6431 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6432 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6433 } else if (EST == EST_Unevaluated) {
6434 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6440 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6443 const ASTReader::RecordData &Record;
6446 SourceLocation ReadSourceLocation() {
6447 return Reader->ReadSourceLocation(*F, Record, Idx);
6450 TypeSourceInfo *GetTypeSourceInfo() {
6451 return Reader->GetTypeSourceInfo(*F, Record, Idx);
6454 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6455 return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6459 TypeLocReader(ModuleFile &F, ASTReader &Reader,
6460 const ASTReader::RecordData &Record, unsigned &Idx)
6461 : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6463 // We want compile-time assurance that we've enumerated all of
6464 // these, so unfortunately we have to declare them first, then
6465 // define them out-of-line.
6466 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6467 #define TYPELOC(CLASS, PARENT) \
6468 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6469 #include "clang/AST/TypeLocNodes.def"
6471 void VisitFunctionTypeLoc(FunctionTypeLoc);
6472 void VisitArrayTypeLoc(ArrayTypeLoc);
6475 } // namespace clang
6477 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6481 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6482 TL.setBuiltinLoc(ReadSourceLocation());
6483 if (TL.needsExtraLocalData()) {
6484 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6485 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6486 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6487 TL.setModeAttr(Record[Idx++]);
6491 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6492 TL.setNameLoc(ReadSourceLocation());
6495 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6496 TL.setStarLoc(ReadSourceLocation());
6499 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6503 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6507 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6508 TL.setCaretLoc(ReadSourceLocation());
6511 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6512 TL.setAmpLoc(ReadSourceLocation());
6515 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6516 TL.setAmpAmpLoc(ReadSourceLocation());
6519 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6520 TL.setStarLoc(ReadSourceLocation());
6521 TL.setClassTInfo(GetTypeSourceInfo());
6524 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6525 TL.setLBracketLoc(ReadSourceLocation());
6526 TL.setRBracketLoc(ReadSourceLocation());
6528 TL.setSizeExpr(Reader->ReadExpr(*F));
6530 TL.setSizeExpr(nullptr);
6533 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6534 VisitArrayTypeLoc(TL);
6537 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6538 VisitArrayTypeLoc(TL);
6541 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6542 VisitArrayTypeLoc(TL);
6545 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6546 DependentSizedArrayTypeLoc TL) {
6547 VisitArrayTypeLoc(TL);
6550 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6551 DependentAddressSpaceTypeLoc TL) {
6553 TL.setAttrNameLoc(ReadSourceLocation());
6555 range.setBegin(ReadSourceLocation());
6556 range.setEnd(ReadSourceLocation());
6557 TL.setAttrOperandParensRange(range);
6558 TL.setAttrExprOperand(Reader->ReadExpr(*F));
6561 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6562 DependentSizedExtVectorTypeLoc TL) {
6563 TL.setNameLoc(ReadSourceLocation());
6566 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6567 TL.setNameLoc(ReadSourceLocation());
6570 void TypeLocReader::VisitDependentVectorTypeLoc(
6571 DependentVectorTypeLoc TL) {
6572 TL.setNameLoc(ReadSourceLocation());
6575 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6576 TL.setNameLoc(ReadSourceLocation());
6579 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6580 TL.setLocalRangeBegin(ReadSourceLocation());
6581 TL.setLParenLoc(ReadSourceLocation());
6582 TL.setRParenLoc(ReadSourceLocation());
6583 TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6584 Reader->ReadSourceLocation(*F, Record, Idx)));
6585 TL.setLocalRangeEnd(ReadSourceLocation());
6586 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6587 TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6591 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6592 VisitFunctionTypeLoc(TL);
6595 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6596 VisitFunctionTypeLoc(TL);
6599 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6600 TL.setNameLoc(ReadSourceLocation());
6603 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6604 TL.setNameLoc(ReadSourceLocation());
6607 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6608 TL.setTypeofLoc(ReadSourceLocation());
6609 TL.setLParenLoc(ReadSourceLocation());
6610 TL.setRParenLoc(ReadSourceLocation());
6613 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6614 TL.setTypeofLoc(ReadSourceLocation());
6615 TL.setLParenLoc(ReadSourceLocation());
6616 TL.setRParenLoc(ReadSourceLocation());
6617 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6620 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6621 TL.setNameLoc(ReadSourceLocation());
6624 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6625 TL.setKWLoc(ReadSourceLocation());
6626 TL.setLParenLoc(ReadSourceLocation());
6627 TL.setRParenLoc(ReadSourceLocation());
6628 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6631 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6632 TL.setNameLoc(ReadSourceLocation());
6635 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6636 DeducedTemplateSpecializationTypeLoc TL) {
6637 TL.setTemplateNameLoc(ReadSourceLocation());
6640 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6641 TL.setNameLoc(ReadSourceLocation());
6644 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6645 TL.setNameLoc(ReadSourceLocation());
6648 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6649 TL.setAttrNameLoc(ReadSourceLocation());
6650 if (TL.hasAttrOperand()) {
6652 range.setBegin(ReadSourceLocation());
6653 range.setEnd(ReadSourceLocation());
6654 TL.setAttrOperandParensRange(range);
6656 if (TL.hasAttrExprOperand()) {
6658 TL.setAttrExprOperand(Reader->ReadExpr(*F));
6660 TL.setAttrExprOperand(nullptr);
6661 } else if (TL.hasAttrEnumOperand())
6662 TL.setAttrEnumOperandLoc(ReadSourceLocation());
6665 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6666 TL.setNameLoc(ReadSourceLocation());
6669 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6670 SubstTemplateTypeParmTypeLoc TL) {
6671 TL.setNameLoc(ReadSourceLocation());
6674 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6675 SubstTemplateTypeParmPackTypeLoc TL) {
6676 TL.setNameLoc(ReadSourceLocation());
6679 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6680 TemplateSpecializationTypeLoc TL) {
6681 TL.setTemplateKeywordLoc(ReadSourceLocation());
6682 TL.setTemplateNameLoc(ReadSourceLocation());
6683 TL.setLAngleLoc(ReadSourceLocation());
6684 TL.setRAngleLoc(ReadSourceLocation());
6685 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6688 Reader->GetTemplateArgumentLocInfo(
6689 *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6692 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6693 TL.setLParenLoc(ReadSourceLocation());
6694 TL.setRParenLoc(ReadSourceLocation());
6697 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6698 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6699 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6702 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6703 TL.setNameLoc(ReadSourceLocation());
6706 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6707 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6708 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6709 TL.setNameLoc(ReadSourceLocation());
6712 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6713 DependentTemplateSpecializationTypeLoc TL) {
6714 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6715 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6716 TL.setTemplateKeywordLoc(ReadSourceLocation());
6717 TL.setTemplateNameLoc(ReadSourceLocation());
6718 TL.setLAngleLoc(ReadSourceLocation());
6719 TL.setRAngleLoc(ReadSourceLocation());
6720 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6723 Reader->GetTemplateArgumentLocInfo(
6724 *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6727 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6728 TL.setEllipsisLoc(ReadSourceLocation());
6731 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6732 TL.setNameLoc(ReadSourceLocation());
6735 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6736 if (TL.getNumProtocols()) {
6737 TL.setProtocolLAngleLoc(ReadSourceLocation());
6738 TL.setProtocolRAngleLoc(ReadSourceLocation());
6740 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6741 TL.setProtocolLoc(i, ReadSourceLocation());
6744 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6745 TL.setHasBaseTypeAsWritten(Record[Idx++]);
6746 TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6747 TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6748 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6749 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6750 TL.setProtocolLAngleLoc(ReadSourceLocation());
6751 TL.setProtocolRAngleLoc(ReadSourceLocation());
6752 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6753 TL.setProtocolLoc(i, ReadSourceLocation());
6756 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6757 TL.setStarLoc(ReadSourceLocation());
6760 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6761 TL.setKWLoc(ReadSourceLocation());
6762 TL.setLParenLoc(ReadSourceLocation());
6763 TL.setRParenLoc(ReadSourceLocation());
6766 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6767 TL.setKWLoc(ReadSourceLocation());
6770 void ASTReader::ReadTypeLoc(ModuleFile &F, const ASTReader::RecordData &Record,
6771 unsigned &Idx, TypeLoc TL) {
6772 TypeLocReader TLR(F, *this, Record, Idx);
6773 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6778 ASTReader::GetTypeSourceInfo(ModuleFile &F, const ASTReader::RecordData &Record,
6780 QualType InfoTy = readType(F, Record, Idx);
6781 if (InfoTy.isNull())
6784 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6785 ReadTypeLoc(F, Record, Idx, TInfo->getTypeLoc());
6789 QualType ASTReader::GetType(TypeID ID) {
6790 assert(ContextObj && "reading type with no AST context");
6791 ASTContext &Context = *ContextObj;
6793 unsigned FastQuals = ID & Qualifiers::FastMask;
6794 unsigned Index = ID >> Qualifiers::FastWidth;
6796 if (Index < NUM_PREDEF_TYPE_IDS) {
6798 switch ((PredefinedTypeIDs)Index) {
6799 case PREDEF_TYPE_NULL_ID:
6801 case PREDEF_TYPE_VOID_ID:
6804 case PREDEF_TYPE_BOOL_ID:
6807 case PREDEF_TYPE_CHAR_U_ID:
6808 case PREDEF_TYPE_CHAR_S_ID:
6809 // FIXME: Check that the signedness of CharTy is correct!
6812 case PREDEF_TYPE_UCHAR_ID:
6813 T = Context.UnsignedCharTy;
6815 case PREDEF_TYPE_USHORT_ID:
6816 T = Context.UnsignedShortTy;
6818 case PREDEF_TYPE_UINT_ID:
6819 T = Context.UnsignedIntTy;
6821 case PREDEF_TYPE_ULONG_ID:
6822 T = Context.UnsignedLongTy;
6824 case PREDEF_TYPE_ULONGLONG_ID:
6825 T = Context.UnsignedLongLongTy;
6827 case PREDEF_TYPE_UINT128_ID:
6828 T = Context.UnsignedInt128Ty;
6830 case PREDEF_TYPE_SCHAR_ID:
6831 T = Context.SignedCharTy;
6833 case PREDEF_TYPE_WCHAR_ID:
6834 T = Context.WCharTy;
6836 case PREDEF_TYPE_SHORT_ID:
6837 T = Context.ShortTy;
6839 case PREDEF_TYPE_INT_ID:
6842 case PREDEF_TYPE_LONG_ID:
6845 case PREDEF_TYPE_LONGLONG_ID:
6846 T = Context.LongLongTy;
6848 case PREDEF_TYPE_INT128_ID:
6849 T = Context.Int128Ty;
6851 case PREDEF_TYPE_HALF_ID:
6854 case PREDEF_TYPE_FLOAT_ID:
6855 T = Context.FloatTy;
6857 case PREDEF_TYPE_DOUBLE_ID:
6858 T = Context.DoubleTy;
6860 case PREDEF_TYPE_LONGDOUBLE_ID:
6861 T = Context.LongDoubleTy;
6863 case PREDEF_TYPE_SHORT_ACCUM_ID:
6864 T = Context.ShortAccumTy;
6866 case PREDEF_TYPE_ACCUM_ID:
6867 T = Context.AccumTy;
6869 case PREDEF_TYPE_LONG_ACCUM_ID:
6870 T = Context.LongAccumTy;
6872 case PREDEF_TYPE_USHORT_ACCUM_ID:
6873 T = Context.UnsignedShortAccumTy;
6875 case PREDEF_TYPE_UACCUM_ID:
6876 T = Context.UnsignedAccumTy;
6878 case PREDEF_TYPE_ULONG_ACCUM_ID:
6879 T = Context.UnsignedLongAccumTy;
6881 case PREDEF_TYPE_SHORT_FRACT_ID:
6882 T = Context.ShortFractTy;
6884 case PREDEF_TYPE_FRACT_ID:
6885 T = Context.FractTy;
6887 case PREDEF_TYPE_LONG_FRACT_ID:
6888 T = Context.LongFractTy;
6890 case PREDEF_TYPE_USHORT_FRACT_ID:
6891 T = Context.UnsignedShortFractTy;
6893 case PREDEF_TYPE_UFRACT_ID:
6894 T = Context.UnsignedFractTy;
6896 case PREDEF_TYPE_ULONG_FRACT_ID:
6897 T = Context.UnsignedLongFractTy;
6899 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6900 T = Context.SatShortAccumTy;
6902 case PREDEF_TYPE_SAT_ACCUM_ID:
6903 T = Context.SatAccumTy;
6905 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6906 T = Context.SatLongAccumTy;
6908 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6909 T = Context.SatUnsignedShortAccumTy;
6911 case PREDEF_TYPE_SAT_UACCUM_ID:
6912 T = Context.SatUnsignedAccumTy;
6914 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6915 T = Context.SatUnsignedLongAccumTy;
6917 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6918 T = Context.SatShortFractTy;
6920 case PREDEF_TYPE_SAT_FRACT_ID:
6921 T = Context.SatFractTy;
6923 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6924 T = Context.SatLongFractTy;
6926 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6927 T = Context.SatUnsignedShortFractTy;
6929 case PREDEF_TYPE_SAT_UFRACT_ID:
6930 T = Context.SatUnsignedFractTy;
6932 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6933 T = Context.SatUnsignedLongFractTy;
6935 case PREDEF_TYPE_FLOAT16_ID:
6936 T = Context.Float16Ty;
6938 case PREDEF_TYPE_FLOAT128_ID:
6939 T = Context.Float128Ty;
6941 case PREDEF_TYPE_OVERLOAD_ID:
6942 T = Context.OverloadTy;
6944 case PREDEF_TYPE_BOUND_MEMBER:
6945 T = Context.BoundMemberTy;
6947 case PREDEF_TYPE_PSEUDO_OBJECT:
6948 T = Context.PseudoObjectTy;
6950 case PREDEF_TYPE_DEPENDENT_ID:
6951 T = Context.DependentTy;
6953 case PREDEF_TYPE_UNKNOWN_ANY:
6954 T = Context.UnknownAnyTy;
6956 case PREDEF_TYPE_NULLPTR_ID:
6957 T = Context.NullPtrTy;
6959 case PREDEF_TYPE_CHAR8_ID:
6960 T = Context.Char8Ty;
6962 case PREDEF_TYPE_CHAR16_ID:
6963 T = Context.Char16Ty;
6965 case PREDEF_TYPE_CHAR32_ID:
6966 T = Context.Char32Ty;
6968 case PREDEF_TYPE_OBJC_ID:
6969 T = Context.ObjCBuiltinIdTy;
6971 case PREDEF_TYPE_OBJC_CLASS:
6972 T = Context.ObjCBuiltinClassTy;
6974 case PREDEF_TYPE_OBJC_SEL:
6975 T = Context.ObjCBuiltinSelTy;
6977 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6978 case PREDEF_TYPE_##Id##_ID: \
6979 T = Context.SingletonId; \
6981 #include "clang/Basic/OpenCLImageTypes.def"
6982 case PREDEF_TYPE_SAMPLER_ID:
6983 T = Context.OCLSamplerTy;
6985 case PREDEF_TYPE_EVENT_ID:
6986 T = Context.OCLEventTy;
6988 case PREDEF_TYPE_CLK_EVENT_ID:
6989 T = Context.OCLClkEventTy;
6991 case PREDEF_TYPE_QUEUE_ID:
6992 T = Context.OCLQueueTy;
6994 case PREDEF_TYPE_RESERVE_ID_ID:
6995 T = Context.OCLReserveIDTy;
6997 case PREDEF_TYPE_AUTO_DEDUCT:
6998 T = Context.getAutoDeductType();
7000 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7001 T = Context.getAutoRRefDeductType();
7003 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7004 T = Context.ARCUnbridgedCastTy;
7006 case PREDEF_TYPE_BUILTIN_FN:
7007 T = Context.BuiltinFnTy;
7009 case PREDEF_TYPE_OMP_ARRAY_SECTION:
7010 T = Context.OMPArraySectionTy;
7014 assert(!T.isNull() && "Unknown predefined type");
7015 return T.withFastQualifiers(FastQuals);
7018 Index -= NUM_PREDEF_TYPE_IDS;
7019 assert(Index < TypesLoaded.size() && "Type index out-of-range");
7020 if (TypesLoaded[Index].isNull()) {
7021 TypesLoaded[Index] = readTypeRecord(Index);
7022 if (TypesLoaded[Index].isNull())
7025 TypesLoaded[Index]->setFromAST();
7026 if (DeserializationListener)
7027 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7028 TypesLoaded[Index]);
7031 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7034 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7035 return GetType(getGlobalTypeID(F, LocalID));
7038 serialization::TypeID
7039 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7040 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7041 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7043 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7046 if (!F.ModuleOffsetMap.empty())
7047 ReadModuleOffsetMap(F);
7049 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7050 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7051 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7053 unsigned GlobalIndex = LocalIndex + I->second;
7054 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7057 TemplateArgumentLocInfo
7058 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
7059 TemplateArgument::ArgKind Kind,
7060 const RecordData &Record,
7063 case TemplateArgument::Expression:
7065 case TemplateArgument::Type:
7066 return GetTypeSourceInfo(F, Record, Index);
7067 case TemplateArgument::Template: {
7068 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7070 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7071 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7074 case TemplateArgument::TemplateExpansion: {
7075 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7077 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7078 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
7079 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7082 case TemplateArgument::Null:
7083 case TemplateArgument::Integral:
7084 case TemplateArgument::Declaration:
7085 case TemplateArgument::NullPtr:
7086 case TemplateArgument::Pack:
7087 // FIXME: Is this right?
7088 return TemplateArgumentLocInfo();
7090 llvm_unreachable("unexpected template argument loc");
7094 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
7095 const RecordData &Record, unsigned &Index) {
7096 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7098 if (Arg.getKind() == TemplateArgument::Expression) {
7099 if (Record[Index++]) // bool InfoHasSameExpr.
7100 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7102 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
7106 const ASTTemplateArgumentListInfo*
7107 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
7108 const RecordData &Record,
7110 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
7111 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
7112 unsigned NumArgsAsWritten = Record[Index++];
7113 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7114 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7115 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
7116 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7119 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7123 void ASTReader::CompleteRedeclChain(const Decl *D) {
7124 if (NumCurrentElementsDeserializing) {
7125 // We arrange to not care about the complete redeclaration chain while we're
7126 // deserializing. Just remember that the AST has marked this one as complete
7127 // but that it's not actually complete yet, so we know we still need to
7128 // complete it later.
7129 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7133 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7135 // If this is a named declaration, complete it by looking it up
7136 // within its context.
7138 // FIXME: Merging a function definition should merge
7139 // all mergeable entities within it.
7140 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7141 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7142 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7143 if (!getContext().getLangOpts().CPlusPlus &&
7144 isa<TranslationUnitDecl>(DC)) {
7145 // Outside of C++, we don't have a lookup table for the TU, so update
7146 // the identifier instead. (For C++ modules, we don't store decls
7147 // in the serialized identifier table, so we do the lookup in the TU.)
7148 auto *II = Name.getAsIdentifierInfo();
7149 assert(II && "non-identifier name in C?");
7150 if (II->isOutOfDate())
7151 updateOutOfDateIdentifier(*II);
7154 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7155 // Find all declarations of this kind from the relevant context.
7156 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7157 auto *DC = cast<DeclContext>(DCDecl);
7158 SmallVector<Decl*, 8> Decls;
7159 FindExternalLexicalDecls(
7160 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7165 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7166 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7167 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7168 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7169 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7170 if (auto *Template = FD->getPrimaryTemplate())
7171 Template->LoadLazySpecializations();
7175 CXXCtorInitializer **
7176 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7177 RecordLocation Loc = getLocalBitOffset(Offset);
7178 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7179 SavedStreamPosition SavedPosition(Cursor);
7180 Cursor.JumpToBit(Loc.Offset);
7181 ReadingKindTracker ReadingKind(Read_Decl, *this);
7184 unsigned Code = Cursor.ReadCode();
7185 unsigned RecCode = Cursor.readRecord(Code, Record);
7186 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7187 Error("malformed AST file: missing C++ ctor initializers");
7192 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7195 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7196 assert(ContextObj && "reading base specifiers with no AST context");
7197 ASTContext &Context = *ContextObj;
7199 RecordLocation Loc = getLocalBitOffset(Offset);
7200 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7201 SavedStreamPosition SavedPosition(Cursor);
7202 Cursor.JumpToBit(Loc.Offset);
7203 ReadingKindTracker ReadingKind(Read_Decl, *this);
7205 unsigned Code = Cursor.ReadCode();
7206 unsigned RecCode = Cursor.readRecord(Code, Record);
7207 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7208 Error("malformed AST file: missing C++ base specifiers");
7213 unsigned NumBases = Record[Idx++];
7214 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7215 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7216 for (unsigned I = 0; I != NumBases; ++I)
7217 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7221 serialization::DeclID
7222 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7223 if (LocalID < NUM_PREDEF_DECL_IDS)
7226 if (!F.ModuleOffsetMap.empty())
7227 ReadModuleOffsetMap(F);
7229 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7230 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7231 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7233 return LocalID + I->second;
7236 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7237 ModuleFile &M) const {
7238 // Predefined decls aren't from any module.
7239 if (ID < NUM_PREDEF_DECL_IDS)
7242 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7243 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7246 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7247 if (!D->isFromASTFile())
7249 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7250 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7254 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7255 if (ID < NUM_PREDEF_DECL_IDS)
7256 return SourceLocation();
7258 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7260 if (Index > DeclsLoaded.size()) {
7261 Error("declaration ID out-of-range for AST file");
7262 return SourceLocation();
7265 if (Decl *D = DeclsLoaded[Index])
7266 return D->getLocation();
7269 DeclCursorForID(ID, Loc);
7273 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7275 case PREDEF_DECL_NULL_ID:
7278 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7279 return Context.getTranslationUnitDecl();
7281 case PREDEF_DECL_OBJC_ID_ID:
7282 return Context.getObjCIdDecl();
7284 case PREDEF_DECL_OBJC_SEL_ID:
7285 return Context.getObjCSelDecl();
7287 case PREDEF_DECL_OBJC_CLASS_ID:
7288 return Context.getObjCClassDecl();
7290 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7291 return Context.getObjCProtocolDecl();
7293 case PREDEF_DECL_INT_128_ID:
7294 return Context.getInt128Decl();
7296 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7297 return Context.getUInt128Decl();
7299 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7300 return Context.getObjCInstanceTypeDecl();
7302 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7303 return Context.getBuiltinVaListDecl();
7305 case PREDEF_DECL_VA_LIST_TAG:
7306 return Context.getVaListTagDecl();
7308 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7309 return Context.getBuiltinMSVaListDecl();
7311 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7312 return Context.getExternCContextDecl();
7314 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7315 return Context.getMakeIntegerSeqDecl();
7317 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7318 return Context.getCFConstantStringDecl();
7320 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7321 return Context.getCFConstantStringTagDecl();
7323 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7324 return Context.getTypePackElementDecl();
7326 llvm_unreachable("PredefinedDeclIDs unknown enum value");
7329 Decl *ASTReader::GetExistingDecl(DeclID ID) {
7330 assert(ContextObj && "reading decl with no AST context");
7331 if (ID < NUM_PREDEF_DECL_IDS) {
7332 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7334 // Track that we have merged the declaration with ID \p ID into the
7335 // pre-existing predefined declaration \p D.
7336 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7338 Merged.push_back(ID);
7343 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7345 if (Index >= DeclsLoaded.size()) {
7346 assert(0 && "declaration ID out-of-range for AST file");
7347 Error("declaration ID out-of-range for AST file");
7351 return DeclsLoaded[Index];
7354 Decl *ASTReader::GetDecl(DeclID ID) {
7355 if (ID < NUM_PREDEF_DECL_IDS)
7356 return GetExistingDecl(ID);
7358 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7360 if (Index >= DeclsLoaded.size()) {
7361 assert(0 && "declaration ID out-of-range for AST file");
7362 Error("declaration ID out-of-range for AST file");
7366 if (!DeclsLoaded[Index]) {
7368 if (DeserializationListener)
7369 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7372 return DeclsLoaded[Index];
7375 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7377 if (GlobalID < NUM_PREDEF_DECL_IDS)
7380 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7381 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7382 ModuleFile *Owner = I->second;
7384 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7385 = M.GlobalToLocalDeclIDs.find(Owner);
7386 if (Pos == M.GlobalToLocalDeclIDs.end())
7389 return GlobalID - Owner->BaseDeclID + Pos->second;
7392 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7393 const RecordData &Record,
7395 if (Idx >= Record.size()) {
7396 Error("Corrupted AST file");
7400 return getGlobalDeclID(F, Record[Idx++]);
7403 /// Resolve the offset of a statement into a statement.
7405 /// This operation will read a new statement from the external
7406 /// source each time it is called, and is meant to be used via a
7407 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7408 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7409 // Switch case IDs are per Decl.
7410 ClearSwitchCaseIDs();
7412 // Offset here is a global offset across the entire chain.
7413 RecordLocation Loc = getLocalBitOffset(Offset);
7414 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7415 assert(NumCurrentElementsDeserializing == 0 &&
7416 "should not be called while already deserializing");
7417 Deserializing D(this);
7418 return ReadStmtFromStream(*Loc.F);
7421 void ASTReader::FindExternalLexicalDecls(
7422 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7423 SmallVectorImpl<Decl *> &Decls) {
7424 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7426 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7427 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7428 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7429 auto K = (Decl::Kind)+LexicalDecls[I];
7430 if (!IsKindWeWant(K))
7433 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7435 // Don't add predefined declarations to the lexical context more
7437 if (ID < NUM_PREDEF_DECL_IDS) {
7438 if (PredefsVisited[ID])
7441 PredefsVisited[ID] = true;
7444 if (Decl *D = GetLocalDecl(*M, ID)) {
7445 assert(D->getKind() == K && "wrong kind for lexical decl");
7446 if (!DC->isDeclInLexicalTraversal(D))
7452 if (isa<TranslationUnitDecl>(DC)) {
7453 for (auto Lexical : TULexicalDecls)
7454 Visit(Lexical.first, Lexical.second);
7456 auto I = LexicalDecls.find(DC);
7457 if (I != LexicalDecls.end())
7458 Visit(I->second.first, I->second.second);
7461 ++NumLexicalDeclContextsRead;
7471 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7473 bool operator()(LocalDeclID L, LocalDeclID R) const {
7474 SourceLocation LHS = getLocation(L);
7475 SourceLocation RHS = getLocation(R);
7476 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7479 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7480 SourceLocation RHS = getLocation(R);
7481 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7484 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7485 SourceLocation LHS = getLocation(L);
7486 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7489 SourceLocation getLocation(LocalDeclID ID) const {
7490 return Reader.getSourceManager().getFileLoc(
7491 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7497 void ASTReader::FindFileRegionDecls(FileID File,
7498 unsigned Offset, unsigned Length,
7499 SmallVectorImpl<Decl *> &Decls) {
7500 SourceManager &SM = getSourceManager();
7502 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7503 if (I == FileDeclIDs.end())
7506 FileDeclsInfo &DInfo = I->second;
7507 if (DInfo.Decls.empty())
7511 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7512 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7514 DeclIDComp DIDComp(*this, *DInfo.Mod);
7515 ArrayRef<serialization::LocalDeclID>::iterator
7516 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7518 if (BeginIt != DInfo.Decls.begin())
7521 // If we are pointing at a top-level decl inside an objc container, we need
7522 // to backtrack until we find it otherwise we will fail to report that the
7523 // region overlaps with an objc container.
7524 while (BeginIt != DInfo.Decls.begin() &&
7525 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7526 ->isTopLevelDeclInObjCContainer())
7529 ArrayRef<serialization::LocalDeclID>::iterator
7530 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7532 if (EndIt != DInfo.Decls.end())
7535 for (ArrayRef<serialization::LocalDeclID>::iterator
7536 DIt = BeginIt; DIt != EndIt; ++DIt)
7537 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7541 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7542 DeclarationName Name) {
7543 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7544 "DeclContext has no visible decls in storage");
7548 auto It = Lookups.find(DC);
7549 if (It == Lookups.end())
7552 Deserializing LookupResults(this);
7554 // Load the list of declarations.
7555 SmallVector<NamedDecl *, 64> Decls;
7556 for (DeclID ID : It->second.Table.find(Name)) {
7557 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7558 if (ND->getDeclName() == Name)
7559 Decls.push_back(ND);
7562 ++NumVisibleDeclContextsRead;
7563 SetExternalVisibleDeclsForName(DC, Name, Decls);
7564 return !Decls.empty();
7567 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7568 if (!DC->hasExternalVisibleStorage())
7571 auto It = Lookups.find(DC);
7572 assert(It != Lookups.end() &&
7573 "have external visible storage but no lookup tables");
7577 for (DeclID ID : It->second.Table.findAll()) {
7578 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7579 Decls[ND->getDeclName()].push_back(ND);
7582 ++NumVisibleDeclContextsRead;
7584 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7585 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7587 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7590 const serialization::reader::DeclContextLookupTable *
7591 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7592 auto I = Lookups.find(Primary);
7593 return I == Lookups.end() ? nullptr : &I->second;
7596 /// Under non-PCH compilation the consumer receives the objc methods
7597 /// before receiving the implementation, and codegen depends on this.
7598 /// We simulate this by deserializing and passing to consumer the methods of the
7599 /// implementation before passing the deserialized implementation decl.
7600 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7601 ASTConsumer *Consumer) {
7602 assert(ImplD && Consumer);
7604 for (auto *I : ImplD->methods())
7605 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7607 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7610 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7611 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7612 PassObjCImplDeclToConsumer(ImplD, Consumer);
7614 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7617 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7618 this->Consumer = Consumer;
7621 PassInterestingDeclsToConsumer();
7623 if (DeserializationListener)
7624 DeserializationListener->ReaderInitialized(this);
7627 void ASTReader::PrintStats() {
7628 std::fprintf(stderr, "*** AST File Statistics:\n");
7630 unsigned NumTypesLoaded
7631 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7633 unsigned NumDeclsLoaded
7634 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7636 unsigned NumIdentifiersLoaded
7637 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7638 IdentifiersLoaded.end(),
7639 (IdentifierInfo *)nullptr);
7640 unsigned NumMacrosLoaded
7641 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7643 (MacroInfo *)nullptr);
7644 unsigned NumSelectorsLoaded
7645 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7646 SelectorsLoaded.end(),
7649 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7650 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7651 NumSLocEntriesRead, TotalNumSLocEntries,
7652 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7653 if (!TypesLoaded.empty())
7654 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7655 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7656 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7657 if (!DeclsLoaded.empty())
7658 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7659 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7660 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7661 if (!IdentifiersLoaded.empty())
7662 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7663 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7664 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7665 if (!MacrosLoaded.empty())
7666 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7667 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7668 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7669 if (!SelectorsLoaded.empty())
7670 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7671 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7672 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7673 if (TotalNumStatements)
7674 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7675 NumStatementsRead, TotalNumStatements,
7676 ((float)NumStatementsRead/TotalNumStatements * 100));
7678 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7679 NumMacrosRead, TotalNumMacros,
7680 ((float)NumMacrosRead/TotalNumMacros * 100));
7681 if (TotalLexicalDeclContexts)
7682 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7683 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7684 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7686 if (TotalVisibleDeclContexts)
7687 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7688 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7689 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7691 if (TotalNumMethodPoolEntries)
7692 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7693 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7694 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7696 if (NumMethodPoolLookups)
7697 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7698 NumMethodPoolHits, NumMethodPoolLookups,
7699 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7700 if (NumMethodPoolTableLookups)
7701 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7702 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7703 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7705 if (NumIdentifierLookupHits)
7706 std::fprintf(stderr,
7707 " %u / %u identifier table lookups succeeded (%f%%)\n",
7708 NumIdentifierLookupHits, NumIdentifierLookups,
7709 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7712 std::fprintf(stderr, "\n");
7713 GlobalIndex->printStats();
7716 std::fprintf(stderr, "\n");
7718 std::fprintf(stderr, "\n");
7721 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7722 LLVM_DUMP_METHOD static void
7723 dumpModuleIDMap(StringRef Name,
7724 const ContinuousRangeMap<Key, ModuleFile *,
7725 InitialCapacity> &Map) {
7726 if (Map.begin() == Map.end())
7729 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7731 llvm::errs() << Name << ":\n";
7732 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7734 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7739 LLVM_DUMP_METHOD void ASTReader::dump() {
7740 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7741 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7742 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7743 dumpModuleIDMap("Global type map", GlobalTypeMap);
7744 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7745 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7746 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7747 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7748 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7749 dumpModuleIDMap("Global preprocessed entity map",
7750 GlobalPreprocessedEntityMap);
7752 llvm::errs() << "\n*** PCH/Modules Loaded:";
7753 for (ModuleFile &M : ModuleMgr)
7757 /// Return the amount of memory used by memory buffers, breaking down
7758 /// by heap-backed versus mmap'ed memory.
7759 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7760 for (ModuleFile &I : ModuleMgr) {
7761 if (llvm::MemoryBuffer *buf = I.Buffer) {
7762 size_t bytes = buf->getBufferSize();
7763 switch (buf->getBufferKind()) {
7764 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7765 sizes.malloc_bytes += bytes;
7767 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7768 sizes.mmap_bytes += bytes;
7775 void ASTReader::InitializeSema(Sema &S) {
7777 S.addExternalSource(this);
7779 // Makes sure any declarations that were deserialized "too early"
7780 // still get added to the identifier's declaration chains.
7781 for (uint64_t ID : PreloadedDeclIDs) {
7782 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7783 pushExternalDeclIntoScope(D, D->getDeclName());
7785 PreloadedDeclIDs.clear();
7787 // FIXME: What happens if these are changed by a module import?
7788 if (!FPPragmaOptions.empty()) {
7789 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7790 SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7793 SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7794 SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7795 SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7800 void ASTReader::UpdateSema() {
7801 assert(SemaObj && "no Sema to update");
7803 // Load the offsets of the declarations that Sema references.
7804 // They will be lazily deserialized when needed.
7805 if (!SemaDeclRefs.empty()) {
7806 assert(SemaDeclRefs.size() % 3 == 0);
7807 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7808 if (!SemaObj->StdNamespace)
7809 SemaObj->StdNamespace = SemaDeclRefs[I];
7810 if (!SemaObj->StdBadAlloc)
7811 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7812 if (!SemaObj->StdAlignValT)
7813 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7815 SemaDeclRefs.clear();
7818 // Update the state of pragmas. Use the same API as if we had encountered the
7819 // pragma in the source.
7820 if(OptimizeOffPragmaLocation.isValid())
7821 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7822 if (PragmaMSStructState != -1)
7823 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7824 if (PointersToMembersPragmaLocation.isValid()) {
7825 SemaObj->ActOnPragmaMSPointersToMembers(
7826 (LangOptions::PragmaMSPointersToMembersKind)
7827 PragmaMSPointersToMembersState,
7828 PointersToMembersPragmaLocation);
7830 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7832 if (PragmaPackCurrentValue) {
7833 // The bottom of the stack might have a default value. It must be adjusted
7834 // to the current value to ensure that the packing state is preserved after
7835 // popping entries that were included/imported from a PCH/module.
7836 bool DropFirst = false;
7837 if (!PragmaPackStack.empty() &&
7838 PragmaPackStack.front().Location.isInvalid()) {
7839 assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7840 "Expected a default alignment value");
7841 SemaObj->PackStack.Stack.emplace_back(
7842 PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7843 SemaObj->PackStack.CurrentPragmaLocation,
7844 PragmaPackStack.front().PushLocation);
7847 for (const auto &Entry :
7848 llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7849 SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7850 Entry.Location, Entry.PushLocation);
7851 if (PragmaPackCurrentLocation.isInvalid()) {
7852 assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7853 "Expected a default alignment value");
7854 // Keep the current values.
7856 SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7857 SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7862 IdentifierInfo *ASTReader::get(StringRef Name) {
7863 // Note that we are loading an identifier.
7864 Deserializing AnIdentifier(this);
7866 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7867 NumIdentifierLookups,
7868 NumIdentifierLookupHits);
7870 // We don't need to do identifier table lookups in C++ modules (we preload
7871 // all interesting declarations, and don't need to use the scope for name
7872 // lookups). Perform the lookup in PCH files, though, since we don't build
7873 // a complete initial identifier table if we're carrying on from a PCH.
7874 if (PP.getLangOpts().CPlusPlus) {
7875 for (auto F : ModuleMgr.pch_modules())
7879 // If there is a global index, look there first to determine which modules
7880 // provably do not have any results for this identifier.
7881 GlobalModuleIndex::HitSet Hits;
7882 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7883 if (!loadGlobalIndex()) {
7884 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7889 ModuleMgr.visit(Visitor, HitsPtr);
7892 IdentifierInfo *II = Visitor.getIdentifierInfo();
7893 markIdentifierUpToDate(II);
7899 /// An identifier-lookup iterator that enumerates all of the
7900 /// identifiers stored within a set of AST files.
7901 class ASTIdentifierIterator : public IdentifierIterator {
7902 /// The AST reader whose identifiers are being enumerated.
7903 const ASTReader &Reader;
7905 /// The current index into the chain of AST files stored in
7909 /// The current position within the identifier lookup table
7910 /// of the current AST file.
7911 ASTIdentifierLookupTable::key_iterator Current;
7913 /// The end position within the identifier lookup table of
7914 /// the current AST file.
7915 ASTIdentifierLookupTable::key_iterator End;
7917 /// Whether to skip any modules in the ASTReader.
7921 explicit ASTIdentifierIterator(const ASTReader &Reader,
7922 bool SkipModules = false);
7924 StringRef Next() override;
7927 } // namespace clang
7929 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
7931 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7934 StringRef ASTIdentifierIterator::Next() {
7935 while (Current == End) {
7936 // If we have exhausted all of our AST files, we're done.
7941 ModuleFile &F = Reader.ModuleMgr[Index];
7942 if (SkipModules && F.isModule())
7945 ASTIdentifierLookupTable *IdTable =
7946 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7947 Current = IdTable->key_begin();
7948 End = IdTable->key_end();
7951 // We have any identifiers remaining in the current AST file; return
7953 StringRef Result = *Current;
7960 /// A utility for appending two IdentifierIterators.
7961 class ChainedIdentifierIterator : public IdentifierIterator {
7962 std::unique_ptr<IdentifierIterator> Current;
7963 std::unique_ptr<IdentifierIterator> Queued;
7966 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7967 std::unique_ptr<IdentifierIterator> Second)
7968 : Current(std::move(First)), Queued(std::move(Second)) {}
7970 StringRef Next() override {
7974 StringRef result = Current->Next();
7975 if (!result.empty())
7978 // Try the queued iterator, which may itself be empty.
7980 std::swap(Current, Queued);
7987 IdentifierIterator *ASTReader::getIdentifiers() {
7988 if (!loadGlobalIndex()) {
7989 std::unique_ptr<IdentifierIterator> ReaderIter(
7990 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7991 std::unique_ptr<IdentifierIterator> ModulesIter(
7992 GlobalIndex->createIdentifierIterator());
7993 return new ChainedIdentifierIterator(std::move(ReaderIter),
7994 std::move(ModulesIter));
7997 return new ASTIdentifierIterator(*this);
8001 namespace serialization {
8003 class ReadMethodPoolVisitor {
8006 unsigned PriorGeneration;
8007 unsigned InstanceBits = 0;
8008 unsigned FactoryBits = 0;
8009 bool InstanceHasMoreThanOneDecl = false;
8010 bool FactoryHasMoreThanOneDecl = false;
8011 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8012 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8015 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8016 unsigned PriorGeneration)
8017 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8019 bool operator()(ModuleFile &M) {
8020 if (!M.SelectorLookupTable)
8023 // If we've already searched this module file, skip it now.
8024 if (M.Generation <= PriorGeneration)
8027 ++Reader.NumMethodPoolTableLookups;
8028 ASTSelectorLookupTable *PoolTable
8029 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8030 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8031 if (Pos == PoolTable->end())
8034 ++Reader.NumMethodPoolTableHits;
8035 ++Reader.NumSelectorsRead;
8036 // FIXME: Not quite happy with the statistics here. We probably should
8037 // disable this tracking when called via LoadSelector.
8038 // Also, should entries without methods count as misses?
8039 ++Reader.NumMethodPoolEntriesRead;
8040 ASTSelectorLookupTrait::data_type Data = *Pos;
8041 if (Reader.DeserializationListener)
8042 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8044 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8045 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8046 InstanceBits = Data.InstanceBits;
8047 FactoryBits = Data.FactoryBits;
8048 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8049 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8053 /// Retrieve the instance methods found by this visitor.
8054 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8055 return InstanceMethods;
8058 /// Retrieve the instance methods found by this visitor.
8059 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8060 return FactoryMethods;
8063 unsigned getInstanceBits() const { return InstanceBits; }
8064 unsigned getFactoryBits() const { return FactoryBits; }
8066 bool instanceHasMoreThanOneDecl() const {
8067 return InstanceHasMoreThanOneDecl;
8070 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8073 } // namespace serialization
8074 } // namespace clang
8076 /// Add the given set of methods to the method list.
8077 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8078 ObjCMethodList &List) {
8079 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8080 S.addMethodToGlobalList(&List, Methods[I]);
8084 void ASTReader::ReadMethodPool(Selector Sel) {
8085 // Get the selector generation and update it to the current generation.
8086 unsigned &Generation = SelectorGeneration[Sel];
8087 unsigned PriorGeneration = Generation;
8088 Generation = getGeneration();
8089 SelectorOutOfDate[Sel] = false;
8091 // Search for methods defined with this selector.
8092 ++NumMethodPoolLookups;
8093 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8094 ModuleMgr.visit(Visitor);
8096 if (Visitor.getInstanceMethods().empty() &&
8097 Visitor.getFactoryMethods().empty())
8100 ++NumMethodPoolHits;
8105 Sema &S = *getSema();
8106 Sema::GlobalMethodPool::iterator Pos
8107 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8109 Pos->second.first.setBits(Visitor.getInstanceBits());
8110 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8111 Pos->second.second.setBits(Visitor.getFactoryBits());
8112 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8114 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8115 // when building a module we keep every method individually and may need to
8116 // update hasMoreThanOneDecl as we add the methods.
8117 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8118 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8121 void ASTReader::updateOutOfDateSelector(Selector Sel) {
8122 if (SelectorOutOfDate[Sel])
8123 ReadMethodPool(Sel);
8126 void ASTReader::ReadKnownNamespaces(
8127 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8130 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8131 if (NamespaceDecl *Namespace
8132 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8133 Namespaces.push_back(Namespace);
8137 void ASTReader::ReadUndefinedButUsed(
8138 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8139 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8140 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8141 SourceLocation Loc =
8142 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8143 Undefined.insert(std::make_pair(D, Loc));
8147 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8148 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8150 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8151 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8152 uint64_t Count = DelayedDeleteExprs[Idx++];
8153 for (uint64_t C = 0; C < Count; ++C) {
8154 SourceLocation DeleteLoc =
8155 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8156 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8157 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8162 void ASTReader::ReadTentativeDefinitions(
8163 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8164 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8165 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8167 TentativeDefs.push_back(Var);
8169 TentativeDefinitions.clear();
8172 void ASTReader::ReadUnusedFileScopedDecls(
8173 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8174 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8176 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8180 UnusedFileScopedDecls.clear();
8183 void ASTReader::ReadDelegatingConstructors(
8184 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8185 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8186 CXXConstructorDecl *D
8187 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8191 DelegatingCtorDecls.clear();
8194 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8195 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8197 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8201 ExtVectorDecls.clear();
8204 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8205 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8206 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8208 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8209 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8213 UnusedLocalTypedefNameCandidates.clear();
8216 void ASTReader::ReadReferencedSelectors(
8217 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8218 if (ReferencedSelectorsData.empty())
8221 // If there are @selector references added them to its pool. This is for
8222 // implementation of -Wselector.
8223 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8225 while (I < DataSize) {
8226 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8227 SourceLocation SelLoc
8228 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8229 Sels.push_back(std::make_pair(Sel, SelLoc));
8231 ReferencedSelectorsData.clear();
8234 void ASTReader::ReadWeakUndeclaredIdentifiers(
8235 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8236 if (WeakUndeclaredIdentifiers.empty())
8239 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8240 IdentifierInfo *WeakId
8241 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8242 IdentifierInfo *AliasId
8243 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8245 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8246 bool Used = WeakUndeclaredIdentifiers[I++];
8247 WeakInfo WI(AliasId, Loc);
8249 WeakIDs.push_back(std::make_pair(WeakId, WI));
8251 WeakUndeclaredIdentifiers.clear();
8254 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8255 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8256 ExternalVTableUse VT;
8257 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8258 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8259 VT.DefinitionRequired = VTableUses[Idx++];
8260 VTables.push_back(VT);
8266 void ASTReader::ReadPendingInstantiations(
8267 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8268 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8269 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8271 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8273 Pending.push_back(std::make_pair(D, Loc));
8275 PendingInstantiations.clear();
8278 void ASTReader::ReadLateParsedTemplates(
8279 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8281 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8283 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8285 auto LT = llvm::make_unique<LateParsedTemplate>();
8286 LT->D = GetDecl(LateParsedTemplates[Idx++]);
8288 ModuleFile *F = getOwningModuleFile(LT->D);
8289 assert(F && "No module");
8291 unsigned TokN = LateParsedTemplates[Idx++];
8292 LT->Toks.reserve(TokN);
8293 for (unsigned T = 0; T < TokN; ++T)
8294 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8296 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8299 LateParsedTemplates.clear();
8302 void ASTReader::LoadSelector(Selector Sel) {
8303 // It would be complicated to avoid reading the methods anyway. So don't.
8304 ReadMethodPool(Sel);
8307 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8308 assert(ID && "Non-zero identifier ID required");
8309 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8310 IdentifiersLoaded[ID - 1] = II;
8311 if (DeserializationListener)
8312 DeserializationListener->IdentifierRead(ID, II);
8315 /// Set the globally-visible declarations associated with the given
8318 /// If the AST reader is currently in a state where the given declaration IDs
8319 /// cannot safely be resolved, they are queued until it is safe to resolve
8322 /// \param II an IdentifierInfo that refers to one or more globally-visible
8325 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8326 /// visible at global scope.
8328 /// \param Decls if non-null, this vector will be populated with the set of
8329 /// deserialized declarations. These declarations will not be pushed into
8332 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8333 const SmallVectorImpl<uint32_t> &DeclIDs,
8334 SmallVectorImpl<Decl *> *Decls) {
8335 if (NumCurrentElementsDeserializing && !Decls) {
8336 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8340 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8342 // Queue this declaration so that it will be added to the
8343 // translation unit scope and identifier's declaration chain
8344 // once a Sema object is known.
8345 PreloadedDeclIDs.push_back(DeclIDs[I]);
8349 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8351 // If we're simply supposed to record the declarations, do so now.
8353 Decls->push_back(D);
8357 // Introduce this declaration into the translation-unit scope
8358 // and add it to the declaration chain for this identifier, so
8359 // that (unqualified) name lookup will find it.
8360 pushExternalDeclIntoScope(D, II);
8364 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8368 if (IdentifiersLoaded.empty()) {
8369 Error("no identifier table in AST file");
8374 if (!IdentifiersLoaded[ID]) {
8375 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8376 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8377 ModuleFile *M = I->second;
8378 unsigned Index = ID - M->BaseIdentifierID;
8379 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8381 // All of the strings in the AST file are preceded by a 16-bit length.
8382 // Extract that 16-bit length to avoid having to execute strlen().
8383 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8384 // unsigned integers. This is important to avoid integer overflow when
8385 // we cast them to 'unsigned'.
8386 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8387 unsigned StrLen = (((unsigned) StrLenPtr[0])
8388 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8389 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8390 IdentifiersLoaded[ID] = &II;
8391 markIdentifierFromAST(*this, II);
8392 if (DeserializationListener)
8393 DeserializationListener->IdentifierRead(ID + 1, &II);
8396 return IdentifiersLoaded[ID];
8399 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8400 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8403 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8404 if (LocalID < NUM_PREDEF_IDENT_IDS)
8407 if (!M.ModuleOffsetMap.empty())
8408 ReadModuleOffsetMap(M);
8410 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8411 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8412 assert(I != M.IdentifierRemap.end()
8413 && "Invalid index into identifier index remap");
8415 return LocalID + I->second;
8418 MacroInfo *ASTReader::getMacro(MacroID ID) {
8422 if (MacrosLoaded.empty()) {
8423 Error("no macro table in AST file");
8427 ID -= NUM_PREDEF_MACRO_IDS;
8428 if (!MacrosLoaded[ID]) {
8429 GlobalMacroMapType::iterator I
8430 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8431 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8432 ModuleFile *M = I->second;
8433 unsigned Index = ID - M->BaseMacroID;
8434 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8436 if (DeserializationListener)
8437 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8441 return MacrosLoaded[ID];
8444 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8445 if (LocalID < NUM_PREDEF_MACRO_IDS)
8448 if (!M.ModuleOffsetMap.empty())
8449 ReadModuleOffsetMap(M);
8451 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8452 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8453 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8455 return LocalID + I->second;
8458 serialization::SubmoduleID
8459 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8460 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8463 if (!M.ModuleOffsetMap.empty())
8464 ReadModuleOffsetMap(M);
8466 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8467 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8468 assert(I != M.SubmoduleRemap.end()
8469 && "Invalid index into submodule index remap");
8471 return LocalID + I->second;
8474 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8475 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8476 assert(GlobalID == 0 && "Unhandled global submodule ID");
8480 if (GlobalID > SubmodulesLoaded.size()) {
8481 Error("submodule ID out of range in AST file");
8485 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8488 Module *ASTReader::getModule(unsigned ID) {
8489 return getSubmodule(ID);
8492 bool ASTReader::DeclIsFromPCHWithObjectFile(const Decl *D) {
8493 ModuleFile *MF = getOwningModuleFile(D);
8494 return MF && MF->PCHHasObjectFile;
8497 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8499 // It's a module, look it up by submodule ID.
8500 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8501 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8503 // It's a prefix (preamble, PCH, ...). Look it up by index.
8504 unsigned IndexFromEnd = ID >> 1;
8505 assert(IndexFromEnd && "got reference to unknown module file");
8506 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8510 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8514 // For a file representing a module, use the submodule ID of the top-level
8515 // module as the file ID. For any other kind of file, the number of such
8516 // files loaded beforehand will be the same on reload.
8517 // FIXME: Is this true even if we have an explicit module file and a PCH?
8519 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8521 auto PCHModules = getModuleManager().pch_modules();
8522 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
8523 assert(I != PCHModules.end() && "emitting reference to unknown file");
8524 return (I - PCHModules.end()) << 1;
8527 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
8528 ASTReader::getSourceDescriptor(unsigned ID) {
8529 if (const Module *M = getSubmodule(ID))
8530 return ExternalASTSource::ASTSourceDescriptor(*M);
8532 // If there is only a single PCH, return it instead.
8533 // Chained PCH are not supported.
8534 const auto &PCHChain = ModuleMgr.pch_modules();
8535 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8536 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8537 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8538 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8539 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8545 ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8546 auto I = DefinitionSource.find(FD);
8547 if (I == DefinitionSource.end())
8548 return EK_ReplyHazy;
8549 return I->second ? EK_Never : EK_Always;
8552 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8553 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8556 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8560 if (ID > SelectorsLoaded.size()) {
8561 Error("selector ID out of range in AST file");
8565 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8566 // Load this selector from the selector table.
8567 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8568 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8569 ModuleFile &M = *I->second;
8570 ASTSelectorLookupTrait Trait(*this, M);
8571 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8572 SelectorsLoaded[ID - 1] =
8573 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8574 if (DeserializationListener)
8575 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8578 return SelectorsLoaded[ID - 1];
8581 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8582 return DecodeSelector(ID);
8585 uint32_t ASTReader::GetNumExternalSelectors() {
8586 // ID 0 (the null selector) is considered an external selector.
8587 return getTotalNumSelectors() + 1;
8590 serialization::SelectorID
8591 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8592 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8595 if (!M.ModuleOffsetMap.empty())
8596 ReadModuleOffsetMap(M);
8598 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8599 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8600 assert(I != M.SelectorRemap.end()
8601 && "Invalid index into selector index remap");
8603 return LocalID + I->second;
8607 ASTReader::ReadDeclarationName(ModuleFile &F,
8608 const RecordData &Record, unsigned &Idx) {
8609 ASTContext &Context = getContext();
8610 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
8612 case DeclarationName::Identifier:
8613 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8615 case DeclarationName::ObjCZeroArgSelector:
8616 case DeclarationName::ObjCOneArgSelector:
8617 case DeclarationName::ObjCMultiArgSelector:
8618 return DeclarationName(ReadSelector(F, Record, Idx));
8620 case DeclarationName::CXXConstructorName:
8621 return Context.DeclarationNames.getCXXConstructorName(
8622 Context.getCanonicalType(readType(F, Record, Idx)));
8624 case DeclarationName::CXXDestructorName:
8625 return Context.DeclarationNames.getCXXDestructorName(
8626 Context.getCanonicalType(readType(F, Record, Idx)));
8628 case DeclarationName::CXXDeductionGuideName:
8629 return Context.DeclarationNames.getCXXDeductionGuideName(
8630 ReadDeclAs<TemplateDecl>(F, Record, Idx));
8632 case DeclarationName::CXXConversionFunctionName:
8633 return Context.DeclarationNames.getCXXConversionFunctionName(
8634 Context.getCanonicalType(readType(F, Record, Idx)));
8636 case DeclarationName::CXXOperatorName:
8637 return Context.DeclarationNames.getCXXOperatorName(
8638 (OverloadedOperatorKind)Record[Idx++]);
8640 case DeclarationName::CXXLiteralOperatorName:
8641 return Context.DeclarationNames.getCXXLiteralOperatorName(
8642 GetIdentifierInfo(F, Record, Idx));
8644 case DeclarationName::CXXUsingDirective:
8645 return DeclarationName::getUsingDirectiveName();
8648 llvm_unreachable("Invalid NameKind!");
8651 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
8652 DeclarationNameLoc &DNLoc,
8653 DeclarationName Name,
8654 const RecordData &Record, unsigned &Idx) {
8655 switch (Name.getNameKind()) {
8656 case DeclarationName::CXXConstructorName:
8657 case DeclarationName::CXXDestructorName:
8658 case DeclarationName::CXXConversionFunctionName:
8659 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8662 case DeclarationName::CXXOperatorName:
8663 DNLoc.CXXOperatorName.BeginOpNameLoc
8664 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8665 DNLoc.CXXOperatorName.EndOpNameLoc
8666 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8669 case DeclarationName::CXXLiteralOperatorName:
8670 DNLoc.CXXLiteralOperatorName.OpNameLoc
8671 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8674 case DeclarationName::Identifier:
8675 case DeclarationName::ObjCZeroArgSelector:
8676 case DeclarationName::ObjCOneArgSelector:
8677 case DeclarationName::ObjCMultiArgSelector:
8678 case DeclarationName::CXXUsingDirective:
8679 case DeclarationName::CXXDeductionGuideName:
8684 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
8685 DeclarationNameInfo &NameInfo,
8686 const RecordData &Record, unsigned &Idx) {
8687 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8688 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8689 DeclarationNameLoc DNLoc;
8690 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8691 NameInfo.setInfo(DNLoc);
8694 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
8695 const RecordData &Record, unsigned &Idx) {
8696 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8697 unsigned NumTPLists = Record[Idx++];
8698 Info.NumTemplParamLists = NumTPLists;
8700 Info.TemplParamLists =
8701 new (getContext()) TemplateParameterList *[NumTPLists];
8702 for (unsigned i = 0; i != NumTPLists; ++i)
8703 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8708 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8710 ASTContext &Context = getContext();
8711 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
8713 case TemplateName::Template:
8714 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8716 case TemplateName::OverloadedTemplate: {
8717 unsigned size = Record[Idx++];
8718 UnresolvedSet<8> Decls;
8720 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8722 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8725 case TemplateName::QualifiedTemplate: {
8726 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8727 bool hasTemplKeyword = Record[Idx++];
8728 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8729 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8732 case TemplateName::DependentTemplate: {
8733 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8734 if (Record[Idx++]) // isIdentifier
8735 return Context.getDependentTemplateName(NNS,
8736 GetIdentifierInfo(F, Record,
8738 return Context.getDependentTemplateName(NNS,
8739 (OverloadedOperatorKind)Record[Idx++]);
8742 case TemplateName::SubstTemplateTemplateParm: {
8743 TemplateTemplateParmDecl *param
8744 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8745 if (!param) return TemplateName();
8746 TemplateName replacement = ReadTemplateName(F, Record, Idx);
8747 return Context.getSubstTemplateTemplateParm(param, replacement);
8750 case TemplateName::SubstTemplateTemplateParmPack: {
8751 TemplateTemplateParmDecl *Param
8752 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8754 return TemplateName();
8756 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8757 if (ArgPack.getKind() != TemplateArgument::Pack)
8758 return TemplateName();
8760 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8764 llvm_unreachable("Unhandled template name kind!");
8767 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
8768 const RecordData &Record,
8770 bool Canonicalize) {
8771 ASTContext &Context = getContext();
8773 // The caller wants a canonical template argument. Sometimes the AST only
8774 // wants template arguments in canonical form (particularly as the template
8775 // argument lists of template specializations) so ensure we preserve that
8776 // canonical form across serialization.
8777 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8778 return Context.getCanonicalTemplateArgument(Arg);
8781 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
8783 case TemplateArgument::Null:
8784 return TemplateArgument();
8785 case TemplateArgument::Type:
8786 return TemplateArgument(readType(F, Record, Idx));
8787 case TemplateArgument::Declaration: {
8788 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8789 return TemplateArgument(D, readType(F, Record, Idx));
8791 case TemplateArgument::NullPtr:
8792 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8793 case TemplateArgument::Integral: {
8794 llvm::APSInt Value = ReadAPSInt(Record, Idx);
8795 QualType T = readType(F, Record, Idx);
8796 return TemplateArgument(Context, Value, T);
8798 case TemplateArgument::Template:
8799 return TemplateArgument(ReadTemplateName(F, Record, Idx));
8800 case TemplateArgument::TemplateExpansion: {
8801 TemplateName Name = ReadTemplateName(F, Record, Idx);
8802 Optional<unsigned> NumTemplateExpansions;
8803 if (unsigned NumExpansions = Record[Idx++])
8804 NumTemplateExpansions = NumExpansions - 1;
8805 return TemplateArgument(Name, NumTemplateExpansions);
8807 case TemplateArgument::Expression:
8808 return TemplateArgument(ReadExpr(F));
8809 case TemplateArgument::Pack: {
8810 unsigned NumArgs = Record[Idx++];
8811 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8812 for (unsigned I = 0; I != NumArgs; ++I)
8813 Args[I] = ReadTemplateArgument(F, Record, Idx);
8814 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8818 llvm_unreachable("Unhandled template argument kind!");
8821 TemplateParameterList *
8822 ASTReader::ReadTemplateParameterList(ModuleFile &F,
8823 const RecordData &Record, unsigned &Idx) {
8824 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8825 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8826 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8828 unsigned NumParams = Record[Idx++];
8829 SmallVector<NamedDecl *, 16> Params;
8830 Params.reserve(NumParams);
8832 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8835 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8836 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8837 return TemplateParams;
8842 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
8843 ModuleFile &F, const RecordData &Record,
8844 unsigned &Idx, bool Canonicalize) {
8845 unsigned NumTemplateArgs = Record[Idx++];
8846 TemplArgs.reserve(NumTemplateArgs);
8847 while (NumTemplateArgs--)
8848 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8851 /// Read a UnresolvedSet structure.
8852 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
8853 const RecordData &Record, unsigned &Idx) {
8854 unsigned NumDecls = Record[Idx++];
8855 Set.reserve(getContext(), NumDecls);
8856 while (NumDecls--) {
8857 DeclID ID = ReadDeclID(F, Record, Idx);
8858 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8859 Set.addLazyDecl(getContext(), ID, AS);
8864 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
8865 const RecordData &Record, unsigned &Idx) {
8866 bool isVirtual = static_cast<bool>(Record[Idx++]);
8867 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8868 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8869 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8870 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8871 SourceRange Range = ReadSourceRange(F, Record, Idx);
8872 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8873 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8875 Result.setInheritConstructors(inheritConstructors);
8879 CXXCtorInitializer **
8880 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8882 ASTContext &Context = getContext();
8883 unsigned NumInitializers = Record[Idx++];
8884 assert(NumInitializers && "wrote ctor initializers but have no inits");
8885 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8886 for (unsigned i = 0; i != NumInitializers; ++i) {
8887 TypeSourceInfo *TInfo = nullptr;
8888 bool IsBaseVirtual = false;
8889 FieldDecl *Member = nullptr;
8890 IndirectFieldDecl *IndirectMember = nullptr;
8892 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8894 case CTOR_INITIALIZER_BASE:
8895 TInfo = GetTypeSourceInfo(F, Record, Idx);
8896 IsBaseVirtual = Record[Idx++];
8899 case CTOR_INITIALIZER_DELEGATING:
8900 TInfo = GetTypeSourceInfo(F, Record, Idx);
8903 case CTOR_INITIALIZER_MEMBER:
8904 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8907 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8908 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8912 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8913 Expr *Init = ReadExpr(F);
8914 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8915 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8917 CXXCtorInitializer *BOMInit;
8918 if (Type == CTOR_INITIALIZER_BASE)
8919 BOMInit = new (Context)
8920 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8921 RParenLoc, MemberOrEllipsisLoc);
8922 else if (Type == CTOR_INITIALIZER_DELEGATING)
8923 BOMInit = new (Context)
8924 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8926 BOMInit = new (Context)
8927 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8930 BOMInit = new (Context)
8931 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8932 LParenLoc, Init, RParenLoc);
8934 if (/*IsWritten*/Record[Idx++]) {
8935 unsigned SourceOrder = Record[Idx++];
8936 BOMInit->setSourceOrder(SourceOrder);
8939 CtorInitializers[i] = BOMInit;
8942 return CtorInitializers;
8945 NestedNameSpecifier *
8946 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8947 const RecordData &Record, unsigned &Idx) {
8948 ASTContext &Context = getContext();
8949 unsigned N = Record[Idx++];
8950 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8951 for (unsigned I = 0; I != N; ++I) {
8952 NestedNameSpecifier::SpecifierKind Kind
8953 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8955 case NestedNameSpecifier::Identifier: {
8956 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8957 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8961 case NestedNameSpecifier::Namespace: {
8962 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8963 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8967 case NestedNameSpecifier::NamespaceAlias: {
8968 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8969 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8973 case NestedNameSpecifier::TypeSpec:
8974 case NestedNameSpecifier::TypeSpecWithTemplate: {
8975 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8979 bool Template = Record[Idx++];
8980 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8984 case NestedNameSpecifier::Global:
8985 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8986 // No associated value, and there can't be a prefix.
8989 case NestedNameSpecifier::Super: {
8990 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8991 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
9000 NestedNameSpecifierLoc
9001 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
9003 ASTContext &Context = getContext();
9004 unsigned N = Record[Idx++];
9005 NestedNameSpecifierLocBuilder Builder;
9006 for (unsigned I = 0; I != N; ++I) {
9007 NestedNameSpecifier::SpecifierKind Kind
9008 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9010 case NestedNameSpecifier::Identifier: {
9011 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9012 SourceRange Range = ReadSourceRange(F, Record, Idx);
9013 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9017 case NestedNameSpecifier::Namespace: {
9018 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9019 SourceRange Range = ReadSourceRange(F, Record, Idx);
9020 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9024 case NestedNameSpecifier::NamespaceAlias: {
9025 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9026 SourceRange Range = ReadSourceRange(F, Record, Idx);
9027 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9031 case NestedNameSpecifier::TypeSpec:
9032 case NestedNameSpecifier::TypeSpecWithTemplate: {
9033 bool Template = Record[Idx++];
9034 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
9036 return NestedNameSpecifierLoc();
9037 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9039 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9040 Builder.Extend(Context,
9041 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9042 T->getTypeLoc(), ColonColonLoc);
9046 case NestedNameSpecifier::Global: {
9047 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9048 Builder.MakeGlobal(Context, ColonColonLoc);
9052 case NestedNameSpecifier::Super: {
9053 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9054 SourceRange Range = ReadSourceRange(F, Record, Idx);
9055 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9061 return Builder.getWithLocInContext(Context);
9065 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9067 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
9068 SourceLocation end = ReadSourceLocation(F, Record, Idx);
9069 return SourceRange(beg, end);
9072 /// Read an integral value
9073 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
9074 unsigned BitWidth = Record[Idx++];
9075 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
9076 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9081 /// Read a signed integral value
9082 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
9083 bool isUnsigned = Record[Idx++];
9084 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
9087 /// Read a floating-point value
9088 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
9089 const llvm::fltSemantics &Sem,
9091 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
9095 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9096 unsigned Len = Record[Idx++];
9097 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9102 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9104 std::string Filename = ReadString(Record, Idx);
9105 ResolveImportedPath(F, Filename);
9109 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9111 unsigned Major = Record[Idx++];
9112 unsigned Minor = Record[Idx++];
9113 unsigned Subminor = Record[Idx++];
9115 return VersionTuple(Major);
9117 return VersionTuple(Major, Minor - 1);
9118 return VersionTuple(Major, Minor - 1, Subminor - 1);
9121 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9122 const RecordData &Record,
9124 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9125 return CXXTemporary::Create(getContext(), Decl);
9128 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9129 return Diag(CurrentImportLoc, DiagID);
9132 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9133 return Diags.Report(Loc, DiagID);
9136 /// Retrieve the identifier table associated with the
9138 IdentifierTable &ASTReader::getIdentifierTable() {
9139 return PP.getIdentifierTable();
9142 /// Record that the given ID maps to the given switch-case
9144 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9145 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9146 "Already have a SwitchCase with this ID");
9147 (*CurrSwitchCaseStmts)[ID] = SC;
9150 /// Retrieve the switch-case statement with the given ID.
9151 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9152 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9153 return (*CurrSwitchCaseStmts)[ID];
9156 void ASTReader::ClearSwitchCaseIDs() {
9157 CurrSwitchCaseStmts->clear();
9160 void ASTReader::ReadComments() {
9161 ASTContext &Context = getContext();
9162 std::vector<RawComment *> Comments;
9163 for (SmallVectorImpl<std::pair<BitstreamCursor,
9164 serialization::ModuleFile *>>::iterator
9165 I = CommentsCursors.begin(),
9166 E = CommentsCursors.end();
9169 BitstreamCursor &Cursor = I->first;
9170 serialization::ModuleFile &F = *I->second;
9171 SavedStreamPosition SavedPosition(Cursor);
9175 llvm::BitstreamEntry Entry =
9176 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9178 switch (Entry.Kind) {
9179 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9180 case llvm::BitstreamEntry::Error:
9181 Error("malformed block record in AST file");
9183 case llvm::BitstreamEntry::EndBlock:
9185 case llvm::BitstreamEntry::Record:
9186 // The interesting case.
9192 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9193 case COMMENTS_RAW_COMMENT: {
9195 SourceRange SR = ReadSourceRange(F, Record, Idx);
9196 RawComment::CommentKind Kind =
9197 (RawComment::CommentKind) Record[Idx++];
9198 bool IsTrailingComment = Record[Idx++];
9199 bool IsAlmostTrailingComment = Record[Idx++];
9200 Comments.push_back(new (Context) RawComment(
9201 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9207 // De-serialized SourceLocations get negative FileIDs for other modules,
9208 // potentially invalidating the original order. Sort it again.
9209 llvm::sort(Comments.begin(), Comments.end(),
9210 BeforeThanCompare<RawComment>(SourceMgr));
9211 Context.Comments.addDeserializedComments(Comments);
9215 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9216 bool IncludeSystem, bool Complain,
9217 llvm::function_ref<void(const serialization::InputFile &IF,
9218 bool isSystem)> Visitor) {
9219 unsigned NumUserInputs = MF.NumUserInputFiles;
9220 unsigned NumInputs = MF.InputFilesLoaded.size();
9221 assert(NumUserInputs <= NumInputs);
9222 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9223 for (unsigned I = 0; I < N; ++I) {
9224 bool IsSystem = I >= NumUserInputs;
9225 InputFile IF = getInputFile(MF, I+1, Complain);
9226 Visitor(IF, IsSystem);
9230 void ASTReader::visitTopLevelModuleMaps(
9231 serialization::ModuleFile &MF,
9232 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9233 unsigned NumInputs = MF.InputFilesLoaded.size();
9234 for (unsigned I = 0; I < NumInputs; ++I) {
9235 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9236 if (IFI.TopLevelModuleMap)
9237 // FIXME: This unnecessarily re-reads the InputFileInfo.
9238 if (auto *FE = getInputFile(MF, I + 1).getFile())
9243 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9244 // If we know the owning module, use it.
9245 if (Module *M = D->getImportedOwningModule())
9246 return M->getFullModuleName();
9248 // Otherwise, use the name of the top-level module the decl is within.
9249 if (ModuleFile *M = getOwningModuleFile(D))
9250 return M->ModuleName;
9252 // Not from a module.
9256 void ASTReader::finishPendingActions() {
9257 while (!PendingIdentifierInfos.empty() ||
9258 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9259 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9260 !PendingUpdateRecords.empty()) {
9261 // If any identifiers with corresponding top-level declarations have
9262 // been loaded, load those declarations now.
9263 using TopLevelDeclsMap =
9264 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9265 TopLevelDeclsMap TopLevelDecls;
9267 while (!PendingIdentifierInfos.empty()) {
9268 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9269 SmallVector<uint32_t, 4> DeclIDs =
9270 std::move(PendingIdentifierInfos.back().second);
9271 PendingIdentifierInfos.pop_back();
9273 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9276 // For each decl chain that we wanted to complete while deserializing, mark
9277 // it as "still needs to be completed".
9278 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9279 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9281 PendingIncompleteDeclChains.clear();
9283 // Load pending declaration chains.
9284 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9285 loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
9286 PendingDeclChains.clear();
9288 // Make the most recent of the top-level declarations visible.
9289 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9290 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9291 IdentifierInfo *II = TLD->first;
9292 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9293 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9297 // Load any pending macro definitions.
9298 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9299 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9300 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9301 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9302 // Initialize the macro history from chained-PCHs ahead of module imports.
9303 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9305 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9306 if (!Info.M->isModule())
9307 resolvePendingMacro(II, Info);
9309 // Handle module imports.
9310 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9312 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9313 if (Info.M->isModule())
9314 resolvePendingMacro(II, Info);
9317 PendingMacroIDs.clear();
9319 // Wire up the DeclContexts for Decls that we delayed setting until
9320 // recursive loading is completed.
9321 while (!PendingDeclContextInfos.empty()) {
9322 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9323 PendingDeclContextInfos.pop_front();
9324 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9325 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9326 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9329 // Perform any pending declaration updates.
9330 while (!PendingUpdateRecords.empty()) {
9331 auto Update = PendingUpdateRecords.pop_back_val();
9332 ReadingKindTracker ReadingKind(Read_Decl, *this);
9333 loadDeclUpdateRecords(Update);
9337 // At this point, all update records for loaded decls are in place, so any
9338 // fake class definitions should have become real.
9339 assert(PendingFakeDefinitionData.empty() &&
9340 "faked up a class definition but never saw the real one");
9342 // If we deserialized any C++ or Objective-C class definitions, any
9343 // Objective-C protocol definitions, or any redeclarable templates, make sure
9344 // that all redeclarations point to the definitions. Note that this can only
9345 // happen now, after the redeclaration chains have been fully wired.
9346 for (Decl *D : PendingDefinitions) {
9347 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9348 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9349 // Make sure that the TagType points at the definition.
9350 const_cast<TagType*>(TagT)->decl = TD;
9353 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9354 for (auto *R = getMostRecentExistingDecl(RD); R;
9355 R = R->getPreviousDecl()) {
9357 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9358 "declaration thinks it's the definition but it isn't");
9359 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9366 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9367 // Make sure that the ObjCInterfaceType points at the definition.
9368 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9371 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9372 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9377 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9378 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9379 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9384 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9385 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9386 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9388 PendingDefinitions.clear();
9390 // Load the bodies of any functions or methods we've encountered. We do
9391 // this now (delayed) so that we can be sure that the declaration chains
9392 // have been fully wired up (hasBody relies on this).
9393 // FIXME: We shouldn't require complete redeclaration chains here.
9394 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9395 PBEnd = PendingBodies.end();
9396 PB != PBEnd; ++PB) {
9397 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9398 // For a function defined inline within a class template, force the
9399 // canonical definition to be the one inside the canonical definition of
9400 // the template. This ensures that we instantiate from a correct view
9403 // Sadly we can't do this more generally: we can't be sure that all
9404 // copies of an arbitrary class definition will have the same members
9405 // defined (eg, some member functions may not be instantiated, and some
9406 // special members may or may not have been implicitly defined).
9407 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9408 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9411 // FIXME: Check for =delete/=default?
9412 // FIXME: Complain about ODR violations here?
9413 const FunctionDecl *Defn = nullptr;
9414 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9415 FD->setLazyBody(PB->second);
9417 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9418 mergeDefinitionVisibility(NonConstDefn, FD);
9420 if (!FD->isLateTemplateParsed() &&
9421 !NonConstDefn->isLateTemplateParsed() &&
9422 FD->getODRHash() != NonConstDefn->getODRHash()) {
9423 if (!isa<CXXMethodDecl>(FD)) {
9424 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9425 } else if (FD->getLexicalParent()->isFileContext() &&
9426 NonConstDefn->getLexicalParent()->isFileContext()) {
9427 // Only diagnose out-of-line method definitions. If they are
9428 // in class definitions, then an error will be generated when
9429 // processing the class bodies.
9430 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9437 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9438 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9439 MD->setLazyBody(PB->second);
9441 PendingBodies.clear();
9444 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9445 getContext().deduplicateMergedDefinitonsFor(ND);
9446 PendingMergedDefinitionsToDeduplicate.clear();
9449 void ASTReader::diagnoseOdrViolations() {
9450 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9451 PendingFunctionOdrMergeFailures.empty() &&
9452 PendingEnumOdrMergeFailures.empty())
9455 // Trigger the import of the full definition of each class that had any
9456 // odr-merging problems, so we can produce better diagnostics for them.
9457 // These updates may in turn find and diagnose some ODR failures, so take
9458 // ownership of the set first.
9459 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9460 PendingOdrMergeFailures.clear();
9461 for (auto &Merge : OdrMergeFailures) {
9462 Merge.first->buildLookup();
9463 Merge.first->decls_begin();
9464 Merge.first->bases_begin();
9465 Merge.first->vbases_begin();
9466 for (auto &RecordPair : Merge.second) {
9467 auto *RD = RecordPair.first;
9474 // Trigger the import of functions.
9475 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9476 PendingFunctionOdrMergeFailures.clear();
9477 for (auto &Merge : FunctionOdrMergeFailures) {
9478 Merge.first->buildLookup();
9479 Merge.first->decls_begin();
9480 Merge.first->getBody();
9481 for (auto &FD : Merge.second) {
9488 // Trigger the import of enums.
9489 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9490 PendingEnumOdrMergeFailures.clear();
9491 for (auto &Merge : EnumOdrMergeFailures) {
9492 Merge.first->decls_begin();
9493 for (auto &Enum : Merge.second) {
9494 Enum->decls_begin();
9498 // For each declaration from a merged context, check that the canonical
9499 // definition of that context also contains a declaration of the same
9502 // Caution: this loop does things that might invalidate iterators into
9503 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9504 while (!PendingOdrMergeChecks.empty()) {
9505 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9507 // FIXME: Skip over implicit declarations for now. This matters for things
9508 // like implicitly-declared special member functions. This isn't entirely
9509 // correct; we can end up with multiple unmerged declarations of the same
9511 if (D->isImplicit())
9514 DeclContext *CanonDef = D->getDeclContext();
9517 const Decl *DCanon = D->getCanonicalDecl();
9519 for (auto RI : D->redecls()) {
9520 if (RI->getLexicalDeclContext() == CanonDef) {
9528 // Quick check failed, time to do the slow thing. Note, we can't just
9529 // look up the name of D in CanonDef here, because the member that is
9530 // in CanonDef might not be found by name lookup (it might have been
9531 // replaced by a more recent declaration in the lookup table), and we
9532 // can't necessarily find it in the redeclaration chain because it might
9533 // be merely mergeable, not redeclarable.
9534 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9535 for (auto *CanonMember : CanonDef->decls()) {
9536 if (CanonMember->getCanonicalDecl() == DCanon) {
9537 // This can happen if the declaration is merely mergeable and not
9538 // actually redeclarable (we looked for redeclarations earlier).
9540 // FIXME: We should be able to detect this more efficiently, without
9541 // pulling in all of the members of CanonDef.
9545 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9546 if (ND->getDeclName() == D->getDeclName())
9547 Candidates.push_back(ND);
9551 // The AST doesn't like TagDecls becoming invalid after they've been
9552 // completed. We only really need to mark FieldDecls as invalid here.
9553 if (!isa<TagDecl>(D))
9554 D->setInvalidDecl();
9556 // Ensure we don't accidentally recursively enter deserialization while
9557 // we're producing our diagnostic.
9558 Deserializing RecursionGuard(this);
9560 std::string CanonDefModule =
9561 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9562 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9563 << D << getOwningModuleNameForDiagnostic(D)
9564 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9566 if (Candidates.empty())
9567 Diag(cast<Decl>(CanonDef)->getLocation(),
9568 diag::note_module_odr_violation_no_possible_decls) << D;
9570 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9571 Diag(Candidates[I]->getLocation(),
9572 diag::note_module_odr_violation_possible_decl)
9576 DiagnosedOdrMergeFailures.insert(CanonDef);
9580 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9581 EnumOdrMergeFailures.empty())
9584 // Ensure we don't accidentally recursively enter deserialization while
9585 // we're producing our diagnostics.
9586 Deserializing RecursionGuard(this);
9588 // Common code for hashing helpers.
9590 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9592 Hash.AddQualType(Ty);
9593 return Hash.CalculateHash();
9596 auto ComputeODRHash = [&Hash](const Stmt *S) {
9600 return Hash.CalculateHash();
9603 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9607 return Hash.CalculateHash();
9610 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9612 Hash.AddTemplateArgument(TA);
9613 return Hash.CalculateHash();
9616 auto ComputeTemplateParameterListODRHash =
9617 [&Hash](const TemplateParameterList *TPL) {
9620 Hash.AddTemplateParameterList(TPL);
9621 return Hash.CalculateHash();
9624 // Issue any pending ODR-failure diagnostics.
9625 for (auto &Merge : OdrMergeFailures) {
9626 // If we've already pointed out a specific problem with this class, don't
9627 // bother issuing a general "something's different" diagnostic.
9628 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9631 bool Diagnosed = false;
9632 CXXRecordDecl *FirstRecord = Merge.first;
9633 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9634 for (auto &RecordPair : Merge.second) {
9635 CXXRecordDecl *SecondRecord = RecordPair.first;
9636 // Multiple different declarations got merged together; tell the user
9637 // where they came from.
9638 if (FirstRecord == SecondRecord)
9641 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9643 auto *FirstDD = FirstRecord->DefinitionData;
9644 auto *SecondDD = RecordPair.second;
9646 assert(FirstDD && SecondDD && "Definitions without DefinitionData");
9648 // Diagnostics from DefinitionData are emitted here.
9649 if (FirstDD != SecondDD) {
9650 enum ODRDefinitionDataDifference {
9657 auto ODRDiagError = [FirstRecord, &FirstModule,
9658 this](SourceLocation Loc, SourceRange Range,
9659 ODRDefinitionDataDifference DiffType) {
9660 return Diag(Loc, diag::err_module_odr_violation_definition_data)
9661 << FirstRecord << FirstModule.empty() << FirstModule << Range
9664 auto ODRDiagNote = [&SecondModule,
9665 this](SourceLocation Loc, SourceRange Range,
9666 ODRDefinitionDataDifference DiffType) {
9667 return Diag(Loc, diag::note_module_odr_violation_definition_data)
9668 << SecondModule << Range << DiffType;
9671 unsigned FirstNumBases = FirstDD->NumBases;
9672 unsigned FirstNumVBases = FirstDD->NumVBases;
9673 unsigned SecondNumBases = SecondDD->NumBases;
9674 unsigned SecondNumVBases = SecondDD->NumVBases;
9676 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9677 unsigned NumBases = DD->NumBases;
9678 if (NumBases == 0) return SourceRange();
9679 auto bases = DD->bases();
9680 return SourceRange(bases[0].getLocStart(),
9681 bases[NumBases - 1].getLocEnd());
9684 if (FirstNumBases != SecondNumBases) {
9685 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9688 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9695 if (FirstNumVBases != SecondNumVBases) {
9696 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9699 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9706 auto FirstBases = FirstDD->bases();
9707 auto SecondBases = SecondDD->bases();
9709 for (i = 0; i < FirstNumBases; ++i) {
9710 auto FirstBase = FirstBases[i];
9711 auto SecondBase = SecondBases[i];
9712 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9713 ComputeQualTypeODRHash(SecondBase.getType())) {
9714 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9716 << (i + 1) << FirstBase.getType();
9717 ODRDiagNote(SecondRecord->getLocation(),
9718 SecondBase.getSourceRange(), BaseType)
9719 << (i + 1) << SecondBase.getType();
9723 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9724 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9726 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9727 ODRDiagNote(SecondRecord->getLocation(),
9728 SecondBase.getSourceRange(), BaseVirtual)
9729 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9733 if (FirstBase.getAccessSpecifierAsWritten() !=
9734 SecondBase.getAccessSpecifierAsWritten()) {
9735 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9737 << (i + 1) << FirstBase.getType()
9738 << (int)FirstBase.getAccessSpecifierAsWritten();
9739 ODRDiagNote(SecondRecord->getLocation(),
9740 SecondBase.getSourceRange(), BaseAccess)
9741 << (i + 1) << SecondBase.getType()
9742 << (int)SecondBase.getAccessSpecifierAsWritten();
9747 if (i != FirstNumBases) {
9753 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9755 const ClassTemplateDecl *FirstTemplate =
9756 FirstRecord->getDescribedClassTemplate();
9757 const ClassTemplateDecl *SecondTemplate =
9758 SecondRecord->getDescribedClassTemplate();
9760 assert(!FirstTemplate == !SecondTemplate &&
9761 "Both pointers should be null or non-null");
9763 enum ODRTemplateDifference {
9766 ParamSingleDefaultArgument,
9767 ParamDifferentDefaultArgument,
9770 if (FirstTemplate && SecondTemplate) {
9771 DeclHashes FirstTemplateHashes;
9772 DeclHashes SecondTemplateHashes;
9774 auto PopulateTemplateParameterHashs =
9775 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9776 const ClassTemplateDecl *TD) {
9777 for (auto *D : TD->getTemplateParameters()->asArray()) {
9778 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9782 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9783 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9785 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
9786 "Number of template parameters should be equal.");
9788 auto FirstIt = FirstTemplateHashes.begin();
9789 auto FirstEnd = FirstTemplateHashes.end();
9790 auto SecondIt = SecondTemplateHashes.begin();
9791 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9792 if (FirstIt->second == SecondIt->second)
9795 auto ODRDiagError = [FirstRecord, &FirstModule,
9796 this](SourceLocation Loc, SourceRange Range,
9797 ODRTemplateDifference DiffType) {
9798 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9799 << FirstRecord << FirstModule.empty() << FirstModule << Range
9802 auto ODRDiagNote = [&SecondModule,
9803 this](SourceLocation Loc, SourceRange Range,
9804 ODRTemplateDifference DiffType) {
9805 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9806 << SecondModule << Range << DiffType;
9809 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9810 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9812 assert(FirstDecl->getKind() == SecondDecl->getKind() &&
9813 "Parameter Decl's should be the same kind.");
9815 DeclarationName FirstName = FirstDecl->getDeclName();
9816 DeclarationName SecondName = SecondDecl->getDeclName();
9818 if (FirstName != SecondName) {
9819 const bool FirstNameEmpty =
9820 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9821 const bool SecondNameEmpty =
9822 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9823 assert((!FirstNameEmpty || !SecondNameEmpty) &&
9824 "Both template parameters cannot be unnamed.");
9825 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9826 FirstNameEmpty ? ParamEmptyName : ParamName)
9828 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9829 SecondNameEmpty ? ParamEmptyName : ParamName)
9834 switch (FirstDecl->getKind()) {
9836 llvm_unreachable("Invalid template parameter type.");
9837 case Decl::TemplateTypeParm: {
9838 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9839 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9840 const bool HasFirstDefaultArgument =
9841 FirstParam->hasDefaultArgument() &&
9842 !FirstParam->defaultArgumentWasInherited();
9843 const bool HasSecondDefaultArgument =
9844 SecondParam->hasDefaultArgument() &&
9845 !SecondParam->defaultArgumentWasInherited();
9847 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9848 ODRDiagError(FirstDecl->getLocation(),
9849 FirstDecl->getSourceRange(),
9850 ParamSingleDefaultArgument)
9851 << HasFirstDefaultArgument;
9852 ODRDiagNote(SecondDecl->getLocation(),
9853 SecondDecl->getSourceRange(),
9854 ParamSingleDefaultArgument)
9855 << HasSecondDefaultArgument;
9859 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9860 "Expecting default arguments.");
9862 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9863 ParamDifferentDefaultArgument);
9864 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9865 ParamDifferentDefaultArgument);
9869 case Decl::NonTypeTemplateParm: {
9870 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9871 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9872 const bool HasFirstDefaultArgument =
9873 FirstParam->hasDefaultArgument() &&
9874 !FirstParam->defaultArgumentWasInherited();
9875 const bool HasSecondDefaultArgument =
9876 SecondParam->hasDefaultArgument() &&
9877 !SecondParam->defaultArgumentWasInherited();
9879 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9880 ODRDiagError(FirstDecl->getLocation(),
9881 FirstDecl->getSourceRange(),
9882 ParamSingleDefaultArgument)
9883 << HasFirstDefaultArgument;
9884 ODRDiagNote(SecondDecl->getLocation(),
9885 SecondDecl->getSourceRange(),
9886 ParamSingleDefaultArgument)
9887 << HasSecondDefaultArgument;
9891 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9892 "Expecting default arguments.");
9894 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9895 ParamDifferentDefaultArgument);
9896 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9897 ParamDifferentDefaultArgument);
9901 case Decl::TemplateTemplateParm: {
9902 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
9903 const auto *SecondParam =
9904 cast<TemplateTemplateParmDecl>(SecondDecl);
9905 const bool HasFirstDefaultArgument =
9906 FirstParam->hasDefaultArgument() &&
9907 !FirstParam->defaultArgumentWasInherited();
9908 const bool HasSecondDefaultArgument =
9909 SecondParam->hasDefaultArgument() &&
9910 !SecondParam->defaultArgumentWasInherited();
9912 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9913 ODRDiagError(FirstDecl->getLocation(),
9914 FirstDecl->getSourceRange(),
9915 ParamSingleDefaultArgument)
9916 << HasFirstDefaultArgument;
9917 ODRDiagNote(SecondDecl->getLocation(),
9918 SecondDecl->getSourceRange(),
9919 ParamSingleDefaultArgument)
9920 << HasSecondDefaultArgument;
9924 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9925 "Expecting default arguments.");
9927 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9928 ParamDifferentDefaultArgument);
9929 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9930 ParamDifferentDefaultArgument);
9939 if (FirstIt != FirstEnd) {
9945 DeclHashes FirstHashes;
9946 DeclHashes SecondHashes;
9948 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
9949 DeclHashes &Hashes, CXXRecordDecl *Record) {
9950 for (auto *D : Record->decls()) {
9951 // Due to decl merging, the first CXXRecordDecl is the parent of
9952 // Decls in both records.
9953 if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
9955 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9958 PopulateHashes(FirstHashes, FirstRecord);
9959 PopulateHashes(SecondHashes, SecondRecord);
9961 // Used with err_module_odr_violation_mismatch_decl and
9962 // note_module_odr_violation_mismatch_decl
9963 // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
9978 } FirstDiffType = Other,
9979 SecondDiffType = Other;
9981 auto DifferenceSelector = [](Decl *D) {
9982 assert(D && "valid Decl required");
9983 switch (D->getKind()) {
9986 case Decl::AccessSpec:
9987 switch (D->getAccess()) {
9989 return PublicSpecifer;
9991 return PrivateSpecifer;
9993 return ProtectedSpecifer;
9997 llvm_unreachable("Invalid access specifier");
9998 case Decl::StaticAssert:
9999 return StaticAssert;
10002 case Decl::CXXMethod:
10003 case Decl::CXXConstructor:
10004 case Decl::CXXDestructor:
10006 case Decl::TypeAlias:
10008 case Decl::Typedef:
10014 case Decl::FunctionTemplate:
10015 return FunctionTemplate;
10019 Decl *FirstDecl = nullptr;
10020 Decl *SecondDecl = nullptr;
10021 auto FirstIt = FirstHashes.begin();
10022 auto SecondIt = SecondHashes.begin();
10024 // If there is a diagnoseable difference, FirstDiffType and
10025 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
10026 // filled in if not EndOfClass.
10027 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
10028 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
10029 FirstIt->second == SecondIt->second) {
10035 FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
10036 SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
10038 FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
10040 SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
10045 if (FirstDiffType == Other || SecondDiffType == Other) {
10046 // Reaching this point means an unexpected Decl was encountered
10047 // or no difference was detected. This causes a generic error
10048 // message to be emitted.
10049 Diag(FirstRecord->getLocation(),
10050 diag::err_module_odr_violation_different_definitions)
10051 << FirstRecord << FirstModule.empty() << FirstModule;
10054 Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
10055 << FirstRecord << FirstDecl->getSourceRange();
10058 Diag(SecondRecord->getLocation(),
10059 diag::note_module_odr_violation_different_definitions)
10063 Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
10064 << SecondDecl->getSourceRange();
10071 if (FirstDiffType != SecondDiffType) {
10072 SourceLocation FirstLoc;
10073 SourceRange FirstRange;
10074 if (FirstDiffType == EndOfClass) {
10075 FirstLoc = FirstRecord->getBraceRange().getEnd();
10077 FirstLoc = FirstIt->first->getLocation();
10078 FirstRange = FirstIt->first->getSourceRange();
10080 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10081 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10084 SourceLocation SecondLoc;
10085 SourceRange SecondRange;
10086 if (SecondDiffType == EndOfClass) {
10087 SecondLoc = SecondRecord->getBraceRange().getEnd();
10089 SecondLoc = SecondDecl->getLocation();
10090 SecondRange = SecondDecl->getSourceRange();
10092 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10093 << SecondModule << SecondRange << SecondDiffType;
10098 assert(FirstDiffType == SecondDiffType);
10100 // Used with err_module_odr_violation_mismatch_decl_diff and
10101 // note_module_odr_violation_mismatch_decl_diff
10102 enum ODRDeclDifference {
10103 StaticAssertCondition,
10104 StaticAssertMessage,
10105 StaticAssertOnlyMessage,
10108 FieldSingleBitField,
10109 FieldDifferentWidthBitField,
10110 FieldSingleMutable,
10111 FieldSingleInitializer,
10112 FieldDifferentInitializers,
10121 MethodNumberParameters,
10122 MethodParameterType,
10123 MethodParameterName,
10124 MethodParameterSingleDefaultArgument,
10125 MethodParameterDifferentDefaultArgument,
10126 MethodNoTemplateArguments,
10127 MethodDifferentNumberTemplateArguments,
10128 MethodDifferentTemplateArgument,
10130 MethodDifferentBody,
10135 VarSingleInitializer,
10136 VarDifferentInitializer,
10138 FriendTypeFunction,
10141 FunctionTemplateDifferentNumberParameters,
10142 FunctionTemplateParameterDifferentKind,
10143 FunctionTemplateParameterName,
10144 FunctionTemplateParameterSingleDefaultArgument,
10145 FunctionTemplateParameterDifferentDefaultArgument,
10146 FunctionTemplateParameterDifferentType,
10147 FunctionTemplatePackParameter,
10150 // These lambdas have the common portions of the ODR diagnostics. This
10151 // has the same return as Diag(), so addition parameters can be passed
10152 // in with operator<<
10153 auto ODRDiagError = [FirstRecord, &FirstModule, this](
10154 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10155 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
10156 << FirstRecord << FirstModule.empty() << FirstModule << Range
10159 auto ODRDiagNote = [&SecondModule, this](
10160 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10161 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
10162 << SecondModule << Range << DiffType;
10165 switch (FirstDiffType) {
10168 case PublicSpecifer:
10169 case PrivateSpecifer:
10170 case ProtectedSpecifer:
10171 llvm_unreachable("Invalid diff type");
10173 case StaticAssert: {
10174 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10175 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10177 Expr *FirstExpr = FirstSA->getAssertExpr();
10178 Expr *SecondExpr = SecondSA->getAssertExpr();
10179 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10180 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10181 if (FirstODRHash != SecondODRHash) {
10182 ODRDiagError(FirstExpr->getLocStart(), FirstExpr->getSourceRange(),
10183 StaticAssertCondition);
10184 ODRDiagNote(SecondExpr->getLocStart(),
10185 SecondExpr->getSourceRange(), StaticAssertCondition);
10190 StringLiteral *FirstStr = FirstSA->getMessage();
10191 StringLiteral *SecondStr = SecondSA->getMessage();
10192 assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10193 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10194 SourceLocation FirstLoc, SecondLoc;
10195 SourceRange FirstRange, SecondRange;
10197 FirstLoc = FirstStr->getLocStart();
10198 FirstRange = FirstStr->getSourceRange();
10200 FirstLoc = FirstSA->getLocStart();
10201 FirstRange = FirstSA->getSourceRange();
10204 SecondLoc = SecondStr->getLocStart();
10205 SecondRange = SecondStr->getSourceRange();
10207 SecondLoc = SecondSA->getLocStart();
10208 SecondRange = SecondSA->getSourceRange();
10210 ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
10211 << (FirstStr == nullptr);
10212 ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
10213 << (SecondStr == nullptr);
10218 if (FirstStr && SecondStr &&
10219 FirstStr->getString() != SecondStr->getString()) {
10220 ODRDiagError(FirstStr->getLocStart(), FirstStr->getSourceRange(),
10221 StaticAssertMessage);
10222 ODRDiagNote(SecondStr->getLocStart(), SecondStr->getSourceRange(),
10223 StaticAssertMessage);
10230 FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10231 FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10232 IdentifierInfo *FirstII = FirstField->getIdentifier();
10233 IdentifierInfo *SecondII = SecondField->getIdentifier();
10234 if (FirstII->getName() != SecondII->getName()) {
10235 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10238 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10246 assert(getContext().hasSameType(FirstField->getType(),
10247 SecondField->getType()));
10249 QualType FirstType = FirstField->getType();
10250 QualType SecondType = SecondField->getType();
10251 if (ComputeQualTypeODRHash(FirstType) !=
10252 ComputeQualTypeODRHash(SecondType)) {
10253 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10255 << FirstII << FirstType;
10256 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10258 << SecondII << SecondType;
10264 const bool IsFirstBitField = FirstField->isBitField();
10265 const bool IsSecondBitField = SecondField->isBitField();
10266 if (IsFirstBitField != IsSecondBitField) {
10267 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10268 FieldSingleBitField)
10269 << FirstII << IsFirstBitField;
10270 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10271 FieldSingleBitField)
10272 << SecondII << IsSecondBitField;
10277 if (IsFirstBitField && IsSecondBitField) {
10278 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10279 FieldDifferentWidthBitField)
10280 << FirstII << FirstField->getBitWidth()->getSourceRange();
10281 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10282 FieldDifferentWidthBitField)
10283 << SecondII << SecondField->getBitWidth()->getSourceRange();
10288 const bool IsFirstMutable = FirstField->isMutable();
10289 const bool IsSecondMutable = SecondField->isMutable();
10290 if (IsFirstMutable != IsSecondMutable) {
10291 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10292 FieldSingleMutable)
10293 << FirstII << IsFirstMutable;
10294 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10295 FieldSingleMutable)
10296 << SecondII << IsSecondMutable;
10301 const Expr *FirstInitializer = FirstField->getInClassInitializer();
10302 const Expr *SecondInitializer = SecondField->getInClassInitializer();
10303 if ((!FirstInitializer && SecondInitializer) ||
10304 (FirstInitializer && !SecondInitializer)) {
10305 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10306 FieldSingleInitializer)
10307 << FirstII << (FirstInitializer != nullptr);
10308 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10309 FieldSingleInitializer)
10310 << SecondII << (SecondInitializer != nullptr);
10315 if (FirstInitializer && SecondInitializer) {
10316 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10317 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10318 if (FirstInitHash != SecondInitHash) {
10319 ODRDiagError(FirstField->getLocation(),
10320 FirstField->getSourceRange(),
10321 FieldDifferentInitializers)
10322 << FirstII << FirstInitializer->getSourceRange();
10323 ODRDiagNote(SecondField->getLocation(),
10324 SecondField->getSourceRange(),
10325 FieldDifferentInitializers)
10326 << SecondII << SecondInitializer->getSourceRange();
10341 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10342 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10343 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10346 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10347 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10348 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10349 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10350 auto FirstName = FirstMethod->getDeclName();
10351 auto SecondName = SecondMethod->getDeclName();
10352 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10353 ODRDiagError(FirstMethod->getLocation(),
10354 FirstMethod->getSourceRange(), MethodName)
10355 << FirstMethodType << FirstName;
10356 ODRDiagNote(SecondMethod->getLocation(),
10357 SecondMethod->getSourceRange(), MethodName)
10358 << SecondMethodType << SecondName;
10364 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10365 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10366 if (FirstDeleted != SecondDeleted) {
10367 ODRDiagError(FirstMethod->getLocation(),
10368 FirstMethod->getSourceRange(), MethodDeleted)
10369 << FirstMethodType << FirstName << FirstDeleted;
10371 ODRDiagNote(SecondMethod->getLocation(),
10372 SecondMethod->getSourceRange(), MethodDeleted)
10373 << SecondMethodType << SecondName << SecondDeleted;
10378 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10379 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10380 if (FirstDefaulted != SecondDefaulted) {
10381 ODRDiagError(FirstMethod->getLocation(),
10382 FirstMethod->getSourceRange(), MethodDefaulted)
10383 << FirstMethodType << FirstName << FirstDefaulted;
10385 ODRDiagNote(SecondMethod->getLocation(),
10386 SecondMethod->getSourceRange(), MethodDefaulted)
10387 << SecondMethodType << SecondName << SecondDefaulted;
10392 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10393 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10394 const bool FirstPure = FirstMethod->isPure();
10395 const bool SecondPure = SecondMethod->isPure();
10396 if ((FirstVirtual || SecondVirtual) &&
10397 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10398 ODRDiagError(FirstMethod->getLocation(),
10399 FirstMethod->getSourceRange(), MethodVirtual)
10400 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10401 ODRDiagNote(SecondMethod->getLocation(),
10402 SecondMethod->getSourceRange(), MethodVirtual)
10403 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10408 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10409 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10410 // class needs to be checked instead.
10411 const auto FirstStorage = FirstMethod->getStorageClass();
10412 const auto SecondStorage = SecondMethod->getStorageClass();
10413 const bool FirstStatic = FirstStorage == SC_Static;
10414 const bool SecondStatic = SecondStorage == SC_Static;
10415 if (FirstStatic != SecondStatic) {
10416 ODRDiagError(FirstMethod->getLocation(),
10417 FirstMethod->getSourceRange(), MethodStatic)
10418 << FirstMethodType << FirstName << FirstStatic;
10419 ODRDiagNote(SecondMethod->getLocation(),
10420 SecondMethod->getSourceRange(), MethodStatic)
10421 << SecondMethodType << SecondName << SecondStatic;
10426 const bool FirstVolatile = FirstMethod->isVolatile();
10427 const bool SecondVolatile = SecondMethod->isVolatile();
10428 if (FirstVolatile != SecondVolatile) {
10429 ODRDiagError(FirstMethod->getLocation(),
10430 FirstMethod->getSourceRange(), MethodVolatile)
10431 << FirstMethodType << FirstName << FirstVolatile;
10432 ODRDiagNote(SecondMethod->getLocation(),
10433 SecondMethod->getSourceRange(), MethodVolatile)
10434 << SecondMethodType << SecondName << SecondVolatile;
10439 const bool FirstConst = FirstMethod->isConst();
10440 const bool SecondConst = SecondMethod->isConst();
10441 if (FirstConst != SecondConst) {
10442 ODRDiagError(FirstMethod->getLocation(),
10443 FirstMethod->getSourceRange(), MethodConst)
10444 << FirstMethodType << FirstName << FirstConst;
10445 ODRDiagNote(SecondMethod->getLocation(),
10446 SecondMethod->getSourceRange(), MethodConst)
10447 << SecondMethodType << SecondName << SecondConst;
10452 const bool FirstInline = FirstMethod->isInlineSpecified();
10453 const bool SecondInline = SecondMethod->isInlineSpecified();
10454 if (FirstInline != SecondInline) {
10455 ODRDiagError(FirstMethod->getLocation(),
10456 FirstMethod->getSourceRange(), MethodInline)
10457 << FirstMethodType << FirstName << FirstInline;
10458 ODRDiagNote(SecondMethod->getLocation(),
10459 SecondMethod->getSourceRange(), MethodInline)
10460 << SecondMethodType << SecondName << SecondInline;
10465 const unsigned FirstNumParameters = FirstMethod->param_size();
10466 const unsigned SecondNumParameters = SecondMethod->param_size();
10467 if (FirstNumParameters != SecondNumParameters) {
10468 ODRDiagError(FirstMethod->getLocation(),
10469 FirstMethod->getSourceRange(), MethodNumberParameters)
10470 << FirstMethodType << FirstName << FirstNumParameters;
10471 ODRDiagNote(SecondMethod->getLocation(),
10472 SecondMethod->getSourceRange(), MethodNumberParameters)
10473 << SecondMethodType << SecondName << SecondNumParameters;
10478 // Need this status boolean to know when break out of the switch.
10479 bool ParameterMismatch = false;
10480 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10481 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10482 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10484 QualType FirstParamType = FirstParam->getType();
10485 QualType SecondParamType = SecondParam->getType();
10486 if (FirstParamType != SecondParamType &&
10487 ComputeQualTypeODRHash(FirstParamType) !=
10488 ComputeQualTypeODRHash(SecondParamType)) {
10489 if (const DecayedType *ParamDecayedType =
10490 FirstParamType->getAs<DecayedType>()) {
10491 ODRDiagError(FirstMethod->getLocation(),
10492 FirstMethod->getSourceRange(), MethodParameterType)
10493 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10494 << true << ParamDecayedType->getOriginalType();
10496 ODRDiagError(FirstMethod->getLocation(),
10497 FirstMethod->getSourceRange(), MethodParameterType)
10498 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10502 if (const DecayedType *ParamDecayedType =
10503 SecondParamType->getAs<DecayedType>()) {
10504 ODRDiagNote(SecondMethod->getLocation(),
10505 SecondMethod->getSourceRange(), MethodParameterType)
10506 << SecondMethodType << SecondName << (I + 1)
10507 << SecondParamType << true
10508 << ParamDecayedType->getOriginalType();
10510 ODRDiagNote(SecondMethod->getLocation(),
10511 SecondMethod->getSourceRange(), MethodParameterType)
10512 << SecondMethodType << SecondName << (I + 1)
10513 << SecondParamType << false;
10515 ParameterMismatch = true;
10519 DeclarationName FirstParamName = FirstParam->getDeclName();
10520 DeclarationName SecondParamName = SecondParam->getDeclName();
10521 if (FirstParamName != SecondParamName) {
10522 ODRDiagError(FirstMethod->getLocation(),
10523 FirstMethod->getSourceRange(), MethodParameterName)
10524 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10525 ODRDiagNote(SecondMethod->getLocation(),
10526 SecondMethod->getSourceRange(), MethodParameterName)
10527 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10528 ParameterMismatch = true;
10532 const Expr *FirstInit = FirstParam->getInit();
10533 const Expr *SecondInit = SecondParam->getInit();
10534 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10535 ODRDiagError(FirstMethod->getLocation(),
10536 FirstMethod->getSourceRange(),
10537 MethodParameterSingleDefaultArgument)
10538 << FirstMethodType << FirstName << (I + 1)
10539 << (FirstInit == nullptr)
10540 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10541 ODRDiagNote(SecondMethod->getLocation(),
10542 SecondMethod->getSourceRange(),
10543 MethodParameterSingleDefaultArgument)
10544 << SecondMethodType << SecondName << (I + 1)
10545 << (SecondInit == nullptr)
10546 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10547 ParameterMismatch = true;
10551 if (FirstInit && SecondInit &&
10552 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10553 ODRDiagError(FirstMethod->getLocation(),
10554 FirstMethod->getSourceRange(),
10555 MethodParameterDifferentDefaultArgument)
10556 << FirstMethodType << FirstName << (I + 1)
10557 << FirstInit->getSourceRange();
10558 ODRDiagNote(SecondMethod->getLocation(),
10559 SecondMethod->getSourceRange(),
10560 MethodParameterDifferentDefaultArgument)
10561 << SecondMethodType << SecondName << (I + 1)
10562 << SecondInit->getSourceRange();
10563 ParameterMismatch = true;
10569 if (ParameterMismatch) {
10574 const auto *FirstTemplateArgs =
10575 FirstMethod->getTemplateSpecializationArgs();
10576 const auto *SecondTemplateArgs =
10577 SecondMethod->getTemplateSpecializationArgs();
10579 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10580 (!FirstTemplateArgs && SecondTemplateArgs)) {
10581 ODRDiagError(FirstMethod->getLocation(),
10582 FirstMethod->getSourceRange(), MethodNoTemplateArguments)
10583 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10584 ODRDiagNote(SecondMethod->getLocation(),
10585 SecondMethod->getSourceRange(), MethodNoTemplateArguments)
10586 << SecondMethodType << SecondName
10587 << (SecondTemplateArgs != nullptr);
10593 if (FirstTemplateArgs && SecondTemplateArgs) {
10594 // Remove pack expansions from argument list.
10595 auto ExpandTemplateArgumentList =
10596 [](const TemplateArgumentList *TAL) {
10597 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10598 for (const TemplateArgument &TA : TAL->asArray()) {
10599 if (TA.getKind() != TemplateArgument::Pack) {
10600 ExpandedList.push_back(&TA);
10603 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10604 ExpandedList.push_back(&PackTA);
10607 return ExpandedList;
10609 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10610 ExpandTemplateArgumentList(FirstTemplateArgs);
10611 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10612 ExpandTemplateArgumentList(SecondTemplateArgs);
10614 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10615 ODRDiagError(FirstMethod->getLocation(),
10616 FirstMethod->getSourceRange(),
10617 MethodDifferentNumberTemplateArguments)
10618 << FirstMethodType << FirstName
10619 << (unsigned)FirstExpandedList.size();
10620 ODRDiagNote(SecondMethod->getLocation(),
10621 SecondMethod->getSourceRange(),
10622 MethodDifferentNumberTemplateArguments)
10623 << SecondMethodType << SecondName
10624 << (unsigned)SecondExpandedList.size();
10630 bool TemplateArgumentMismatch = false;
10631 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10632 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10633 &SecondTA = *SecondExpandedList[i];
10634 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10635 ComputeTemplateArgumentODRHash(SecondTA)) {
10639 ODRDiagError(FirstMethod->getLocation(),
10640 FirstMethod->getSourceRange(),
10641 MethodDifferentTemplateArgument)
10642 << FirstMethodType << FirstName << FirstTA << i + 1;
10643 ODRDiagNote(SecondMethod->getLocation(),
10644 SecondMethod->getSourceRange(),
10645 MethodDifferentTemplateArgument)
10646 << SecondMethodType << SecondName << SecondTA << i + 1;
10648 TemplateArgumentMismatch = true;
10652 if (TemplateArgumentMismatch) {
10658 // Compute the hash of the method as if it has no body.
10659 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10661 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10662 return Hash.CalculateHash();
10665 // Compare the hash generated to the hash stored. A difference means
10666 // that a body was present in the original source. Due to merging,
10667 // the stardard way of detecting a body will not work.
10668 const bool HasFirstBody =
10669 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10670 const bool HasSecondBody =
10671 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10673 if (HasFirstBody != HasSecondBody) {
10674 ODRDiagError(FirstMethod->getLocation(),
10675 FirstMethod->getSourceRange(), MethodSingleBody)
10676 << FirstMethodType << FirstName << HasFirstBody;
10677 ODRDiagNote(SecondMethod->getLocation(),
10678 SecondMethod->getSourceRange(), MethodSingleBody)
10679 << SecondMethodType << SecondName << HasSecondBody;
10684 if (HasFirstBody && HasSecondBody) {
10685 ODRDiagError(FirstMethod->getLocation(),
10686 FirstMethod->getSourceRange(), MethodDifferentBody)
10687 << FirstMethodType << FirstName;
10688 ODRDiagNote(SecondMethod->getLocation(),
10689 SecondMethod->getSourceRange(), MethodDifferentBody)
10690 << SecondMethodType << SecondName;
10699 TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10700 TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10701 auto FirstName = FirstTD->getDeclName();
10702 auto SecondName = SecondTD->getDeclName();
10703 if (FirstName != SecondName) {
10704 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10706 << (FirstDiffType == TypeAlias) << FirstName;
10707 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10709 << (FirstDiffType == TypeAlias) << SecondName;
10714 QualType FirstType = FirstTD->getUnderlyingType();
10715 QualType SecondType = SecondTD->getUnderlyingType();
10716 if (ComputeQualTypeODRHash(FirstType) !=
10717 ComputeQualTypeODRHash(SecondType)) {
10718 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10720 << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10721 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10723 << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10730 VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10731 VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10732 auto FirstName = FirstVD->getDeclName();
10733 auto SecondName = SecondVD->getDeclName();
10734 if (FirstName != SecondName) {
10735 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10738 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10745 QualType FirstType = FirstVD->getType();
10746 QualType SecondType = SecondVD->getType();
10747 if (ComputeQualTypeODRHash(FirstType) !=
10748 ComputeQualTypeODRHash(SecondType)) {
10749 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10751 << FirstName << FirstType;
10752 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10754 << SecondName << SecondType;
10759 const Expr *FirstInit = FirstVD->getInit();
10760 const Expr *SecondInit = SecondVD->getInit();
10761 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10762 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10763 VarSingleInitializer)
10764 << FirstName << (FirstInit == nullptr)
10765 << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10766 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10767 VarSingleInitializer)
10768 << SecondName << (SecondInit == nullptr)
10769 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10774 if (FirstInit && SecondInit &&
10775 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10776 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10777 VarDifferentInitializer)
10778 << FirstName << FirstInit->getSourceRange();
10779 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10780 VarDifferentInitializer)
10781 << SecondName << SecondInit->getSourceRange();
10786 const bool FirstIsConstexpr = FirstVD->isConstexpr();
10787 const bool SecondIsConstexpr = SecondVD->isConstexpr();
10788 if (FirstIsConstexpr != SecondIsConstexpr) {
10789 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10791 << FirstName << FirstIsConstexpr;
10792 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10794 << SecondName << SecondIsConstexpr;
10801 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10802 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10804 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10805 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10807 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10808 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10810 if (FirstND && SecondND) {
10811 ODRDiagError(FirstFriend->getFriendLoc(),
10812 FirstFriend->getSourceRange(), FriendFunction)
10814 ODRDiagNote(SecondFriend->getFriendLoc(),
10815 SecondFriend->getSourceRange(), FriendFunction)
10822 if (FirstTSI && SecondTSI) {
10823 QualType FirstFriendType = FirstTSI->getType();
10824 QualType SecondFriendType = SecondTSI->getType();
10825 assert(ComputeQualTypeODRHash(FirstFriendType) !=
10826 ComputeQualTypeODRHash(SecondFriendType));
10827 ODRDiagError(FirstFriend->getFriendLoc(),
10828 FirstFriend->getSourceRange(), FriendType)
10829 << FirstFriendType;
10830 ODRDiagNote(SecondFriend->getFriendLoc(),
10831 SecondFriend->getSourceRange(), FriendType)
10832 << SecondFriendType;
10837 ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10838 FriendTypeFunction)
10839 << (FirstTSI == nullptr);
10840 ODRDiagNote(SecondFriend->getFriendLoc(),
10841 SecondFriend->getSourceRange(), FriendTypeFunction)
10842 << (SecondTSI == nullptr);
10847 case FunctionTemplate: {
10848 FunctionTemplateDecl *FirstTemplate =
10849 cast<FunctionTemplateDecl>(FirstDecl);
10850 FunctionTemplateDecl *SecondTemplate =
10851 cast<FunctionTemplateDecl>(SecondDecl);
10853 TemplateParameterList *FirstTPL =
10854 FirstTemplate->getTemplateParameters();
10855 TemplateParameterList *SecondTPL =
10856 SecondTemplate->getTemplateParameters();
10858 if (FirstTPL->size() != SecondTPL->size()) {
10859 ODRDiagError(FirstTemplate->getLocation(),
10860 FirstTemplate->getSourceRange(),
10861 FunctionTemplateDifferentNumberParameters)
10862 << FirstTemplate << FirstTPL->size();
10863 ODRDiagNote(SecondTemplate->getLocation(),
10864 SecondTemplate->getSourceRange(),
10865 FunctionTemplateDifferentNumberParameters)
10866 << SecondTemplate << SecondTPL->size();
10872 bool ParameterMismatch = false;
10873 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10874 NamedDecl *FirstParam = FirstTPL->getParam(i);
10875 NamedDecl *SecondParam = SecondTPL->getParam(i);
10877 if (FirstParam->getKind() != SecondParam->getKind()) {
10879 TemplateTypeParameter,
10880 NonTypeTemplateParameter,
10881 TemplateTemplateParameter,
10883 auto GetParamType = [](NamedDecl *D) {
10884 switch (D->getKind()) {
10886 llvm_unreachable("Unexpected template parameter type");
10887 case Decl::TemplateTypeParm:
10888 return TemplateTypeParameter;
10889 case Decl::NonTypeTemplateParm:
10890 return NonTypeTemplateParameter;
10891 case Decl::TemplateTemplateParm:
10892 return TemplateTemplateParameter;
10896 ODRDiagError(FirstTemplate->getLocation(),
10897 FirstTemplate->getSourceRange(),
10898 FunctionTemplateParameterDifferentKind)
10899 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10900 ODRDiagNote(SecondTemplate->getLocation(),
10901 SecondTemplate->getSourceRange(),
10902 FunctionTemplateParameterDifferentKind)
10903 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10905 ParameterMismatch = true;
10909 if (FirstParam->getName() != SecondParam->getName()) {
10910 ODRDiagError(FirstTemplate->getLocation(),
10911 FirstTemplate->getSourceRange(),
10912 FunctionTemplateParameterName)
10913 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10915 ODRDiagNote(SecondTemplate->getLocation(),
10916 SecondTemplate->getSourceRange(),
10917 FunctionTemplateParameterName)
10918 << SecondTemplate << (i + 1)
10919 << (bool)SecondParam->getIdentifier() << SecondParam;
10920 ParameterMismatch = true;
10924 if (isa<TemplateTypeParmDecl>(FirstParam) &&
10925 isa<TemplateTypeParmDecl>(SecondParam)) {
10926 TemplateTypeParmDecl *FirstTTPD =
10927 cast<TemplateTypeParmDecl>(FirstParam);
10928 TemplateTypeParmDecl *SecondTTPD =
10929 cast<TemplateTypeParmDecl>(SecondParam);
10930 bool HasFirstDefaultArgument =
10931 FirstTTPD->hasDefaultArgument() &&
10932 !FirstTTPD->defaultArgumentWasInherited();
10933 bool HasSecondDefaultArgument =
10934 SecondTTPD->hasDefaultArgument() &&
10935 !SecondTTPD->defaultArgumentWasInherited();
10936 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10937 ODRDiagError(FirstTemplate->getLocation(),
10938 FirstTemplate->getSourceRange(),
10939 FunctionTemplateParameterSingleDefaultArgument)
10940 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10941 ODRDiagNote(SecondTemplate->getLocation(),
10942 SecondTemplate->getSourceRange(),
10943 FunctionTemplateParameterSingleDefaultArgument)
10944 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
10945 ParameterMismatch = true;
10949 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
10950 QualType FirstType = FirstTTPD->getDefaultArgument();
10951 QualType SecondType = SecondTTPD->getDefaultArgument();
10952 if (ComputeQualTypeODRHash(FirstType) !=
10953 ComputeQualTypeODRHash(SecondType)) {
10954 ODRDiagError(FirstTemplate->getLocation(),
10955 FirstTemplate->getSourceRange(),
10956 FunctionTemplateParameterDifferentDefaultArgument)
10957 << FirstTemplate << (i + 1) << FirstType;
10958 ODRDiagNote(SecondTemplate->getLocation(),
10959 SecondTemplate->getSourceRange(),
10960 FunctionTemplateParameterDifferentDefaultArgument)
10961 << SecondTemplate << (i + 1) << SecondType;
10962 ParameterMismatch = true;
10967 if (FirstTTPD->isParameterPack() !=
10968 SecondTTPD->isParameterPack()) {
10969 ODRDiagError(FirstTemplate->getLocation(),
10970 FirstTemplate->getSourceRange(),
10971 FunctionTemplatePackParameter)
10972 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
10973 ODRDiagNote(SecondTemplate->getLocation(),
10974 SecondTemplate->getSourceRange(),
10975 FunctionTemplatePackParameter)
10976 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
10977 ParameterMismatch = true;
10982 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
10983 isa<TemplateTemplateParmDecl>(SecondParam)) {
10984 TemplateTemplateParmDecl *FirstTTPD =
10985 cast<TemplateTemplateParmDecl>(FirstParam);
10986 TemplateTemplateParmDecl *SecondTTPD =
10987 cast<TemplateTemplateParmDecl>(SecondParam);
10989 TemplateParameterList *FirstTPL =
10990 FirstTTPD->getTemplateParameters();
10991 TemplateParameterList *SecondTPL =
10992 SecondTTPD->getTemplateParameters();
10994 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
10995 ComputeTemplateParameterListODRHash(SecondTPL)) {
10996 ODRDiagError(FirstTemplate->getLocation(),
10997 FirstTemplate->getSourceRange(),
10998 FunctionTemplateParameterDifferentType)
10999 << FirstTemplate << (i + 1);
11000 ODRDiagNote(SecondTemplate->getLocation(),
11001 SecondTemplate->getSourceRange(),
11002 FunctionTemplateParameterDifferentType)
11003 << SecondTemplate << (i + 1);
11004 ParameterMismatch = true;
11008 bool HasFirstDefaultArgument =
11009 FirstTTPD->hasDefaultArgument() &&
11010 !FirstTTPD->defaultArgumentWasInherited();
11011 bool HasSecondDefaultArgument =
11012 SecondTTPD->hasDefaultArgument() &&
11013 !SecondTTPD->defaultArgumentWasInherited();
11014 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11015 ODRDiagError(FirstTemplate->getLocation(),
11016 FirstTemplate->getSourceRange(),
11017 FunctionTemplateParameterSingleDefaultArgument)
11018 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11019 ODRDiagNote(SecondTemplate->getLocation(),
11020 SecondTemplate->getSourceRange(),
11021 FunctionTemplateParameterSingleDefaultArgument)
11022 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11023 ParameterMismatch = true;
11027 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11028 TemplateArgument FirstTA =
11029 FirstTTPD->getDefaultArgument().getArgument();
11030 TemplateArgument SecondTA =
11031 SecondTTPD->getDefaultArgument().getArgument();
11032 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11033 ComputeTemplateArgumentODRHash(SecondTA)) {
11034 ODRDiagError(FirstTemplate->getLocation(),
11035 FirstTemplate->getSourceRange(),
11036 FunctionTemplateParameterDifferentDefaultArgument)
11037 << FirstTemplate << (i + 1) << FirstTA;
11038 ODRDiagNote(SecondTemplate->getLocation(),
11039 SecondTemplate->getSourceRange(),
11040 FunctionTemplateParameterDifferentDefaultArgument)
11041 << SecondTemplate << (i + 1) << SecondTA;
11042 ParameterMismatch = true;
11047 if (FirstTTPD->isParameterPack() !=
11048 SecondTTPD->isParameterPack()) {
11049 ODRDiagError(FirstTemplate->getLocation(),
11050 FirstTemplate->getSourceRange(),
11051 FunctionTemplatePackParameter)
11052 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11053 ODRDiagNote(SecondTemplate->getLocation(),
11054 SecondTemplate->getSourceRange(),
11055 FunctionTemplatePackParameter)
11056 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11057 ParameterMismatch = true;
11062 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11063 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11064 NonTypeTemplateParmDecl *FirstNTTPD =
11065 cast<NonTypeTemplateParmDecl>(FirstParam);
11066 NonTypeTemplateParmDecl *SecondNTTPD =
11067 cast<NonTypeTemplateParmDecl>(SecondParam);
11069 QualType FirstType = FirstNTTPD->getType();
11070 QualType SecondType = SecondNTTPD->getType();
11071 if (ComputeQualTypeODRHash(FirstType) !=
11072 ComputeQualTypeODRHash(SecondType)) {
11073 ODRDiagError(FirstTemplate->getLocation(),
11074 FirstTemplate->getSourceRange(),
11075 FunctionTemplateParameterDifferentType)
11076 << FirstTemplate << (i + 1);
11077 ODRDiagNote(SecondTemplate->getLocation(),
11078 SecondTemplate->getSourceRange(),
11079 FunctionTemplateParameterDifferentType)
11080 << SecondTemplate << (i + 1);
11081 ParameterMismatch = true;
11085 bool HasFirstDefaultArgument =
11086 FirstNTTPD->hasDefaultArgument() &&
11087 !FirstNTTPD->defaultArgumentWasInherited();
11088 bool HasSecondDefaultArgument =
11089 SecondNTTPD->hasDefaultArgument() &&
11090 !SecondNTTPD->defaultArgumentWasInherited();
11091 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11092 ODRDiagError(FirstTemplate->getLocation(),
11093 FirstTemplate->getSourceRange(),
11094 FunctionTemplateParameterSingleDefaultArgument)
11095 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11096 ODRDiagNote(SecondTemplate->getLocation(),
11097 SecondTemplate->getSourceRange(),
11098 FunctionTemplateParameterSingleDefaultArgument)
11099 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11100 ParameterMismatch = true;
11104 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11105 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11106 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11107 if (ComputeODRHash(FirstDefaultArgument) !=
11108 ComputeODRHash(SecondDefaultArgument)) {
11109 ODRDiagError(FirstTemplate->getLocation(),
11110 FirstTemplate->getSourceRange(),
11111 FunctionTemplateParameterDifferentDefaultArgument)
11112 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11113 ODRDiagNote(SecondTemplate->getLocation(),
11114 SecondTemplate->getSourceRange(),
11115 FunctionTemplateParameterDifferentDefaultArgument)
11116 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11117 ParameterMismatch = true;
11122 if (FirstNTTPD->isParameterPack() !=
11123 SecondNTTPD->isParameterPack()) {
11124 ODRDiagError(FirstTemplate->getLocation(),
11125 FirstTemplate->getSourceRange(),
11126 FunctionTemplatePackParameter)
11127 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11128 ODRDiagNote(SecondTemplate->getLocation(),
11129 SecondTemplate->getSourceRange(),
11130 FunctionTemplatePackParameter)
11131 << SecondTemplate << (i + 1)
11132 << SecondNTTPD->isParameterPack();
11133 ParameterMismatch = true;
11139 if (ParameterMismatch) {
11151 Diag(FirstDecl->getLocation(),
11152 diag::err_module_odr_violation_mismatch_decl_unknown)
11153 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11154 << FirstDecl->getSourceRange();
11155 Diag(SecondDecl->getLocation(),
11156 diag::note_module_odr_violation_mismatch_decl_unknown)
11157 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11162 // All definitions are updates to the same declaration. This happens if a
11163 // module instantiates the declaration of a class template specialization
11164 // and two or more other modules instantiate its definition.
11166 // FIXME: Indicate which modules had instantiations of this definition.
11167 // FIXME: How can this even happen?
11168 Diag(Merge.first->getLocation(),
11169 diag::err_module_odr_violation_different_instantiations)
11174 // Issue ODR failures diagnostics for functions.
11175 for (auto &Merge : FunctionOdrMergeFailures) {
11176 enum ODRFunctionDifference {
11180 ParameterSingleDefaultArgument,
11181 ParameterDifferentDefaultArgument,
11185 FunctionDecl *FirstFunction = Merge.first;
11186 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11188 bool Diagnosed = false;
11189 for (auto &SecondFunction : Merge.second) {
11191 if (FirstFunction == SecondFunction)
11194 std::string SecondModule =
11195 getOwningModuleNameForDiagnostic(SecondFunction);
11197 auto ODRDiagError = [FirstFunction, &FirstModule,
11198 this](SourceLocation Loc, SourceRange Range,
11199 ODRFunctionDifference DiffType) {
11200 return Diag(Loc, diag::err_module_odr_violation_function)
11201 << FirstFunction << FirstModule.empty() << FirstModule << Range
11204 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11206 ODRFunctionDifference DiffType) {
11207 return Diag(Loc, diag::note_module_odr_violation_function)
11208 << SecondModule << Range << DiffType;
11211 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11212 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11213 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11214 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11215 << FirstFunction->getReturnType();
11216 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11217 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11218 << SecondFunction->getReturnType();
11223 assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11224 "Merged functions with different number of parameters");
11226 auto ParamSize = FirstFunction->param_size();
11227 bool ParameterMismatch = false;
11228 for (unsigned I = 0; I < ParamSize; ++I) {
11229 auto *FirstParam = FirstFunction->getParamDecl(I);
11230 auto *SecondParam = SecondFunction->getParamDecl(I);
11232 assert(getContext().hasSameType(FirstParam->getType(),
11233 SecondParam->getType()) &&
11234 "Merged function has different parameter types.");
11236 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11237 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11239 << I + 1 << FirstParam->getDeclName();
11240 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11242 << I + 1 << SecondParam->getDeclName();
11243 ParameterMismatch = true;
11247 QualType FirstParamType = FirstParam->getType();
11248 QualType SecondParamType = SecondParam->getType();
11249 if (FirstParamType != SecondParamType &&
11250 ComputeQualTypeODRHash(FirstParamType) !=
11251 ComputeQualTypeODRHash(SecondParamType)) {
11252 if (const DecayedType *ParamDecayedType =
11253 FirstParamType->getAs<DecayedType>()) {
11254 ODRDiagError(FirstParam->getLocation(),
11255 FirstParam->getSourceRange(), ParameterType)
11256 << (I + 1) << FirstParamType << true
11257 << ParamDecayedType->getOriginalType();
11259 ODRDiagError(FirstParam->getLocation(),
11260 FirstParam->getSourceRange(), ParameterType)
11261 << (I + 1) << FirstParamType << false;
11264 if (const DecayedType *ParamDecayedType =
11265 SecondParamType->getAs<DecayedType>()) {
11266 ODRDiagNote(SecondParam->getLocation(),
11267 SecondParam->getSourceRange(), ParameterType)
11268 << (I + 1) << SecondParamType << true
11269 << ParamDecayedType->getOriginalType();
11271 ODRDiagNote(SecondParam->getLocation(),
11272 SecondParam->getSourceRange(), ParameterType)
11273 << (I + 1) << SecondParamType << false;
11275 ParameterMismatch = true;
11279 const Expr *FirstInit = FirstParam->getInit();
11280 const Expr *SecondInit = SecondParam->getInit();
11281 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11282 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11283 ParameterSingleDefaultArgument)
11284 << (I + 1) << (FirstInit == nullptr)
11285 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11286 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11287 ParameterSingleDefaultArgument)
11288 << (I + 1) << (SecondInit == nullptr)
11289 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11290 ParameterMismatch = true;
11294 if (FirstInit && SecondInit &&
11295 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11296 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11297 ParameterDifferentDefaultArgument)
11298 << (I + 1) << FirstInit->getSourceRange();
11299 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11300 ParameterDifferentDefaultArgument)
11301 << (I + 1) << SecondInit->getSourceRange();
11302 ParameterMismatch = true;
11306 assert(ComputeSubDeclODRHash(FirstParam) ==
11307 ComputeSubDeclODRHash(SecondParam) &&
11308 "Undiagnosed parameter difference.");
11311 if (ParameterMismatch) {
11316 // If no error has been generated before now, assume the problem is in
11317 // the body and generate a message.
11318 ODRDiagError(FirstFunction->getLocation(),
11319 FirstFunction->getSourceRange(), FunctionBody);
11320 ODRDiagNote(SecondFunction->getLocation(),
11321 SecondFunction->getSourceRange(), FunctionBody);
11326 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11329 // Issue ODR failures diagnostics for enums.
11330 for (auto &Merge : EnumOdrMergeFailures) {
11331 enum ODREnumDifference {
11333 EnumTagKeywordMismatch,
11334 SingleSpecifiedType,
11335 DifferentSpecifiedTypes,
11336 DifferentNumberEnumConstants,
11338 EnumConstantSingleInitilizer,
11339 EnumConstantDifferentInitilizer,
11342 // If we've already pointed out a specific problem with this enum, don't
11343 // bother issuing a general "something's different" diagnostic.
11344 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11347 EnumDecl *FirstEnum = Merge.first;
11348 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11351 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11352 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11353 DeclHashes &Hashes, EnumDecl *Enum) {
11354 for (auto *D : Enum->decls()) {
11355 // Due to decl merging, the first EnumDecl is the parent of
11356 // Decls in both records.
11357 if (!ODRHash::isWhitelistedDecl(D, FirstEnum))
11359 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11360 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11361 ComputeSubDeclODRHash(D));
11364 DeclHashes FirstHashes;
11365 PopulateHashes(FirstHashes, FirstEnum);
11366 bool Diagnosed = false;
11367 for (auto &SecondEnum : Merge.second) {
11369 if (FirstEnum == SecondEnum)
11372 std::string SecondModule =
11373 getOwningModuleNameForDiagnostic(SecondEnum);
11375 auto ODRDiagError = [FirstEnum, &FirstModule,
11376 this](SourceLocation Loc, SourceRange Range,
11377 ODREnumDifference DiffType) {
11378 return Diag(Loc, diag::err_module_odr_violation_enum)
11379 << FirstEnum << FirstModule.empty() << FirstModule << Range
11382 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11384 ODREnumDifference DiffType) {
11385 return Diag(Loc, diag::note_module_odr_violation_enum)
11386 << SecondModule << Range << DiffType;
11389 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11390 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11392 << FirstEnum->isScoped();
11393 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11395 << SecondEnum->isScoped();
11400 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11401 if (FirstEnum->isScopedUsingClassTag() !=
11402 SecondEnum->isScopedUsingClassTag()) {
11403 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11404 EnumTagKeywordMismatch)
11405 << FirstEnum->isScopedUsingClassTag();
11406 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11407 EnumTagKeywordMismatch)
11408 << SecondEnum->isScopedUsingClassTag();
11414 QualType FirstUnderlyingType =
11415 FirstEnum->getIntegerTypeSourceInfo()
11416 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11418 QualType SecondUnderlyingType =
11419 SecondEnum->getIntegerTypeSourceInfo()
11420 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11422 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11423 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11424 SingleSpecifiedType)
11425 << !FirstUnderlyingType.isNull();
11426 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11427 SingleSpecifiedType)
11428 << !SecondUnderlyingType.isNull();
11433 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11434 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11435 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11436 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11437 DifferentSpecifiedTypes)
11438 << FirstUnderlyingType;
11439 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11440 DifferentSpecifiedTypes)
11441 << SecondUnderlyingType;
11447 DeclHashes SecondHashes;
11448 PopulateHashes(SecondHashes, SecondEnum);
11450 if (FirstHashes.size() != SecondHashes.size()) {
11451 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11452 DifferentNumberEnumConstants)
11453 << (int)FirstHashes.size();
11454 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11455 DifferentNumberEnumConstants)
11456 << (int)SecondHashes.size();
11461 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11462 if (FirstHashes[I].second == SecondHashes[I].second)
11464 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11465 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11467 if (FirstEnumConstant->getDeclName() !=
11468 SecondEnumConstant->getDeclName()) {
11470 ODRDiagError(FirstEnumConstant->getLocation(),
11471 FirstEnumConstant->getSourceRange(), EnumConstantName)
11472 << I + 1 << FirstEnumConstant;
11473 ODRDiagNote(SecondEnumConstant->getLocation(),
11474 SecondEnumConstant->getSourceRange(), EnumConstantName)
11475 << I + 1 << SecondEnumConstant;
11480 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11481 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11482 if (!FirstInit && !SecondInit)
11485 if (!FirstInit || !SecondInit) {
11486 ODRDiagError(FirstEnumConstant->getLocation(),
11487 FirstEnumConstant->getSourceRange(),
11488 EnumConstantSingleInitilizer)
11489 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11490 ODRDiagNote(SecondEnumConstant->getLocation(),
11491 SecondEnumConstant->getSourceRange(),
11492 EnumConstantSingleInitilizer)
11493 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11498 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11499 ODRDiagError(FirstEnumConstant->getLocation(),
11500 FirstEnumConstant->getSourceRange(),
11501 EnumConstantDifferentInitilizer)
11502 << I + 1 << FirstEnumConstant;
11503 ODRDiagNote(SecondEnumConstant->getLocation(),
11504 SecondEnumConstant->getSourceRange(),
11505 EnumConstantDifferentInitilizer)
11506 << I + 1 << SecondEnumConstant;
11514 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11518 void ASTReader::StartedDeserializing() {
11519 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11520 ReadTimer->startTimer();
11523 void ASTReader::FinishedDeserializing() {
11524 assert(NumCurrentElementsDeserializing &&
11525 "FinishedDeserializing not paired with StartedDeserializing");
11526 if (NumCurrentElementsDeserializing == 1) {
11527 // We decrease NumCurrentElementsDeserializing only after pending actions
11528 // are finished, to avoid recursively re-calling finishPendingActions().
11529 finishPendingActions();
11531 --NumCurrentElementsDeserializing;
11533 if (NumCurrentElementsDeserializing == 0) {
11534 // Propagate exception specification updates along redeclaration chains.
11535 while (!PendingExceptionSpecUpdates.empty()) {
11536 auto Updates = std::move(PendingExceptionSpecUpdates);
11537 PendingExceptionSpecUpdates.clear();
11538 for (auto Update : Updates) {
11539 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11540 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11541 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11542 if (auto *Listener = getContext().getASTMutationListener())
11543 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11544 for (auto *Redecl : Update.second->redecls())
11545 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11550 ReadTimer->stopTimer();
11552 diagnoseOdrViolations();
11554 // We are not in recursive loading, so it's safe to pass the "interesting"
11555 // decls to the consumer.
11557 PassInterestingDeclsToConsumer();
11561 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11562 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11563 // Remove any fake results before adding any real ones.
11564 auto It = PendingFakeLookupResults.find(II);
11565 if (It != PendingFakeLookupResults.end()) {
11566 for (auto *ND : It->second)
11567 SemaObj->IdResolver.RemoveDecl(ND);
11568 // FIXME: this works around module+PCH performance issue.
11569 // Rather than erase the result from the map, which is O(n), just clear
11570 // the vector of NamedDecls.
11571 It->second.clear();
11575 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11576 SemaObj->TUScope->AddDecl(D);
11577 } else if (SemaObj->TUScope) {
11578 // Adding the decl to IdResolver may have failed because it was already in
11579 // (even though it was not added in scope). If it is already in, make sure
11580 // it gets in the scope as well.
11581 if (std::find(SemaObj->IdResolver.begin(Name),
11582 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11583 SemaObj->TUScope->AddDecl(D);
11587 ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
11588 const PCHContainerReader &PCHContainerRdr,
11589 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11590 StringRef isysroot, bool DisableValidation,
11591 bool AllowASTWithCompilerErrors,
11592 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11593 bool UseGlobalIndex,
11594 std::unique_ptr<llvm::Timer> ReadTimer)
11595 : Listener(DisableValidation
11596 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11597 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11598 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11599 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11600 ContextObj(Context),
11601 ModuleMgr(PP.getFileManager(), PP.getPCMCache(), PCHContainerRdr,
11602 PP.getHeaderSearchInfo()),
11603 PCMCache(PP.getPCMCache()), DummyIdResolver(PP),
11604 ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11605 DisableValidation(DisableValidation),
11606 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11607 AllowConfigurationMismatch(AllowConfigurationMismatch),
11608 ValidateSystemInputs(ValidateSystemInputs),
11609 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11610 SourceMgr.setExternalSLocEntrySource(this);
11612 for (const auto &Ext : Extensions) {
11613 auto BlockName = Ext->getExtensionMetadata().BlockName;
11614 auto Known = ModuleFileExtensions.find(BlockName);
11615 if (Known != ModuleFileExtensions.end()) {
11616 Diags.Report(diag::warn_duplicate_module_file_extension)
11621 ModuleFileExtensions.insert({BlockName, Ext});
11625 ASTReader::~ASTReader() {
11626 if (OwnsDeserializationListener)
11627 delete DeserializationListener;
11630 IdentifierResolver &ASTReader::getIdResolver() {
11631 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11634 unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11635 unsigned AbbrevID) {
11638 return Cursor.readRecord(AbbrevID, Record);