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/Lex/HeaderSearch.h"
65 #include "clang/Lex/HeaderSearchOptions.h"
66 #include "clang/Lex/MacroInfo.h"
67 #include "clang/Lex/ModuleMap.h"
68 #include "clang/Lex/PreprocessingRecord.h"
69 #include "clang/Lex/Preprocessor.h"
70 #include "clang/Lex/PreprocessorOptions.h"
71 #include "clang/Lex/Token.h"
72 #include "clang/Sema/ObjCMethodList.h"
73 #include "clang/Sema/Scope.h"
74 #include "clang/Sema/Sema.h"
75 #include "clang/Sema/Weak.h"
76 #include "clang/Serialization/ASTBitCodes.h"
77 #include "clang/Serialization/ASTDeserializationListener.h"
78 #include "clang/Serialization/ContinuousRangeMap.h"
79 #include "clang/Serialization/GlobalModuleIndex.h"
80 #include "clang/Serialization/Module.h"
81 #include "clang/Serialization/ModuleFileExtension.h"
82 #include "clang/Serialization/ModuleManager.h"
83 #include "clang/Serialization/PCHContainerOperations.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);
400 llvm::sort(ReadFeatures);
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());
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 if (Def->isHidden()) {
3784 // If MergedDef is visible or becomes visible, make the definition visible.
3785 if (!MergedDef->isHidden())
3786 Def->setVisibleDespiteOwningModule();
3788 getContext().mergeDefinitionIntoModule(
3789 Def, MergedDef->getImportedOwningModule(),
3790 /*NotifyListeners*/ false);
3791 PendingMergedDefinitionsToDeduplicate.insert(Def);
3796 bool ASTReader::loadGlobalIndex() {
3800 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3801 !PP.getLangOpts().Modules)
3804 // Try to load the global index.
3805 TriedLoadingGlobalIndex = true;
3806 StringRef ModuleCachePath
3807 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3808 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3809 = GlobalModuleIndex::readIndex(ModuleCachePath);
3813 GlobalIndex.reset(Result.first);
3814 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3818 bool ASTReader::isGlobalIndexUnavailable() const {
3819 return PP.getLangOpts().Modules && UseGlobalIndex &&
3820 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3823 static void updateModuleTimestamp(ModuleFile &MF) {
3824 // Overwrite the timestamp file contents so that file's mtime changes.
3825 std::string TimestampFilename = MF.getTimestampFilename();
3827 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3830 OS << "Timestamp file\n";
3832 OS.clear_error(); // Avoid triggering a fatal error.
3835 /// Given a cursor at the start of an AST file, scan ahead and drop the
3836 /// cursor into the start of the given block ID, returning false on success and
3837 /// true on failure.
3838 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3840 llvm::BitstreamEntry Entry = Cursor.advance();
3841 switch (Entry.Kind) {
3842 case llvm::BitstreamEntry::Error:
3843 case llvm::BitstreamEntry::EndBlock:
3846 case llvm::BitstreamEntry::Record:
3847 // Ignore top-level records.
3848 Cursor.skipRecord(Entry.ID);
3851 case llvm::BitstreamEntry::SubBlock:
3852 if (Entry.ID == BlockID) {
3853 if (Cursor.EnterSubBlock(BlockID))
3859 if (Cursor.SkipBlock())
3865 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3867 SourceLocation ImportLoc,
3868 unsigned ClientLoadCapabilities,
3869 SmallVectorImpl<ImportedSubmodule> *Imported) {
3870 llvm::SaveAndRestore<SourceLocation>
3871 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3873 // Defer any pending actions until we get to the end of reading the AST file.
3874 Deserializing AnASTFile(this);
3876 // Bump the generation number.
3877 unsigned PreviousGeneration = 0;
3879 PreviousGeneration = incrementGeneration(*ContextObj);
3881 unsigned NumModules = ModuleMgr.size();
3882 SmallVector<ImportedModule, 4> Loaded;
3883 switch (ASTReadResult ReadResult =
3884 ReadASTCore(FileName, Type, ImportLoc,
3885 /*ImportedBy=*/nullptr, Loaded, 0, 0,
3886 ASTFileSignature(), ClientLoadCapabilities)) {
3890 case VersionMismatch:
3891 case ConfigurationMismatch:
3893 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3894 for (const ImportedModule &IM : Loaded)
3895 LoadedSet.insert(IM.Mod);
3897 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3898 PP.getLangOpts().Modules
3899 ? &PP.getHeaderSearchInfo().getModuleMap()
3902 // If we find that any modules are unusable, the global index is going
3903 // to be out-of-date. Just remove it.
3904 GlobalIndex.reset();
3905 ModuleMgr.setGlobalIndex(nullptr);
3912 // Here comes stuff that we only do once the entire chain is loaded.
3914 // Load the AST blocks of all of the modules that we loaded.
3915 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3916 MEnd = Loaded.end();
3918 ModuleFile &F = *M->Mod;
3920 // Read the AST block.
3921 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3924 // Read the extension blocks.
3925 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3926 if (ASTReadResult Result = ReadExtensionBlock(F))
3930 // Once read, set the ModuleFile bit base offset and update the size in
3931 // bits of all files we've seen.
3932 F.GlobalBitOffset = TotalModulesSizeInBits;
3933 TotalModulesSizeInBits += F.SizeInBits;
3934 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3936 // Preload SLocEntries.
3937 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3938 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3939 // Load it through the SourceManager and don't call ReadSLocEntry()
3940 // directly because the entry may have already been loaded in which case
3941 // calling ReadSLocEntry() directly would trigger an assertion in
3943 SourceMgr.getLoadedSLocEntryByID(Index);
3946 // Map the original source file ID into the ID space of the current
3948 if (F.OriginalSourceFileID.isValid()) {
3949 F.OriginalSourceFileID = FileID::get(
3950 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3953 // Preload all the pending interesting identifiers by marking them out of
3955 for (auto Offset : F.PreloadIdentifierOffsets) {
3956 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3957 F.IdentifierTableData + Offset);
3959 ASTIdentifierLookupTrait Trait(*this, F);
3960 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3961 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3962 auto &II = PP.getIdentifierTable().getOwn(Key);
3963 II.setOutOfDate(true);
3965 // Mark this identifier as being from an AST file so that we can track
3966 // whether we need to serialize it.
3967 markIdentifierFromAST(*this, II);
3969 // Associate the ID with the identifier so that the writer can reuse it.
3970 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3971 SetIdentifierInfo(ID, &II);
3975 // Setup the import locations and notify the module manager that we've
3976 // committed to these module files.
3977 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3978 MEnd = Loaded.end();
3980 ModuleFile &F = *M->Mod;
3982 ModuleMgr.moduleFileAccepted(&F);
3984 // Set the import location.
3985 F.DirectImportLoc = ImportLoc;
3986 // FIXME: We assume that locations from PCH / preamble do not need
3989 F.ImportLoc = M->ImportLoc;
3991 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3994 if (!PP.getLangOpts().CPlusPlus ||
3995 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
3996 Type != MK_PrebuiltModule)) {
3997 // Mark all of the identifiers in the identifier table as being out of date,
3998 // so that various accessors know to check the loaded modules when the
3999 // identifier is used.
4001 // For C++ modules, we don't need information on many identifiers (just
4002 // those that provide macros or are poisoned), so we mark all of
4003 // the interesting ones via PreloadIdentifierOffsets.
4004 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4005 IdEnd = PP.getIdentifierTable().end();
4007 Id->second->setOutOfDate(true);
4009 // Mark selectors as out of date.
4010 for (auto Sel : SelectorGeneration)
4011 SelectorOutOfDate[Sel.first] = true;
4013 // Resolve any unresolved module exports.
4014 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4015 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4016 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4017 Module *ResolvedMod = getSubmodule(GlobalID);
4019 switch (Unresolved.Kind) {
4020 case UnresolvedModuleRef::Conflict:
4022 Module::Conflict Conflict;
4023 Conflict.Other = ResolvedMod;
4024 Conflict.Message = Unresolved.String.str();
4025 Unresolved.Mod->Conflicts.push_back(Conflict);
4029 case UnresolvedModuleRef::Import:
4031 Unresolved.Mod->Imports.insert(ResolvedMod);
4034 case UnresolvedModuleRef::Export:
4035 if (ResolvedMod || Unresolved.IsWildcard)
4036 Unresolved.Mod->Exports.push_back(
4037 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4041 UnresolvedModuleRefs.clear();
4044 Imported->append(ImportedModules.begin(),
4045 ImportedModules.end());
4047 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4048 // Might be unnecessary as use declarations are only used to build the
4052 InitializeContext();
4057 if (DeserializationListener)
4058 DeserializationListener->ReaderInitialized(this);
4060 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4061 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4062 // If this AST file is a precompiled preamble, then set the
4063 // preamble file ID of the source manager to the file source file
4064 // from which the preamble was built.
4065 if (Type == MK_Preamble) {
4066 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4067 } else if (Type == MK_MainFile) {
4068 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4072 // For any Objective-C class definitions we have already loaded, make sure
4073 // that we load any additional categories.
4075 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4076 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4077 ObjCClassesLoaded[I],
4078 PreviousGeneration);
4082 if (PP.getHeaderSearchInfo()
4083 .getHeaderSearchOpts()
4084 .ModulesValidateOncePerBuildSession) {
4085 // Now we are certain that the module and all modules it depends on are
4086 // up to date. Create or update timestamp files for modules that are
4087 // located in the module cache (not for PCH files that could be anywhere
4088 // in the filesystem).
4089 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4090 ImportedModule &M = Loaded[I];
4091 if (M.Mod->Kind == MK_ImplicitModule) {
4092 updateModuleTimestamp(*M.Mod);
4100 static ASTFileSignature readASTFileSignature(StringRef PCH);
4102 /// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4103 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4104 return Stream.canSkipToPos(4) &&
4105 Stream.Read(8) == 'C' &&
4106 Stream.Read(8) == 'P' &&
4107 Stream.Read(8) == 'C' &&
4108 Stream.Read(8) == 'H';
4111 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4115 case MK_ImplicitModule:
4116 case MK_ExplicitModule:
4117 case MK_PrebuiltModule:
4121 return 2; // main source file
4123 llvm_unreachable("unknown module kind");
4126 ASTReader::ASTReadResult
4127 ASTReader::ReadASTCore(StringRef FileName,
4129 SourceLocation ImportLoc,
4130 ModuleFile *ImportedBy,
4131 SmallVectorImpl<ImportedModule> &Loaded,
4132 off_t ExpectedSize, time_t ExpectedModTime,
4133 ASTFileSignature ExpectedSignature,
4134 unsigned ClientLoadCapabilities) {
4136 std::string ErrorStr;
4137 ModuleManager::AddModuleResult AddResult
4138 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4139 getGeneration(), ExpectedSize, ExpectedModTime,
4140 ExpectedSignature, readASTFileSignature,
4143 switch (AddResult) {
4144 case ModuleManager::AlreadyLoaded:
4147 case ModuleManager::NewlyLoaded:
4148 // Load module file below.
4151 case ModuleManager::Missing:
4152 // The module file was missing; if the client can handle that, return
4154 if (ClientLoadCapabilities & ARR_Missing)
4157 // Otherwise, return an error.
4158 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4159 << FileName << !ErrorStr.empty()
4163 case ModuleManager::OutOfDate:
4164 // We couldn't load the module file because it is out-of-date. If the
4165 // client can handle out-of-date, return it.
4166 if (ClientLoadCapabilities & ARR_OutOfDate)
4169 // Otherwise, return an error.
4170 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4171 << FileName << !ErrorStr.empty()
4176 assert(M && "Missing module file");
4179 BitstreamCursor &Stream = F.Stream;
4180 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4181 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4183 // Sniff for the signature.
4184 if (!startsWithASTFileMagic(Stream)) {
4185 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4190 // This is used for compatibility with older PCH formats.
4191 bool HaveReadControlBlock = false;
4193 llvm::BitstreamEntry Entry = Stream.advance();
4195 switch (Entry.Kind) {
4196 case llvm::BitstreamEntry::Error:
4197 case llvm::BitstreamEntry::Record:
4198 case llvm::BitstreamEntry::EndBlock:
4199 Error("invalid record at top-level of AST file");
4202 case llvm::BitstreamEntry::SubBlock:
4207 case CONTROL_BLOCK_ID:
4208 HaveReadControlBlock = true;
4209 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4211 // Check that we didn't try to load a non-module AST file as a module.
4213 // FIXME: Should we also perform the converse check? Loading a module as
4214 // a PCH file sort of works, but it's a bit wonky.
4215 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4216 Type == MK_PrebuiltModule) &&
4217 F.ModuleName.empty()) {
4218 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4219 if (Result != OutOfDate ||
4220 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4221 Diag(diag::err_module_file_not_module) << FileName;
4226 case Failure: return Failure;
4227 case Missing: return Missing;
4228 case OutOfDate: return OutOfDate;
4229 case VersionMismatch: return VersionMismatch;
4230 case ConfigurationMismatch: return ConfigurationMismatch;
4231 case HadErrors: return HadErrors;
4236 if (!HaveReadControlBlock) {
4237 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4238 Diag(diag::err_pch_version_too_old);
4239 return VersionMismatch;
4242 // Record that we've loaded this module.
4243 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4246 case UNHASHED_CONTROL_BLOCK_ID:
4247 // This block is handled using look-ahead during ReadControlBlock. We
4248 // shouldn't get here!
4249 Error("malformed block record in AST file");
4253 if (Stream.SkipBlock()) {
4254 Error("malformed block record in AST file");
4264 ASTReader::ASTReadResult
4265 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4266 unsigned ClientLoadCapabilities) {
4267 const HeaderSearchOptions &HSOpts =
4268 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4269 bool AllowCompatibleConfigurationMismatch =
4270 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4272 ASTReadResult Result = readUnhashedControlBlockImpl(
4273 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4275 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4277 // If F was directly imported by another module, it's implicitly validated by
4278 // the importing module.
4279 if (DisableValidation || WasImportedBy ||
4280 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4283 if (Result == Failure) {
4284 Error("malformed block record in AST file");
4288 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4289 // If this module has already been finalized in the PCMCache, we're stuck
4290 // with it; we can only load a single version of each module.
4292 // This can happen when a module is imported in two contexts: in one, as a
4293 // user module; in another, as a system module (due to an import from
4294 // another module marked with the [system] flag). It usually indicates a
4295 // bug in the module map: this module should also be marked with [system].
4297 // If -Wno-system-headers (the default), and the first import is as a
4298 // system module, then validation will fail during the as-user import,
4299 // since -Werror flags won't have been validated. However, it's reasonable
4300 // to treat this consistently as a system module.
4302 // If -Wsystem-headers, the PCM on disk was built with
4303 // -Wno-system-headers, and the first import is as a user module, then
4304 // validation will fail during the as-system import since the PCM on disk
4305 // doesn't guarantee that -Werror was respected. However, the -Werror
4306 // flags were checked during the initial as-user import.
4307 if (PCMCache.isBufferFinal(F.FileName)) {
4308 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4316 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4317 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4318 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4319 bool ValidateDiagnosticOptions) {
4320 // Initialize a stream.
4321 BitstreamCursor Stream(StreamData);
4323 // Sniff for the signature.
4324 if (!startsWithASTFileMagic(Stream))
4327 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4328 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4331 // Read all of the records in the options block.
4333 ASTReadResult Result = Success;
4335 llvm::BitstreamEntry Entry = Stream.advance();
4337 switch (Entry.Kind) {
4338 case llvm::BitstreamEntry::Error:
4339 case llvm::BitstreamEntry::SubBlock:
4342 case llvm::BitstreamEntry::EndBlock:
4345 case llvm::BitstreamEntry::Record:
4346 // The interesting case.
4350 // Read and process a record.
4353 (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4356 std::copy(Record.begin(), Record.end(), F->Signature.data());
4358 case DIAGNOSTIC_OPTIONS: {
4359 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4360 if (Listener && ValidateDiagnosticOptions &&
4361 !AllowCompatibleConfigurationMismatch &&
4362 ParseDiagnosticOptions(Record, Complain, *Listener))
4363 Result = OutOfDate; // Don't return early. Read the signature.
4366 case DIAG_PRAGMA_MAPPINGS:
4369 if (F->PragmaDiagMappings.empty())
4370 F->PragmaDiagMappings.swap(Record);
4372 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4373 Record.begin(), Record.end());
4379 /// Parse a record and blob containing module file extension metadata.
4380 static bool parseModuleFileExtensionMetadata(
4381 const SmallVectorImpl<uint64_t> &Record,
4383 ModuleFileExtensionMetadata &Metadata) {
4384 if (Record.size() < 4) return true;
4386 Metadata.MajorVersion = Record[0];
4387 Metadata.MinorVersion = Record[1];
4389 unsigned BlockNameLen = Record[2];
4390 unsigned UserInfoLen = Record[3];
4392 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4394 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4395 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4396 Blob.data() + BlockNameLen + UserInfoLen);
4400 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4401 BitstreamCursor &Stream = F.Stream;
4405 llvm::BitstreamEntry Entry = Stream.advance();
4406 switch (Entry.Kind) {
4407 case llvm::BitstreamEntry::SubBlock:
4408 if (Stream.SkipBlock())
4413 case llvm::BitstreamEntry::EndBlock:
4416 case llvm::BitstreamEntry::Error:
4419 case llvm::BitstreamEntry::Record:
4425 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4427 case EXTENSION_METADATA: {
4428 ModuleFileExtensionMetadata Metadata;
4429 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4432 // Find a module file extension with this block name.
4433 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4434 if (Known == ModuleFileExtensions.end()) break;
4437 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4439 F.ExtensionReaders.push_back(std::move(Reader));
4450 void ASTReader::InitializeContext() {
4451 assert(ContextObj && "no context to initialize");
4452 ASTContext &Context = *ContextObj;
4454 // If there's a listener, notify them that we "read" the translation unit.
4455 if (DeserializationListener)
4456 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4457 Context.getTranslationUnitDecl());
4459 // FIXME: Find a better way to deal with collisions between these
4460 // built-in types. Right now, we just ignore the problem.
4462 // Load the special types.
4463 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4464 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4465 if (!Context.CFConstantStringTypeDecl)
4466 Context.setCFConstantStringType(GetType(String));
4469 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4470 QualType FileType = GetType(File);
4471 if (FileType.isNull()) {
4472 Error("FILE type is NULL");
4476 if (!Context.FILEDecl) {
4477 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4478 Context.setFILEDecl(Typedef->getDecl());
4480 const TagType *Tag = FileType->getAs<TagType>();
4482 Error("Invalid FILE type in AST file");
4485 Context.setFILEDecl(Tag->getDecl());
4490 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4491 QualType Jmp_bufType = GetType(Jmp_buf);
4492 if (Jmp_bufType.isNull()) {
4493 Error("jmp_buf type is NULL");
4497 if (!Context.jmp_bufDecl) {
4498 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4499 Context.setjmp_bufDecl(Typedef->getDecl());
4501 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4503 Error("Invalid jmp_buf type in AST file");
4506 Context.setjmp_bufDecl(Tag->getDecl());
4511 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4512 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4513 if (Sigjmp_bufType.isNull()) {
4514 Error("sigjmp_buf type is NULL");
4518 if (!Context.sigjmp_bufDecl) {
4519 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4520 Context.setsigjmp_bufDecl(Typedef->getDecl());
4522 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4523 assert(Tag && "Invalid sigjmp_buf type in AST file");
4524 Context.setsigjmp_bufDecl(Tag->getDecl());
4529 if (unsigned ObjCIdRedef
4530 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4531 if (Context.ObjCIdRedefinitionType.isNull())
4532 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4535 if (unsigned ObjCClassRedef
4536 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4537 if (Context.ObjCClassRedefinitionType.isNull())
4538 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4541 if (unsigned ObjCSelRedef
4542 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4543 if (Context.ObjCSelRedefinitionType.isNull())
4544 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4547 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4548 QualType Ucontext_tType = GetType(Ucontext_t);
4549 if (Ucontext_tType.isNull()) {
4550 Error("ucontext_t type is NULL");
4554 if (!Context.ucontext_tDecl) {
4555 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4556 Context.setucontext_tDecl(Typedef->getDecl());
4558 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4559 assert(Tag && "Invalid ucontext_t type in AST file");
4560 Context.setucontext_tDecl(Tag->getDecl());
4566 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4568 // If there were any CUDA special declarations, deserialize them.
4569 if (!CUDASpecialDeclRefs.empty()) {
4570 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4571 Context.setcudaConfigureCallDecl(
4572 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4575 // Re-export any modules that were imported by a non-module AST file.
4576 // FIXME: This does not make macro-only imports visible again.
4577 for (auto &Import : ImportedModules) {
4578 if (Module *Imported = getSubmodule(Import.ID)) {
4579 makeModuleVisible(Imported, Module::AllVisible,
4580 /*ImportLoc=*/Import.ImportLoc);
4581 if (Import.ImportLoc.isValid())
4582 PP.makeModuleVisible(Imported, Import.ImportLoc);
4583 // FIXME: should we tell Sema to make the module visible too?
4586 ImportedModules.clear();
4589 void ASTReader::finalizeForWriting() {
4590 // Nothing to do for now.
4593 /// Reads and return the signature record from \p PCH's control block, or
4595 static ASTFileSignature readASTFileSignature(StringRef PCH) {
4596 BitstreamCursor Stream(PCH);
4597 if (!startsWithASTFileMagic(Stream))
4598 return ASTFileSignature();
4600 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4601 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4602 return ASTFileSignature();
4604 // Scan for SIGNATURE inside the diagnostic options block.
4605 ASTReader::RecordData Record;
4607 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4608 if (Entry.Kind != llvm::BitstreamEntry::Record)
4609 return ASTFileSignature();
4613 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4614 return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4615 (uint32_t)Record[3], (uint32_t)Record[4]}}};
4619 /// Retrieve the name of the original source file name
4620 /// directly from the AST file, without actually loading the AST
4622 std::string ASTReader::getOriginalSourceFile(
4623 const std::string &ASTFileName, FileManager &FileMgr,
4624 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4625 // Open the AST file.
4626 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4628 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4629 << ASTFileName << Buffer.getError().message();
4630 return std::string();
4633 // Initialize the stream
4634 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4636 // Sniff for the signature.
4637 if (!startsWithASTFileMagic(Stream)) {
4638 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4639 return std::string();
4642 // Scan for the CONTROL_BLOCK_ID block.
4643 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4644 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4645 return std::string();
4648 // Scan for ORIGINAL_FILE inside the control block.
4651 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4652 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4653 return std::string();
4655 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4656 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4657 return std::string();
4662 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4669 class SimplePCHValidator : public ASTReaderListener {
4670 const LangOptions &ExistingLangOpts;
4671 const TargetOptions &ExistingTargetOpts;
4672 const PreprocessorOptions &ExistingPPOpts;
4673 std::string ExistingModuleCachePath;
4674 FileManager &FileMgr;
4677 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4678 const TargetOptions &ExistingTargetOpts,
4679 const PreprocessorOptions &ExistingPPOpts,
4680 StringRef ExistingModuleCachePath,
4681 FileManager &FileMgr)
4682 : ExistingLangOpts(ExistingLangOpts),
4683 ExistingTargetOpts(ExistingTargetOpts),
4684 ExistingPPOpts(ExistingPPOpts),
4685 ExistingModuleCachePath(ExistingModuleCachePath),
4688 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4689 bool AllowCompatibleDifferences) override {
4690 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4691 AllowCompatibleDifferences);
4694 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4695 bool AllowCompatibleDifferences) override {
4696 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4697 AllowCompatibleDifferences);
4700 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4701 StringRef SpecificModuleCachePath,
4702 bool Complain) override {
4703 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4704 ExistingModuleCachePath,
4705 nullptr, ExistingLangOpts);
4708 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4710 std::string &SuggestedPredefines) override {
4711 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4712 SuggestedPredefines, ExistingLangOpts);
4718 bool ASTReader::readASTFileControlBlock(
4719 StringRef Filename, FileManager &FileMgr,
4720 const PCHContainerReader &PCHContainerRdr,
4721 bool FindModuleFileExtensions,
4722 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4723 // Open the AST file.
4724 // FIXME: This allows use of the VFS; we do not allow use of the
4725 // VFS when actually loading a module.
4726 auto Buffer = FileMgr.getBufferForFile(Filename);
4731 // Initialize the stream
4732 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4733 BitstreamCursor Stream(Bytes);
4735 // Sniff for the signature.
4736 if (!startsWithASTFileMagic(Stream))
4739 // Scan for the CONTROL_BLOCK_ID block.
4740 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4743 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4744 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4745 bool NeedsImports = Listener.needsImportVisitation();
4746 BitstreamCursor InputFilesCursor;
4749 std::string ModuleDir;
4750 bool DoneWithControlBlock = false;
4751 while (!DoneWithControlBlock) {
4752 llvm::BitstreamEntry Entry = Stream.advance();
4754 switch (Entry.Kind) {
4755 case llvm::BitstreamEntry::SubBlock: {
4757 case OPTIONS_BLOCK_ID: {
4758 std::string IgnoredSuggestedPredefines;
4759 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4760 /*AllowCompatibleConfigurationMismatch*/ false,
4761 Listener, IgnoredSuggestedPredefines) != Success)
4766 case INPUT_FILES_BLOCK_ID:
4767 InputFilesCursor = Stream;
4768 if (Stream.SkipBlock() ||
4770 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4775 if (Stream.SkipBlock())
4783 case llvm::BitstreamEntry::EndBlock:
4784 DoneWithControlBlock = true;
4787 case llvm::BitstreamEntry::Error:
4790 case llvm::BitstreamEntry::Record:
4794 if (DoneWithControlBlock) break;
4798 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4799 switch ((ControlRecordTypes)RecCode) {
4801 if (Record[0] != VERSION_MAJOR)
4803 if (Listener.ReadFullVersionInformation(Blob))
4807 Listener.ReadModuleName(Blob);
4809 case MODULE_DIRECTORY:
4812 case MODULE_MAP_FILE: {
4814 auto Path = ReadString(Record, Idx);
4815 ResolveImportedPath(Path, ModuleDir);
4816 Listener.ReadModuleMapFile(Path);
4819 case INPUT_FILE_OFFSETS: {
4820 if (!NeedsInputFiles)
4823 unsigned NumInputFiles = Record[0];
4824 unsigned NumUserFiles = Record[1];
4825 const llvm::support::unaligned_uint64_t *InputFileOffs =
4826 (const llvm::support::unaligned_uint64_t *)Blob.data();
4827 for (unsigned I = 0; I != NumInputFiles; ++I) {
4828 // Go find this input file.
4829 bool isSystemFile = I >= NumUserFiles;
4831 if (isSystemFile && !NeedsSystemInputFiles)
4832 break; // the rest are system input files
4834 BitstreamCursor &Cursor = InputFilesCursor;
4835 SavedStreamPosition SavedPosition(Cursor);
4836 Cursor.JumpToBit(InputFileOffs[I]);
4838 unsigned Code = Cursor.ReadCode();
4841 bool shouldContinue = false;
4842 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4844 bool Overridden = static_cast<bool>(Record[3]);
4845 std::string Filename = Blob;
4846 ResolveImportedPath(Filename, ModuleDir);
4847 shouldContinue = Listener.visitInputFile(
4848 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4851 if (!shouldContinue)
4861 unsigned Idx = 0, N = Record.size();
4863 // Read information about the AST file.
4864 Idx += 1+1+1+1+5; // Kind, ImportLoc, Size, ModTime, Signature
4865 std::string ModuleName = ReadString(Record, Idx);
4866 std::string Filename = ReadString(Record, Idx);
4867 ResolveImportedPath(Filename, ModuleDir);
4868 Listener.visitImport(ModuleName, Filename);
4874 // No other validation to perform.
4879 // Look for module file extension blocks, if requested.
4880 if (FindModuleFileExtensions) {
4881 BitstreamCursor SavedStream = Stream;
4882 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4883 bool DoneWithExtensionBlock = false;
4884 while (!DoneWithExtensionBlock) {
4885 llvm::BitstreamEntry Entry = Stream.advance();
4887 switch (Entry.Kind) {
4888 case llvm::BitstreamEntry::SubBlock:
4889 if (Stream.SkipBlock())
4894 case llvm::BitstreamEntry::EndBlock:
4895 DoneWithExtensionBlock = true;
4898 case llvm::BitstreamEntry::Error:
4901 case llvm::BitstreamEntry::Record:
4907 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4909 case EXTENSION_METADATA: {
4910 ModuleFileExtensionMetadata Metadata;
4911 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4914 Listener.readModuleFileExtension(Metadata);
4920 Stream = SavedStream;
4923 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4924 if (readUnhashedControlBlockImpl(
4925 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4926 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4927 ValidateDiagnosticOptions) != Success)
4933 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
4934 const PCHContainerReader &PCHContainerRdr,
4935 const LangOptions &LangOpts,
4936 const TargetOptions &TargetOpts,
4937 const PreprocessorOptions &PPOpts,
4938 StringRef ExistingModuleCachePath) {
4939 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4940 ExistingModuleCachePath, FileMgr);
4941 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4942 /*FindModuleFileExtensions=*/false,
4944 /*ValidateDiagnosticOptions=*/true);
4947 ASTReader::ASTReadResult
4948 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4949 // Enter the submodule block.
4950 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4951 Error("malformed submodule block record in AST file");
4955 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4957 Module *CurrentModule = nullptr;
4960 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4962 switch (Entry.Kind) {
4963 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4964 case llvm::BitstreamEntry::Error:
4965 Error("malformed block record in AST file");
4967 case llvm::BitstreamEntry::EndBlock:
4969 case llvm::BitstreamEntry::Record:
4970 // The interesting case.
4977 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4979 if ((Kind == SUBMODULE_METADATA) != First) {
4980 Error("submodule metadata record should be at beginning of block");
4985 // Submodule information is only valid if we have a current module.
4986 // FIXME: Should we error on these cases?
4987 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4988 Kind != SUBMODULE_DEFINITION)
4992 default: // Default behavior: ignore.
4995 case SUBMODULE_DEFINITION: {
4996 if (Record.size() < 12) {
4997 Error("malformed module definition");
5001 StringRef Name = Blob;
5003 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5004 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5005 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5006 bool IsFramework = Record[Idx++];
5007 bool IsExplicit = Record[Idx++];
5008 bool IsSystem = Record[Idx++];
5009 bool IsExternC = Record[Idx++];
5010 bool InferSubmodules = Record[Idx++];
5011 bool InferExplicitSubmodules = Record[Idx++];
5012 bool InferExportWildcard = Record[Idx++];
5013 bool ConfigMacrosExhaustive = Record[Idx++];
5014 bool ModuleMapIsPrivate = Record[Idx++];
5016 Module *ParentModule = nullptr;
5018 ParentModule = getSubmodule(Parent);
5020 // Retrieve this (sub)module from the module map, creating it if
5023 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5026 // FIXME: set the definition loc for CurrentModule, or call
5027 // ModMap.setInferredModuleAllowedBy()
5029 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5030 if (GlobalIndex >= SubmodulesLoaded.size() ||
5031 SubmodulesLoaded[GlobalIndex]) {
5032 Error("too many submodules");
5036 if (!ParentModule) {
5037 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5038 // Don't emit module relocation error if we have -fno-validate-pch
5039 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5040 CurFile != F.File) {
5041 if (!Diags.isDiagnosticInFlight()) {
5042 Diag(diag::err_module_file_conflict)
5043 << CurrentModule->getTopLevelModuleName()
5044 << CurFile->getName()
5045 << F.File->getName();
5051 CurrentModule->setASTFile(F.File);
5052 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5055 CurrentModule->Kind = Kind;
5056 CurrentModule->Signature = F.Signature;
5057 CurrentModule->IsFromModuleFile = true;
5058 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5059 CurrentModule->IsExternC = IsExternC;
5060 CurrentModule->InferSubmodules = InferSubmodules;
5061 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5062 CurrentModule->InferExportWildcard = InferExportWildcard;
5063 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5064 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5065 if (DeserializationListener)
5066 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5068 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5070 // Clear out data that will be replaced by what is in the module file.
5071 CurrentModule->LinkLibraries.clear();
5072 CurrentModule->ConfigMacros.clear();
5073 CurrentModule->UnresolvedConflicts.clear();
5074 CurrentModule->Conflicts.clear();
5076 // The module is available unless it's missing a requirement; relevant
5077 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5078 // Missing headers that were present when the module was built do not
5079 // make it unavailable -- if we got this far, this must be an explicitly
5080 // imported module file.
5081 CurrentModule->Requirements.clear();
5082 CurrentModule->MissingHeaders.clear();
5083 CurrentModule->IsMissingRequirement =
5084 ParentModule && ParentModule->IsMissingRequirement;
5085 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5089 case SUBMODULE_UMBRELLA_HEADER: {
5090 std::string Filename = Blob;
5091 ResolveImportedPath(F, Filename);
5092 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5093 if (!CurrentModule->getUmbrellaHeader())
5094 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5095 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5096 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5097 Error("mismatched umbrella headers in submodule");
5104 case SUBMODULE_HEADER:
5105 case SUBMODULE_EXCLUDED_HEADER:
5106 case SUBMODULE_PRIVATE_HEADER:
5107 // We lazily associate headers with their modules via the HeaderInfo table.
5108 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5109 // of complete filenames or remove it entirely.
5112 case SUBMODULE_TEXTUAL_HEADER:
5113 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5114 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5118 case SUBMODULE_TOPHEADER:
5119 CurrentModule->addTopHeaderFilename(Blob);
5122 case SUBMODULE_UMBRELLA_DIR: {
5123 std::string Dirname = Blob;
5124 ResolveImportedPath(F, Dirname);
5125 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5126 if (!CurrentModule->getUmbrellaDir())
5127 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5128 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5129 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5130 Error("mismatched umbrella directories in submodule");
5137 case SUBMODULE_METADATA: {
5138 F.BaseSubmoduleID = getTotalNumSubmodules();
5139 F.LocalNumSubmodules = Record[0];
5140 unsigned LocalBaseSubmoduleID = Record[1];
5141 if (F.LocalNumSubmodules > 0) {
5142 // Introduce the global -> local mapping for submodules within this
5144 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5146 // Introduce the local -> global mapping for submodules within this
5148 F.SubmoduleRemap.insertOrReplace(
5149 std::make_pair(LocalBaseSubmoduleID,
5150 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5152 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5157 case SUBMODULE_IMPORTS:
5158 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5159 UnresolvedModuleRef Unresolved;
5160 Unresolved.File = &F;
5161 Unresolved.Mod = CurrentModule;
5162 Unresolved.ID = Record[Idx];
5163 Unresolved.Kind = UnresolvedModuleRef::Import;
5164 Unresolved.IsWildcard = false;
5165 UnresolvedModuleRefs.push_back(Unresolved);
5169 case SUBMODULE_EXPORTS:
5170 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5171 UnresolvedModuleRef Unresolved;
5172 Unresolved.File = &F;
5173 Unresolved.Mod = CurrentModule;
5174 Unresolved.ID = Record[Idx];
5175 Unresolved.Kind = UnresolvedModuleRef::Export;
5176 Unresolved.IsWildcard = Record[Idx + 1];
5177 UnresolvedModuleRefs.push_back(Unresolved);
5180 // Once we've loaded the set of exports, there's no reason to keep
5181 // the parsed, unresolved exports around.
5182 CurrentModule->UnresolvedExports.clear();
5185 case SUBMODULE_REQUIRES:
5186 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5187 PP.getTargetInfo());
5190 case SUBMODULE_LINK_LIBRARY:
5191 ModMap.resolveLinkAsDependencies(CurrentModule);
5192 CurrentModule->LinkLibraries.push_back(
5193 Module::LinkLibrary(Blob, Record[0]));
5196 case SUBMODULE_CONFIG_MACRO:
5197 CurrentModule->ConfigMacros.push_back(Blob.str());
5200 case SUBMODULE_CONFLICT: {
5201 UnresolvedModuleRef Unresolved;
5202 Unresolved.File = &F;
5203 Unresolved.Mod = CurrentModule;
5204 Unresolved.ID = Record[0];
5205 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5206 Unresolved.IsWildcard = false;
5207 Unresolved.String = Blob;
5208 UnresolvedModuleRefs.push_back(Unresolved);
5212 case SUBMODULE_INITIALIZERS: {
5215 SmallVector<uint32_t, 16> Inits;
5216 for (auto &ID : Record)
5217 Inits.push_back(getGlobalDeclID(F, ID));
5218 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5222 case SUBMODULE_EXPORT_AS:
5223 CurrentModule->ExportAsModule = Blob.str();
5224 ModMap.addLinkAsDependency(CurrentModule);
5230 /// Parse the record that corresponds to a LangOptions data
5233 /// This routine parses the language options from the AST file and then gives
5234 /// them to the AST listener if one is set.
5236 /// \returns true if the listener deems the file unacceptable, false otherwise.
5237 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5239 ASTReaderListener &Listener,
5240 bool AllowCompatibleDifferences) {
5241 LangOptions LangOpts;
5243 #define LANGOPT(Name, Bits, Default, Description) \
5244 LangOpts.Name = Record[Idx++];
5245 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5246 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5247 #include "clang/Basic/LangOptions.def"
5248 #define SANITIZER(NAME, ID) \
5249 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5250 #include "clang/Basic/Sanitizers.def"
5252 for (unsigned N = Record[Idx++]; N; --N)
5253 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5255 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5256 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5257 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5259 LangOpts.CurrentModule = ReadString(Record, Idx);
5262 for (unsigned N = Record[Idx++]; N; --N) {
5263 LangOpts.CommentOpts.BlockCommandNames.push_back(
5264 ReadString(Record, Idx));
5266 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5268 // OpenMP offloading options.
5269 for (unsigned N = Record[Idx++]; N; --N) {
5270 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5273 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5275 return Listener.ReadLanguageOptions(LangOpts, Complain,
5276 AllowCompatibleDifferences);
5279 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5280 ASTReaderListener &Listener,
5281 bool AllowCompatibleDifferences) {
5283 TargetOptions TargetOpts;
5284 TargetOpts.Triple = ReadString(Record, Idx);
5285 TargetOpts.CPU = ReadString(Record, Idx);
5286 TargetOpts.ABI = ReadString(Record, Idx);
5287 for (unsigned N = Record[Idx++]; N; --N) {
5288 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5290 for (unsigned N = Record[Idx++]; N; --N) {
5291 TargetOpts.Features.push_back(ReadString(Record, Idx));
5294 return Listener.ReadTargetOptions(TargetOpts, Complain,
5295 AllowCompatibleDifferences);
5298 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5299 ASTReaderListener &Listener) {
5300 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5302 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5303 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5304 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5305 #include "clang/Basic/DiagnosticOptions.def"
5307 for (unsigned N = Record[Idx++]; N; --N)
5308 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5309 for (unsigned N = Record[Idx++]; N; --N)
5310 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5312 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5315 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5316 ASTReaderListener &Listener) {
5317 FileSystemOptions FSOpts;
5319 FSOpts.WorkingDir = ReadString(Record, Idx);
5320 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5323 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5325 ASTReaderListener &Listener) {
5326 HeaderSearchOptions HSOpts;
5328 HSOpts.Sysroot = ReadString(Record, Idx);
5331 for (unsigned N = Record[Idx++]; N; --N) {
5332 std::string Path = ReadString(Record, Idx);
5333 frontend::IncludeDirGroup Group
5334 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5335 bool IsFramework = Record[Idx++];
5336 bool IgnoreSysRoot = Record[Idx++];
5337 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5341 // System header prefixes.
5342 for (unsigned N = Record[Idx++]; N; --N) {
5343 std::string Prefix = ReadString(Record, Idx);
5344 bool IsSystemHeader = Record[Idx++];
5345 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5348 HSOpts.ResourceDir = ReadString(Record, Idx);
5349 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5350 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5351 HSOpts.DisableModuleHash = Record[Idx++];
5352 HSOpts.ImplicitModuleMaps = Record[Idx++];
5353 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5354 HSOpts.UseBuiltinIncludes = Record[Idx++];
5355 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5356 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5357 HSOpts.UseLibcxx = Record[Idx++];
5358 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5360 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5364 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5366 ASTReaderListener &Listener,
5367 std::string &SuggestedPredefines) {
5368 PreprocessorOptions PPOpts;
5371 // Macro definitions/undefs
5372 for (unsigned N = Record[Idx++]; N; --N) {
5373 std::string Macro = ReadString(Record, Idx);
5374 bool IsUndef = Record[Idx++];
5375 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5379 for (unsigned N = Record[Idx++]; N; --N) {
5380 PPOpts.Includes.push_back(ReadString(Record, Idx));
5384 for (unsigned N = Record[Idx++]; N; --N) {
5385 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5388 PPOpts.UsePredefines = Record[Idx++];
5389 PPOpts.DetailedRecord = Record[Idx++];
5390 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5391 PPOpts.ObjCXXARCStandardLibrary =
5392 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5393 SuggestedPredefines.clear();
5394 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5395 SuggestedPredefines);
5398 std::pair<ModuleFile *, unsigned>
5399 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5400 GlobalPreprocessedEntityMapType::iterator
5401 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5402 assert(I != GlobalPreprocessedEntityMap.end() &&
5403 "Corrupted global preprocessed entity map");
5404 ModuleFile *M = I->second;
5405 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5406 return std::make_pair(M, LocalIndex);
5409 llvm::iterator_range<PreprocessingRecord::iterator>
5410 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5411 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5412 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5413 Mod.NumPreprocessedEntities);
5415 return llvm::make_range(PreprocessingRecord::iterator(),
5416 PreprocessingRecord::iterator());
5419 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5420 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5421 return llvm::make_range(
5422 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5423 ModuleDeclIterator(this, &Mod,
5424 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5427 SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5428 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5429 assert(I != GlobalSkippedRangeMap.end() &&
5430 "Corrupted global skipped range map");
5431 ModuleFile *M = I->second;
5432 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5433 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5434 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5435 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5436 TranslateSourceLocation(*M, RawRange.getEnd()));
5437 assert(Range.isValid());
5441 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5442 PreprocessedEntityID PPID = Index+1;
5443 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5444 ModuleFile &M = *PPInfo.first;
5445 unsigned LocalIndex = PPInfo.second;
5446 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5448 if (!PP.getPreprocessingRecord()) {
5449 Error("no preprocessing record");
5453 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5454 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5456 llvm::BitstreamEntry Entry =
5457 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5458 if (Entry.Kind != llvm::BitstreamEntry::Record)
5462 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5463 TranslateSourceLocation(M, PPOffs.getEnd()));
5464 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5467 PreprocessorDetailRecordTypes RecType =
5468 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
5469 Entry.ID, Record, &Blob);
5471 case PPD_MACRO_EXPANSION: {
5472 bool isBuiltin = Record[0];
5473 IdentifierInfo *Name = nullptr;
5474 MacroDefinitionRecord *Def = nullptr;
5476 Name = getLocalIdentifier(M, Record[1]);
5478 PreprocessedEntityID GlobalID =
5479 getGlobalPreprocessedEntityID(M, Record[1]);
5480 Def = cast<MacroDefinitionRecord>(
5481 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5486 ME = new (PPRec) MacroExpansion(Name, Range);
5488 ME = new (PPRec) MacroExpansion(Def, Range);
5493 case PPD_MACRO_DEFINITION: {
5494 // Decode the identifier info and then check again; if the macro is
5495 // still defined and associated with the identifier,
5496 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5497 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5499 if (DeserializationListener)
5500 DeserializationListener->MacroDefinitionRead(PPID, MD);
5505 case PPD_INCLUSION_DIRECTIVE: {
5506 const char *FullFileNameStart = Blob.data() + Record[0];
5507 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5508 const FileEntry *File = nullptr;
5509 if (!FullFileName.empty())
5510 File = PP.getFileManager().getFile(FullFileName);
5512 // FIXME: Stable encoding
5513 InclusionDirective::InclusionKind Kind
5514 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5515 InclusionDirective *ID
5516 = new (PPRec) InclusionDirective(PPRec, Kind,
5517 StringRef(Blob.data(), Record[0]),
5518 Record[1], Record[3],
5525 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5528 /// Find the next module that contains entities and return the ID
5529 /// of the first entry.
5531 /// \param SLocMapI points at a chunk of a module that contains no
5532 /// preprocessed entities or the entities it contains are not the ones we are
5534 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5535 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5537 for (GlobalSLocOffsetMapType::const_iterator
5538 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5539 ModuleFile &M = *SLocMapI->second;
5540 if (M.NumPreprocessedEntities)
5541 return M.BasePreprocessedEntityID;
5544 return getTotalNumPreprocessedEntities();
5549 struct PPEntityComp {
5550 const ASTReader &Reader;
5553 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5555 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5556 SourceLocation LHS = getLoc(L);
5557 SourceLocation RHS = getLoc(R);
5558 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5561 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5562 SourceLocation LHS = getLoc(L);
5563 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5566 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5567 SourceLocation RHS = getLoc(R);
5568 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5571 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5572 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5578 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5579 bool EndsAfter) const {
5580 if (SourceMgr.isLocalSourceLocation(Loc))
5581 return getTotalNumPreprocessedEntities();
5583 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5584 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5585 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5586 "Corrupted global sloc offset map");
5588 if (SLocMapI->second->NumPreprocessedEntities == 0)
5589 return findNextPreprocessedEntity(SLocMapI);
5591 ModuleFile &M = *SLocMapI->second;
5593 using pp_iterator = const PPEntityOffset *;
5595 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5596 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5598 size_t Count = M.NumPreprocessedEntities;
5600 pp_iterator First = pp_begin;
5604 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5605 PPEntityComp(*this, M));
5607 // Do a binary search manually instead of using std::lower_bound because
5608 // The end locations of entities may be unordered (when a macro expansion
5609 // is inside another macro argument), but for this case it is not important
5610 // whether we get the first macro expansion or its containing macro.
5614 std::advance(PPI, Half);
5615 if (SourceMgr.isBeforeInTranslationUnit(
5616 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5619 Count = Count - Half - 1;
5626 return findNextPreprocessedEntity(SLocMapI);
5628 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5631 /// Returns a pair of [Begin, End) indices of preallocated
5632 /// preprocessed entities that \arg Range encompasses.
5633 std::pair<unsigned, unsigned>
5634 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5635 if (Range.isInvalid())
5636 return std::make_pair(0,0);
5637 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5639 PreprocessedEntityID BeginID =
5640 findPreprocessedEntity(Range.getBegin(), false);
5641 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5642 return std::make_pair(BeginID, EndID);
5645 /// Optionally returns true or false if the preallocated preprocessed
5646 /// entity with index \arg Index came from file \arg FID.
5647 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5649 if (FID.isInvalid())
5652 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5653 ModuleFile &M = *PPInfo.first;
5654 unsigned LocalIndex = PPInfo.second;
5655 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5657 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5658 if (Loc.isInvalid())
5661 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5669 /// Visitor used to search for information about a header file.
5670 class HeaderFileInfoVisitor {
5671 const FileEntry *FE;
5672 Optional<HeaderFileInfo> HFI;
5675 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5677 bool operator()(ModuleFile &M) {
5678 HeaderFileInfoLookupTable *Table
5679 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5683 // Look in the on-disk hash table for an entry for this file name.
5684 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5685 if (Pos == Table->end())
5692 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5697 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5698 HeaderFileInfoVisitor Visitor(FE);
5699 ModuleMgr.visit(Visitor);
5700 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5703 return HeaderFileInfo();
5706 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5707 using DiagState = DiagnosticsEngine::DiagState;
5708 SmallVector<DiagState *, 32> DiagStates;
5710 for (ModuleFile &F : ModuleMgr) {
5712 auto &Record = F.PragmaDiagMappings;
5718 auto ReadDiagState =
5719 [&](const DiagState &BasedOn, SourceLocation Loc,
5720 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5721 unsigned BackrefID = Record[Idx++];
5723 return DiagStates[BackrefID - 1];
5725 // A new DiagState was created here.
5726 Diag.DiagStates.push_back(BasedOn);
5727 DiagState *NewState = &Diag.DiagStates.back();
5728 DiagStates.push_back(NewState);
5729 unsigned Size = Record[Idx++];
5730 assert(Idx + Size * 2 <= Record.size() &&
5731 "Invalid data, not enough diag/map pairs");
5733 unsigned DiagID = Record[Idx++];
5734 DiagnosticMapping NewMapping =
5735 DiagnosticMapping::deserialize(Record[Idx++]);
5736 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5739 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5741 // If this mapping was specified as a warning but the severity was
5742 // upgraded due to diagnostic settings, simulate the current diagnostic
5743 // settings (and use a warning).
5744 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5745 NewMapping.setSeverity(diag::Severity::Warning);
5746 NewMapping.setUpgradedFromWarning(false);
5749 Mapping = NewMapping;
5754 // Read the first state.
5755 DiagState *FirstState;
5756 if (F.Kind == MK_ImplicitModule) {
5757 // Implicitly-built modules are reused with different diagnostic
5758 // settings. Use the initial diagnostic state from Diag to simulate this
5759 // compilation's diagnostic settings.
5760 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5761 DiagStates.push_back(FirstState);
5763 // Skip the initial diagnostic state from the serialized module.
5764 assert(Record[1] == 0 &&
5765 "Invalid data, unexpected backref in initial state");
5766 Idx = 3 + Record[2] * 2;
5767 assert(Idx < Record.size() &&
5768 "Invalid data, not enough state change pairs in initial state");
5769 } else if (F.isModule()) {
5770 // For an explicit module, preserve the flags from the module build
5771 // command line (-w, -Weverything, -Werror, ...) along with any explicit
5773 unsigned Flags = Record[Idx++];
5775 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5776 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5777 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5778 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5779 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5780 Initial.ExtBehavior = (diag::Severity)Flags;
5781 FirstState = ReadDiagState(Initial, SourceLocation(), true);
5783 assert(F.OriginalSourceFileID.isValid());
5785 // Set up the root buffer of the module to start with the initial
5786 // diagnostic state of the module itself, to cover files that contain no
5787 // explicit transitions (for which we did not serialize anything).
5788 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5789 .StateTransitions.push_back({FirstState, 0});
5791 // For prefix ASTs, start with whatever the user configured on the
5793 Idx++; // Skip flags.
5794 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5795 SourceLocation(), false);
5798 // Read the state transitions.
5799 unsigned NumLocations = Record[Idx++];
5800 while (NumLocations--) {
5801 assert(Idx < Record.size() &&
5802 "Invalid data, missing pragma diagnostic states");
5803 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5804 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5805 assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
5806 assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5807 unsigned Transitions = Record[Idx++];
5809 // Note that we don't need to set up Parent/ParentOffset here, because
5810 // we won't be changing the diagnostic state within imported FileIDs
5811 // (other than perhaps appending to the main source file, which has no
5813 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5814 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5815 for (unsigned I = 0; I != Transitions; ++I) {
5816 unsigned Offset = Record[Idx++];
5818 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5819 F.StateTransitions.push_back({State, Offset});
5823 // Read the final state.
5824 assert(Idx < Record.size() &&
5825 "Invalid data, missing final pragma diagnostic state");
5826 SourceLocation CurStateLoc =
5827 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5828 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5830 if (!F.isModule()) {
5831 Diag.DiagStatesByLoc.CurDiagState = CurState;
5832 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5834 // Preserve the property that the imaginary root file describes the
5837 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5839 T.push_back({CurState, 0});
5841 T[0].State = CurState;
5844 // Don't try to read these mappings again.
5849 /// Get the correct cursor and offset for loading a type.
5850 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5851 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5852 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5853 ModuleFile *M = I->second;
5854 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5857 /// Read and return the type with the given index..
5859 /// The index is the type ID, shifted and minus the number of predefs. This
5860 /// routine actually reads the record corresponding to the type at the given
5861 /// location. It is a helper routine for GetType, which deals with reading type
5863 QualType ASTReader::readTypeRecord(unsigned Index) {
5864 assert(ContextObj && "reading type with no AST context");
5865 ASTContext &Context = *ContextObj;
5866 RecordLocation Loc = TypeCursorForIndex(Index);
5867 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5869 // Keep track of where we are in the stream, then jump back there
5870 // after reading this type.
5871 SavedStreamPosition SavedPosition(DeclsCursor);
5873 ReadingKindTracker ReadingKind(Read_Type, *this);
5875 // Note that we are loading a type record.
5876 Deserializing AType(this);
5879 DeclsCursor.JumpToBit(Loc.Offset);
5881 unsigned Code = DeclsCursor.ReadCode();
5882 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5883 case TYPE_EXT_QUAL: {
5884 if (Record.size() != 2) {
5885 Error("Incorrect encoding of extended qualifier type");
5888 QualType Base = readType(*Loc.F, Record, Idx);
5889 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5890 return Context.getQualifiedType(Base, Quals);
5893 case TYPE_COMPLEX: {
5894 if (Record.size() != 1) {
5895 Error("Incorrect encoding of complex type");
5898 QualType ElemType = readType(*Loc.F, Record, Idx);
5899 return Context.getComplexType(ElemType);
5902 case TYPE_POINTER: {
5903 if (Record.size() != 1) {
5904 Error("Incorrect encoding of pointer type");
5907 QualType PointeeType = readType(*Loc.F, Record, Idx);
5908 return Context.getPointerType(PointeeType);
5911 case TYPE_DECAYED: {
5912 if (Record.size() != 1) {
5913 Error("Incorrect encoding of decayed type");
5916 QualType OriginalType = readType(*Loc.F, Record, Idx);
5917 QualType DT = Context.getAdjustedParameterType(OriginalType);
5918 if (!isa<DecayedType>(DT))
5919 Error("Decayed type does not decay");
5923 case TYPE_ADJUSTED: {
5924 if (Record.size() != 2) {
5925 Error("Incorrect encoding of adjusted type");
5928 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5929 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5930 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5933 case TYPE_BLOCK_POINTER: {
5934 if (Record.size() != 1) {
5935 Error("Incorrect encoding of block pointer type");
5938 QualType PointeeType = readType(*Loc.F, Record, Idx);
5939 return Context.getBlockPointerType(PointeeType);
5942 case TYPE_LVALUE_REFERENCE: {
5943 if (Record.size() != 2) {
5944 Error("Incorrect encoding of lvalue reference type");
5947 QualType PointeeType = readType(*Loc.F, Record, Idx);
5948 return Context.getLValueReferenceType(PointeeType, Record[1]);
5951 case TYPE_RVALUE_REFERENCE: {
5952 if (Record.size() != 1) {
5953 Error("Incorrect encoding of rvalue reference type");
5956 QualType PointeeType = readType(*Loc.F, Record, Idx);
5957 return Context.getRValueReferenceType(PointeeType);
5960 case TYPE_MEMBER_POINTER: {
5961 if (Record.size() != 2) {
5962 Error("Incorrect encoding of member pointer type");
5965 QualType PointeeType = readType(*Loc.F, Record, Idx);
5966 QualType ClassType = readType(*Loc.F, Record, Idx);
5967 if (PointeeType.isNull() || ClassType.isNull())
5970 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5973 case TYPE_CONSTANT_ARRAY: {
5974 QualType ElementType = readType(*Loc.F, Record, Idx);
5975 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5976 unsigned IndexTypeQuals = Record[2];
5978 llvm::APInt Size = ReadAPInt(Record, Idx);
5979 return Context.getConstantArrayType(ElementType, Size,
5980 ASM, IndexTypeQuals);
5983 case TYPE_INCOMPLETE_ARRAY: {
5984 QualType ElementType = readType(*Loc.F, Record, Idx);
5985 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5986 unsigned IndexTypeQuals = Record[2];
5987 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5990 case TYPE_VARIABLE_ARRAY: {
5991 QualType ElementType = readType(*Loc.F, Record, Idx);
5992 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5993 unsigned IndexTypeQuals = Record[2];
5994 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5995 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5996 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5997 ASM, IndexTypeQuals,
5998 SourceRange(LBLoc, RBLoc));
6002 if (Record.size() != 3) {
6003 Error("incorrect encoding of vector type in AST file");
6007 QualType ElementType = readType(*Loc.F, Record, Idx);
6008 unsigned NumElements = Record[1];
6009 unsigned VecKind = Record[2];
6010 return Context.getVectorType(ElementType, NumElements,
6011 (VectorType::VectorKind)VecKind);
6014 case TYPE_EXT_VECTOR: {
6015 if (Record.size() != 3) {
6016 Error("incorrect encoding of extended vector type in AST file");
6020 QualType ElementType = readType(*Loc.F, Record, Idx);
6021 unsigned NumElements = Record[1];
6022 return Context.getExtVectorType(ElementType, NumElements);
6025 case TYPE_FUNCTION_NO_PROTO: {
6026 if (Record.size() != 8) {
6027 Error("incorrect encoding of no-proto function type");
6030 QualType ResultType = readType(*Loc.F, Record, Idx);
6031 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6032 (CallingConv)Record[4], Record[5], Record[6],
6034 return Context.getFunctionNoProtoType(ResultType, Info);
6037 case TYPE_FUNCTION_PROTO: {
6038 QualType ResultType = readType(*Loc.F, Record, Idx);
6040 FunctionProtoType::ExtProtoInfo EPI;
6041 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
6042 /*hasregparm*/ Record[2],
6043 /*regparm*/ Record[3],
6044 static_cast<CallingConv>(Record[4]),
6045 /*produces*/ Record[5],
6046 /*nocallersavedregs*/ Record[6],
6047 /*nocfcheck*/ Record[7]);
6051 EPI.Variadic = Record[Idx++];
6052 EPI.HasTrailingReturn = Record[Idx++];
6053 EPI.TypeQuals = Qualifiers::fromOpaqueValue(Record[Idx++]);
6054 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
6055 SmallVector<QualType, 8> ExceptionStorage;
6056 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6058 unsigned NumParams = Record[Idx++];
6059 SmallVector<QualType, 16> ParamTypes;
6060 for (unsigned I = 0; I != NumParams; ++I)
6061 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6063 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
6064 if (Idx != Record.size()) {
6065 for (unsigned I = 0; I != NumParams; ++I)
6066 ExtParameterInfos.push_back(
6067 FunctionProtoType::ExtParameterInfo
6068 ::getFromOpaqueValue(Record[Idx++]));
6069 EPI.ExtParameterInfos = ExtParameterInfos.data();
6072 assert(Idx == Record.size());
6074 return Context.getFunctionType(ResultType, ParamTypes, EPI);
6077 case TYPE_UNRESOLVED_USING: {
6079 return Context.getTypeDeclType(
6080 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6083 case TYPE_TYPEDEF: {
6084 if (Record.size() != 2) {
6085 Error("incorrect encoding of typedef type");
6089 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6090 QualType Canonical = readType(*Loc.F, Record, Idx);
6091 if (!Canonical.isNull())
6092 Canonical = Context.getCanonicalType(Canonical);
6093 return Context.getTypedefType(Decl, Canonical);
6096 case TYPE_TYPEOF_EXPR:
6097 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6100 if (Record.size() != 1) {
6101 Error("incorrect encoding of typeof(type) in AST file");
6104 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6105 return Context.getTypeOfType(UnderlyingType);
6108 case TYPE_DECLTYPE: {
6109 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6110 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6113 case TYPE_UNARY_TRANSFORM: {
6114 QualType BaseType = readType(*Loc.F, Record, Idx);
6115 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6116 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
6117 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6121 QualType Deduced = readType(*Loc.F, Record, Idx);
6122 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6123 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6124 return Context.getAutoType(Deduced, Keyword, IsDependent);
6127 case TYPE_DEDUCED_TEMPLATE_SPECIALIZATION: {
6128 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6129 QualType Deduced = readType(*Loc.F, Record, Idx);
6130 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6131 return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6136 if (Record.size() != 2) {
6137 Error("incorrect encoding of record type");
6141 bool IsDependent = Record[Idx++];
6142 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6143 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6144 QualType T = Context.getRecordType(RD);
6145 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6150 if (Record.size() != 2) {
6151 Error("incorrect encoding of enum type");
6155 bool IsDependent = Record[Idx++];
6157 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6158 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6162 case TYPE_ATTRIBUTED: {
6163 if (Record.size() != 3) {
6164 Error("incorrect encoding of attributed type");
6167 QualType modifiedType = readType(*Loc.F, Record, Idx);
6168 QualType equivalentType = readType(*Loc.F, Record, Idx);
6169 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6170 return Context.getAttributedType(kind, modifiedType, equivalentType);
6174 if (Record.size() != 1) {
6175 Error("incorrect encoding of paren type");
6178 QualType InnerType = readType(*Loc.F, Record, Idx);
6179 return Context.getParenType(InnerType);
6182 case TYPE_PACK_EXPANSION: {
6183 if (Record.size() != 2) {
6184 Error("incorrect encoding of pack expansion type");
6187 QualType Pattern = readType(*Loc.F, Record, Idx);
6188 if (Pattern.isNull())
6190 Optional<unsigned> NumExpansions;
6192 NumExpansions = Record[1] - 1;
6193 return Context.getPackExpansionType(Pattern, NumExpansions);
6196 case TYPE_ELABORATED: {
6198 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6199 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6200 QualType NamedType = readType(*Loc.F, Record, Idx);
6201 TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
6202 return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
6205 case TYPE_OBJC_INTERFACE: {
6207 ObjCInterfaceDecl *ItfD
6208 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6209 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6212 case TYPE_OBJC_TYPE_PARAM: {
6214 ObjCTypeParamDecl *Decl
6215 = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6216 unsigned NumProtos = Record[Idx++];
6217 SmallVector<ObjCProtocolDecl*, 4> Protos;
6218 for (unsigned I = 0; I != NumProtos; ++I)
6219 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6220 return Context.getObjCTypeParamType(Decl, Protos);
6223 case TYPE_OBJC_OBJECT: {
6225 QualType Base = readType(*Loc.F, Record, Idx);
6226 unsigned NumTypeArgs = Record[Idx++];
6227 SmallVector<QualType, 4> TypeArgs;
6228 for (unsigned I = 0; I != NumTypeArgs; ++I)
6229 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6230 unsigned NumProtos = Record[Idx++];
6231 SmallVector<ObjCProtocolDecl*, 4> Protos;
6232 for (unsigned I = 0; I != NumProtos; ++I)
6233 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6234 bool IsKindOf = Record[Idx++];
6235 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6238 case TYPE_OBJC_OBJECT_POINTER: {
6240 QualType Pointee = readType(*Loc.F, Record, Idx);
6241 return Context.getObjCObjectPointerType(Pointee);
6244 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
6246 QualType Parm = readType(*Loc.F, Record, Idx);
6247 QualType Replacement = readType(*Loc.F, Record, Idx);
6248 return Context.getSubstTemplateTypeParmType(
6249 cast<TemplateTypeParmType>(Parm),
6250 Context.getCanonicalType(Replacement));
6253 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
6255 QualType Parm = readType(*Loc.F, Record, Idx);
6256 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6257 return Context.getSubstTemplateTypeParmPackType(
6258 cast<TemplateTypeParmType>(Parm),
6262 case TYPE_INJECTED_CLASS_NAME: {
6263 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6264 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6265 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6266 // for AST reading, too much interdependencies.
6267 const Type *T = nullptr;
6268 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6269 if (const Type *Existing = DI->getTypeForDecl()) {
6275 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6276 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6277 DI->setTypeForDecl(T);
6279 return QualType(T, 0);
6282 case TYPE_TEMPLATE_TYPE_PARM: {
6284 unsigned Depth = Record[Idx++];
6285 unsigned Index = Record[Idx++];
6286 bool Pack = Record[Idx++];
6287 TemplateTypeParmDecl *D
6288 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6289 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6292 case TYPE_DEPENDENT_NAME: {
6294 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6295 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6296 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6297 QualType Canon = readType(*Loc.F, Record, Idx);
6298 if (!Canon.isNull())
6299 Canon = Context.getCanonicalType(Canon);
6300 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6303 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
6305 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6306 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6307 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6308 unsigned NumArgs = Record[Idx++];
6309 SmallVector<TemplateArgument, 8> Args;
6310 Args.reserve(NumArgs);
6312 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6313 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6317 case TYPE_DEPENDENT_SIZED_ARRAY: {
6321 QualType ElementType = readType(*Loc.F, Record, Idx);
6322 ArrayType::ArraySizeModifier ASM
6323 = (ArrayType::ArraySizeModifier)Record[Idx++];
6324 unsigned IndexTypeQuals = Record[Idx++];
6326 // DependentSizedArrayType
6327 Expr *NumElts = ReadExpr(*Loc.F);
6328 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6330 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6331 IndexTypeQuals, Brackets);
6334 case TYPE_TEMPLATE_SPECIALIZATION: {
6336 bool IsDependent = Record[Idx++];
6337 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6338 SmallVector<TemplateArgument, 8> Args;
6339 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6340 QualType Underlying = readType(*Loc.F, Record, Idx);
6342 if (Underlying.isNull())
6343 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6345 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6346 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6351 if (Record.size() != 1) {
6352 Error("Incorrect encoding of atomic type");
6355 QualType ValueType = readType(*Loc.F, Record, Idx);
6356 return Context.getAtomicType(ValueType);
6360 if (Record.size() != 2) {
6361 Error("Incorrect encoding of pipe type");
6365 // Reading the pipe element type.
6366 QualType ElementType = readType(*Loc.F, Record, Idx);
6367 unsigned ReadOnly = Record[1];
6368 return Context.getPipeType(ElementType, ReadOnly);
6371 case TYPE_DEPENDENT_SIZED_VECTOR: {
6373 QualType ElementType = readType(*Loc.F, Record, Idx);
6374 Expr *SizeExpr = ReadExpr(*Loc.F);
6375 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6376 unsigned VecKind = Record[Idx];
6378 return Context.getDependentVectorType(ElementType, SizeExpr, AttrLoc,
6379 (VectorType::VectorKind)VecKind);
6382 case TYPE_DEPENDENT_SIZED_EXT_VECTOR: {
6385 // DependentSizedExtVectorType
6386 QualType ElementType = readType(*Loc.F, Record, Idx);
6387 Expr *SizeExpr = ReadExpr(*Loc.F);
6388 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6390 return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6394 case TYPE_DEPENDENT_ADDRESS_SPACE: {
6397 // DependentAddressSpaceType
6398 QualType PointeeType = readType(*Loc.F, Record, Idx);
6399 Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6400 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6402 return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6406 llvm_unreachable("Invalid TypeCode!");
6409 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6410 SmallVectorImpl<QualType> &Exceptions,
6411 FunctionProtoType::ExceptionSpecInfo &ESI,
6412 const RecordData &Record, unsigned &Idx) {
6413 ExceptionSpecificationType EST =
6414 static_cast<ExceptionSpecificationType>(Record[Idx++]);
6416 if (EST == EST_Dynamic) {
6417 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6418 Exceptions.push_back(readType(ModuleFile, Record, Idx));
6419 ESI.Exceptions = Exceptions;
6420 } else if (isComputedNoexcept(EST)) {
6421 ESI.NoexceptExpr = ReadExpr(ModuleFile);
6422 } else if (EST == EST_Uninstantiated) {
6423 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6424 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6425 } else if (EST == EST_Unevaluated) {
6426 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6432 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6435 const ASTReader::RecordData &Record;
6438 SourceLocation ReadSourceLocation() {
6439 return Reader->ReadSourceLocation(*F, Record, Idx);
6442 TypeSourceInfo *GetTypeSourceInfo() {
6443 return Reader->GetTypeSourceInfo(*F, Record, Idx);
6446 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6447 return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6451 return Reader->ReadAttr(*F, Record, Idx);
6455 TypeLocReader(ModuleFile &F, ASTReader &Reader,
6456 const ASTReader::RecordData &Record, unsigned &Idx)
6457 : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6459 // We want compile-time assurance that we've enumerated all of
6460 // these, so unfortunately we have to declare them first, then
6461 // define them out-of-line.
6462 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6463 #define TYPELOC(CLASS, PARENT) \
6464 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6465 #include "clang/AST/TypeLocNodes.def"
6467 void VisitFunctionTypeLoc(FunctionTypeLoc);
6468 void VisitArrayTypeLoc(ArrayTypeLoc);
6471 } // namespace clang
6473 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6477 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6478 TL.setBuiltinLoc(ReadSourceLocation());
6479 if (TL.needsExtraLocalData()) {
6480 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6481 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6482 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6483 TL.setModeAttr(Record[Idx++]);
6487 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6488 TL.setNameLoc(ReadSourceLocation());
6491 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6492 TL.setStarLoc(ReadSourceLocation());
6495 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6499 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6503 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6504 TL.setCaretLoc(ReadSourceLocation());
6507 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6508 TL.setAmpLoc(ReadSourceLocation());
6511 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6512 TL.setAmpAmpLoc(ReadSourceLocation());
6515 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6516 TL.setStarLoc(ReadSourceLocation());
6517 TL.setClassTInfo(GetTypeSourceInfo());
6520 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6521 TL.setLBracketLoc(ReadSourceLocation());
6522 TL.setRBracketLoc(ReadSourceLocation());
6524 TL.setSizeExpr(Reader->ReadExpr(*F));
6526 TL.setSizeExpr(nullptr);
6529 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6530 VisitArrayTypeLoc(TL);
6533 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6534 VisitArrayTypeLoc(TL);
6537 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6538 VisitArrayTypeLoc(TL);
6541 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6542 DependentSizedArrayTypeLoc TL) {
6543 VisitArrayTypeLoc(TL);
6546 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6547 DependentAddressSpaceTypeLoc TL) {
6549 TL.setAttrNameLoc(ReadSourceLocation());
6551 range.setBegin(ReadSourceLocation());
6552 range.setEnd(ReadSourceLocation());
6553 TL.setAttrOperandParensRange(range);
6554 TL.setAttrExprOperand(Reader->ReadExpr(*F));
6557 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6558 DependentSizedExtVectorTypeLoc TL) {
6559 TL.setNameLoc(ReadSourceLocation());
6562 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6563 TL.setNameLoc(ReadSourceLocation());
6566 void TypeLocReader::VisitDependentVectorTypeLoc(
6567 DependentVectorTypeLoc TL) {
6568 TL.setNameLoc(ReadSourceLocation());
6571 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6572 TL.setNameLoc(ReadSourceLocation());
6575 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6576 TL.setLocalRangeBegin(ReadSourceLocation());
6577 TL.setLParenLoc(ReadSourceLocation());
6578 TL.setRParenLoc(ReadSourceLocation());
6579 TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6580 Reader->ReadSourceLocation(*F, Record, Idx)));
6581 TL.setLocalRangeEnd(ReadSourceLocation());
6582 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6583 TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6587 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6588 VisitFunctionTypeLoc(TL);
6591 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6592 VisitFunctionTypeLoc(TL);
6595 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6596 TL.setNameLoc(ReadSourceLocation());
6599 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6600 TL.setNameLoc(ReadSourceLocation());
6603 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6604 TL.setTypeofLoc(ReadSourceLocation());
6605 TL.setLParenLoc(ReadSourceLocation());
6606 TL.setRParenLoc(ReadSourceLocation());
6609 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6610 TL.setTypeofLoc(ReadSourceLocation());
6611 TL.setLParenLoc(ReadSourceLocation());
6612 TL.setRParenLoc(ReadSourceLocation());
6613 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6616 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6617 TL.setNameLoc(ReadSourceLocation());
6620 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6621 TL.setKWLoc(ReadSourceLocation());
6622 TL.setLParenLoc(ReadSourceLocation());
6623 TL.setRParenLoc(ReadSourceLocation());
6624 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6627 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6628 TL.setNameLoc(ReadSourceLocation());
6631 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6632 DeducedTemplateSpecializationTypeLoc TL) {
6633 TL.setTemplateNameLoc(ReadSourceLocation());
6636 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6637 TL.setNameLoc(ReadSourceLocation());
6640 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6641 TL.setNameLoc(ReadSourceLocation());
6644 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6645 TL.setAttr(ReadAttr());
6648 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6649 TL.setNameLoc(ReadSourceLocation());
6652 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6653 SubstTemplateTypeParmTypeLoc TL) {
6654 TL.setNameLoc(ReadSourceLocation());
6657 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6658 SubstTemplateTypeParmPackTypeLoc TL) {
6659 TL.setNameLoc(ReadSourceLocation());
6662 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6663 TemplateSpecializationTypeLoc TL) {
6664 TL.setTemplateKeywordLoc(ReadSourceLocation());
6665 TL.setTemplateNameLoc(ReadSourceLocation());
6666 TL.setLAngleLoc(ReadSourceLocation());
6667 TL.setRAngleLoc(ReadSourceLocation());
6668 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6671 Reader->GetTemplateArgumentLocInfo(
6672 *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6675 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6676 TL.setLParenLoc(ReadSourceLocation());
6677 TL.setRParenLoc(ReadSourceLocation());
6680 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6681 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6682 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6685 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6686 TL.setNameLoc(ReadSourceLocation());
6689 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6690 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6691 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6692 TL.setNameLoc(ReadSourceLocation());
6695 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6696 DependentTemplateSpecializationTypeLoc TL) {
6697 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6698 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6699 TL.setTemplateKeywordLoc(ReadSourceLocation());
6700 TL.setTemplateNameLoc(ReadSourceLocation());
6701 TL.setLAngleLoc(ReadSourceLocation());
6702 TL.setRAngleLoc(ReadSourceLocation());
6703 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6706 Reader->GetTemplateArgumentLocInfo(
6707 *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6710 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6711 TL.setEllipsisLoc(ReadSourceLocation());
6714 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6715 TL.setNameLoc(ReadSourceLocation());
6718 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6719 if (TL.getNumProtocols()) {
6720 TL.setProtocolLAngleLoc(ReadSourceLocation());
6721 TL.setProtocolRAngleLoc(ReadSourceLocation());
6723 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6724 TL.setProtocolLoc(i, ReadSourceLocation());
6727 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6728 TL.setHasBaseTypeAsWritten(Record[Idx++]);
6729 TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6730 TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6731 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6732 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6733 TL.setProtocolLAngleLoc(ReadSourceLocation());
6734 TL.setProtocolRAngleLoc(ReadSourceLocation());
6735 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6736 TL.setProtocolLoc(i, ReadSourceLocation());
6739 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6740 TL.setStarLoc(ReadSourceLocation());
6743 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6744 TL.setKWLoc(ReadSourceLocation());
6745 TL.setLParenLoc(ReadSourceLocation());
6746 TL.setRParenLoc(ReadSourceLocation());
6749 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6750 TL.setKWLoc(ReadSourceLocation());
6753 void ASTReader::ReadTypeLoc(ModuleFile &F, const ASTReader::RecordData &Record,
6754 unsigned &Idx, TypeLoc TL) {
6755 TypeLocReader TLR(F, *this, Record, Idx);
6756 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6761 ASTReader::GetTypeSourceInfo(ModuleFile &F, const ASTReader::RecordData &Record,
6763 QualType InfoTy = readType(F, Record, Idx);
6764 if (InfoTy.isNull())
6767 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6768 ReadTypeLoc(F, Record, Idx, TInfo->getTypeLoc());
6772 QualType ASTReader::GetType(TypeID ID) {
6773 assert(ContextObj && "reading type with no AST context");
6774 ASTContext &Context = *ContextObj;
6776 unsigned FastQuals = ID & Qualifiers::FastMask;
6777 unsigned Index = ID >> Qualifiers::FastWidth;
6779 if (Index < NUM_PREDEF_TYPE_IDS) {
6781 switch ((PredefinedTypeIDs)Index) {
6782 case PREDEF_TYPE_NULL_ID:
6784 case PREDEF_TYPE_VOID_ID:
6787 case PREDEF_TYPE_BOOL_ID:
6790 case PREDEF_TYPE_CHAR_U_ID:
6791 case PREDEF_TYPE_CHAR_S_ID:
6792 // FIXME: Check that the signedness of CharTy is correct!
6795 case PREDEF_TYPE_UCHAR_ID:
6796 T = Context.UnsignedCharTy;
6798 case PREDEF_TYPE_USHORT_ID:
6799 T = Context.UnsignedShortTy;
6801 case PREDEF_TYPE_UINT_ID:
6802 T = Context.UnsignedIntTy;
6804 case PREDEF_TYPE_ULONG_ID:
6805 T = Context.UnsignedLongTy;
6807 case PREDEF_TYPE_ULONGLONG_ID:
6808 T = Context.UnsignedLongLongTy;
6810 case PREDEF_TYPE_UINT128_ID:
6811 T = Context.UnsignedInt128Ty;
6813 case PREDEF_TYPE_SCHAR_ID:
6814 T = Context.SignedCharTy;
6816 case PREDEF_TYPE_WCHAR_ID:
6817 T = Context.WCharTy;
6819 case PREDEF_TYPE_SHORT_ID:
6820 T = Context.ShortTy;
6822 case PREDEF_TYPE_INT_ID:
6825 case PREDEF_TYPE_LONG_ID:
6828 case PREDEF_TYPE_LONGLONG_ID:
6829 T = Context.LongLongTy;
6831 case PREDEF_TYPE_INT128_ID:
6832 T = Context.Int128Ty;
6834 case PREDEF_TYPE_HALF_ID:
6837 case PREDEF_TYPE_FLOAT_ID:
6838 T = Context.FloatTy;
6840 case PREDEF_TYPE_DOUBLE_ID:
6841 T = Context.DoubleTy;
6843 case PREDEF_TYPE_LONGDOUBLE_ID:
6844 T = Context.LongDoubleTy;
6846 case PREDEF_TYPE_SHORT_ACCUM_ID:
6847 T = Context.ShortAccumTy;
6849 case PREDEF_TYPE_ACCUM_ID:
6850 T = Context.AccumTy;
6852 case PREDEF_TYPE_LONG_ACCUM_ID:
6853 T = Context.LongAccumTy;
6855 case PREDEF_TYPE_USHORT_ACCUM_ID:
6856 T = Context.UnsignedShortAccumTy;
6858 case PREDEF_TYPE_UACCUM_ID:
6859 T = Context.UnsignedAccumTy;
6861 case PREDEF_TYPE_ULONG_ACCUM_ID:
6862 T = Context.UnsignedLongAccumTy;
6864 case PREDEF_TYPE_SHORT_FRACT_ID:
6865 T = Context.ShortFractTy;
6867 case PREDEF_TYPE_FRACT_ID:
6868 T = Context.FractTy;
6870 case PREDEF_TYPE_LONG_FRACT_ID:
6871 T = Context.LongFractTy;
6873 case PREDEF_TYPE_USHORT_FRACT_ID:
6874 T = Context.UnsignedShortFractTy;
6876 case PREDEF_TYPE_UFRACT_ID:
6877 T = Context.UnsignedFractTy;
6879 case PREDEF_TYPE_ULONG_FRACT_ID:
6880 T = Context.UnsignedLongFractTy;
6882 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6883 T = Context.SatShortAccumTy;
6885 case PREDEF_TYPE_SAT_ACCUM_ID:
6886 T = Context.SatAccumTy;
6888 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6889 T = Context.SatLongAccumTy;
6891 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6892 T = Context.SatUnsignedShortAccumTy;
6894 case PREDEF_TYPE_SAT_UACCUM_ID:
6895 T = Context.SatUnsignedAccumTy;
6897 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6898 T = Context.SatUnsignedLongAccumTy;
6900 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6901 T = Context.SatShortFractTy;
6903 case PREDEF_TYPE_SAT_FRACT_ID:
6904 T = Context.SatFractTy;
6906 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6907 T = Context.SatLongFractTy;
6909 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6910 T = Context.SatUnsignedShortFractTy;
6912 case PREDEF_TYPE_SAT_UFRACT_ID:
6913 T = Context.SatUnsignedFractTy;
6915 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6916 T = Context.SatUnsignedLongFractTy;
6918 case PREDEF_TYPE_FLOAT16_ID:
6919 T = Context.Float16Ty;
6921 case PREDEF_TYPE_FLOAT128_ID:
6922 T = Context.Float128Ty;
6924 case PREDEF_TYPE_OVERLOAD_ID:
6925 T = Context.OverloadTy;
6927 case PREDEF_TYPE_BOUND_MEMBER:
6928 T = Context.BoundMemberTy;
6930 case PREDEF_TYPE_PSEUDO_OBJECT:
6931 T = Context.PseudoObjectTy;
6933 case PREDEF_TYPE_DEPENDENT_ID:
6934 T = Context.DependentTy;
6936 case PREDEF_TYPE_UNKNOWN_ANY:
6937 T = Context.UnknownAnyTy;
6939 case PREDEF_TYPE_NULLPTR_ID:
6940 T = Context.NullPtrTy;
6942 case PREDEF_TYPE_CHAR8_ID:
6943 T = Context.Char8Ty;
6945 case PREDEF_TYPE_CHAR16_ID:
6946 T = Context.Char16Ty;
6948 case PREDEF_TYPE_CHAR32_ID:
6949 T = Context.Char32Ty;
6951 case PREDEF_TYPE_OBJC_ID:
6952 T = Context.ObjCBuiltinIdTy;
6954 case PREDEF_TYPE_OBJC_CLASS:
6955 T = Context.ObjCBuiltinClassTy;
6957 case PREDEF_TYPE_OBJC_SEL:
6958 T = Context.ObjCBuiltinSelTy;
6960 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6961 case PREDEF_TYPE_##Id##_ID: \
6962 T = Context.SingletonId; \
6964 #include "clang/Basic/OpenCLImageTypes.def"
6965 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6966 case PREDEF_TYPE_##Id##_ID: \
6967 T = Context.Id##Ty; \
6969 #include "clang/Basic/OpenCLExtensionTypes.def"
6970 case PREDEF_TYPE_SAMPLER_ID:
6971 T = Context.OCLSamplerTy;
6973 case PREDEF_TYPE_EVENT_ID:
6974 T = Context.OCLEventTy;
6976 case PREDEF_TYPE_CLK_EVENT_ID:
6977 T = Context.OCLClkEventTy;
6979 case PREDEF_TYPE_QUEUE_ID:
6980 T = Context.OCLQueueTy;
6982 case PREDEF_TYPE_RESERVE_ID_ID:
6983 T = Context.OCLReserveIDTy;
6985 case PREDEF_TYPE_AUTO_DEDUCT:
6986 T = Context.getAutoDeductType();
6988 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
6989 T = Context.getAutoRRefDeductType();
6991 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
6992 T = Context.ARCUnbridgedCastTy;
6994 case PREDEF_TYPE_BUILTIN_FN:
6995 T = Context.BuiltinFnTy;
6997 case PREDEF_TYPE_OMP_ARRAY_SECTION:
6998 T = Context.OMPArraySectionTy;
7002 assert(!T.isNull() && "Unknown predefined type");
7003 return T.withFastQualifiers(FastQuals);
7006 Index -= NUM_PREDEF_TYPE_IDS;
7007 assert(Index < TypesLoaded.size() && "Type index out-of-range");
7008 if (TypesLoaded[Index].isNull()) {
7009 TypesLoaded[Index] = readTypeRecord(Index);
7010 if (TypesLoaded[Index].isNull())
7013 TypesLoaded[Index]->setFromAST();
7014 if (DeserializationListener)
7015 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7016 TypesLoaded[Index]);
7019 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7022 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7023 return GetType(getGlobalTypeID(F, LocalID));
7026 serialization::TypeID
7027 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7028 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7029 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7031 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7034 if (!F.ModuleOffsetMap.empty())
7035 ReadModuleOffsetMap(F);
7037 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7038 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7039 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7041 unsigned GlobalIndex = LocalIndex + I->second;
7042 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7045 TemplateArgumentLocInfo
7046 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
7047 TemplateArgument::ArgKind Kind,
7048 const RecordData &Record,
7051 case TemplateArgument::Expression:
7053 case TemplateArgument::Type:
7054 return GetTypeSourceInfo(F, Record, Index);
7055 case TemplateArgument::Template: {
7056 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7058 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7059 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7062 case TemplateArgument::TemplateExpansion: {
7063 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7065 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7066 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
7067 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7070 case TemplateArgument::Null:
7071 case TemplateArgument::Integral:
7072 case TemplateArgument::Declaration:
7073 case TemplateArgument::NullPtr:
7074 case TemplateArgument::Pack:
7075 // FIXME: Is this right?
7076 return TemplateArgumentLocInfo();
7078 llvm_unreachable("unexpected template argument loc");
7082 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
7083 const RecordData &Record, unsigned &Index) {
7084 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7086 if (Arg.getKind() == TemplateArgument::Expression) {
7087 if (Record[Index++]) // bool InfoHasSameExpr.
7088 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7090 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
7094 const ASTTemplateArgumentListInfo*
7095 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
7096 const RecordData &Record,
7098 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
7099 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
7100 unsigned NumArgsAsWritten = Record[Index++];
7101 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7102 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7103 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
7104 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7107 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7111 void ASTReader::CompleteRedeclChain(const Decl *D) {
7112 if (NumCurrentElementsDeserializing) {
7113 // We arrange to not care about the complete redeclaration chain while we're
7114 // deserializing. Just remember that the AST has marked this one as complete
7115 // but that it's not actually complete yet, so we know we still need to
7116 // complete it later.
7117 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7121 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7123 // If this is a named declaration, complete it by looking it up
7124 // within its context.
7126 // FIXME: Merging a function definition should merge
7127 // all mergeable entities within it.
7128 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7129 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7130 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7131 if (!getContext().getLangOpts().CPlusPlus &&
7132 isa<TranslationUnitDecl>(DC)) {
7133 // Outside of C++, we don't have a lookup table for the TU, so update
7134 // the identifier instead. (For C++ modules, we don't store decls
7135 // in the serialized identifier table, so we do the lookup in the TU.)
7136 auto *II = Name.getAsIdentifierInfo();
7137 assert(II && "non-identifier name in C?");
7138 if (II->isOutOfDate())
7139 updateOutOfDateIdentifier(*II);
7142 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7143 // Find all declarations of this kind from the relevant context.
7144 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7145 auto *DC = cast<DeclContext>(DCDecl);
7146 SmallVector<Decl*, 8> Decls;
7147 FindExternalLexicalDecls(
7148 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7153 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7154 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7155 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7156 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7157 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7158 if (auto *Template = FD->getPrimaryTemplate())
7159 Template->LoadLazySpecializations();
7163 CXXCtorInitializer **
7164 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7165 RecordLocation Loc = getLocalBitOffset(Offset);
7166 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7167 SavedStreamPosition SavedPosition(Cursor);
7168 Cursor.JumpToBit(Loc.Offset);
7169 ReadingKindTracker ReadingKind(Read_Decl, *this);
7172 unsigned Code = Cursor.ReadCode();
7173 unsigned RecCode = Cursor.readRecord(Code, Record);
7174 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7175 Error("malformed AST file: missing C++ ctor initializers");
7180 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7183 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7184 assert(ContextObj && "reading base specifiers with no AST context");
7185 ASTContext &Context = *ContextObj;
7187 RecordLocation Loc = getLocalBitOffset(Offset);
7188 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7189 SavedStreamPosition SavedPosition(Cursor);
7190 Cursor.JumpToBit(Loc.Offset);
7191 ReadingKindTracker ReadingKind(Read_Decl, *this);
7193 unsigned Code = Cursor.ReadCode();
7194 unsigned RecCode = Cursor.readRecord(Code, Record);
7195 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7196 Error("malformed AST file: missing C++ base specifiers");
7201 unsigned NumBases = Record[Idx++];
7202 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7203 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7204 for (unsigned I = 0; I != NumBases; ++I)
7205 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7209 serialization::DeclID
7210 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7211 if (LocalID < NUM_PREDEF_DECL_IDS)
7214 if (!F.ModuleOffsetMap.empty())
7215 ReadModuleOffsetMap(F);
7217 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7218 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7219 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7221 return LocalID + I->second;
7224 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7225 ModuleFile &M) const {
7226 // Predefined decls aren't from any module.
7227 if (ID < NUM_PREDEF_DECL_IDS)
7230 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7231 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7234 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7235 if (!D->isFromASTFile())
7237 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7238 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7242 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7243 if (ID < NUM_PREDEF_DECL_IDS)
7244 return SourceLocation();
7246 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7248 if (Index > DeclsLoaded.size()) {
7249 Error("declaration ID out-of-range for AST file");
7250 return SourceLocation();
7253 if (Decl *D = DeclsLoaded[Index])
7254 return D->getLocation();
7257 DeclCursorForID(ID, Loc);
7261 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7263 case PREDEF_DECL_NULL_ID:
7266 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7267 return Context.getTranslationUnitDecl();
7269 case PREDEF_DECL_OBJC_ID_ID:
7270 return Context.getObjCIdDecl();
7272 case PREDEF_DECL_OBJC_SEL_ID:
7273 return Context.getObjCSelDecl();
7275 case PREDEF_DECL_OBJC_CLASS_ID:
7276 return Context.getObjCClassDecl();
7278 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7279 return Context.getObjCProtocolDecl();
7281 case PREDEF_DECL_INT_128_ID:
7282 return Context.getInt128Decl();
7284 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7285 return Context.getUInt128Decl();
7287 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7288 return Context.getObjCInstanceTypeDecl();
7290 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7291 return Context.getBuiltinVaListDecl();
7293 case PREDEF_DECL_VA_LIST_TAG:
7294 return Context.getVaListTagDecl();
7296 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7297 return Context.getBuiltinMSVaListDecl();
7299 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7300 return Context.getExternCContextDecl();
7302 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7303 return Context.getMakeIntegerSeqDecl();
7305 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7306 return Context.getCFConstantStringDecl();
7308 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7309 return Context.getCFConstantStringTagDecl();
7311 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7312 return Context.getTypePackElementDecl();
7314 llvm_unreachable("PredefinedDeclIDs unknown enum value");
7317 Decl *ASTReader::GetExistingDecl(DeclID ID) {
7318 assert(ContextObj && "reading decl with no AST context");
7319 if (ID < NUM_PREDEF_DECL_IDS) {
7320 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7322 // Track that we have merged the declaration with ID \p ID into the
7323 // pre-existing predefined declaration \p D.
7324 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7326 Merged.push_back(ID);
7331 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7333 if (Index >= DeclsLoaded.size()) {
7334 assert(0 && "declaration ID out-of-range for AST file");
7335 Error("declaration ID out-of-range for AST file");
7339 return DeclsLoaded[Index];
7342 Decl *ASTReader::GetDecl(DeclID ID) {
7343 if (ID < NUM_PREDEF_DECL_IDS)
7344 return GetExistingDecl(ID);
7346 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7348 if (Index >= DeclsLoaded.size()) {
7349 assert(0 && "declaration ID out-of-range for AST file");
7350 Error("declaration ID out-of-range for AST file");
7354 if (!DeclsLoaded[Index]) {
7356 if (DeserializationListener)
7357 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7360 return DeclsLoaded[Index];
7363 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7365 if (GlobalID < NUM_PREDEF_DECL_IDS)
7368 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7369 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7370 ModuleFile *Owner = I->second;
7372 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7373 = M.GlobalToLocalDeclIDs.find(Owner);
7374 if (Pos == M.GlobalToLocalDeclIDs.end())
7377 return GlobalID - Owner->BaseDeclID + Pos->second;
7380 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7381 const RecordData &Record,
7383 if (Idx >= Record.size()) {
7384 Error("Corrupted AST file");
7388 return getGlobalDeclID(F, Record[Idx++]);
7391 /// Resolve the offset of a statement into a statement.
7393 /// This operation will read a new statement from the external
7394 /// source each time it is called, and is meant to be used via a
7395 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7396 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7397 // Switch case IDs are per Decl.
7398 ClearSwitchCaseIDs();
7400 // Offset here is a global offset across the entire chain.
7401 RecordLocation Loc = getLocalBitOffset(Offset);
7402 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7403 assert(NumCurrentElementsDeserializing == 0 &&
7404 "should not be called while already deserializing");
7405 Deserializing D(this);
7406 return ReadStmtFromStream(*Loc.F);
7409 void ASTReader::FindExternalLexicalDecls(
7410 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7411 SmallVectorImpl<Decl *> &Decls) {
7412 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7414 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7415 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7416 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7417 auto K = (Decl::Kind)+LexicalDecls[I];
7418 if (!IsKindWeWant(K))
7421 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7423 // Don't add predefined declarations to the lexical context more
7425 if (ID < NUM_PREDEF_DECL_IDS) {
7426 if (PredefsVisited[ID])
7429 PredefsVisited[ID] = true;
7432 if (Decl *D = GetLocalDecl(*M, ID)) {
7433 assert(D->getKind() == K && "wrong kind for lexical decl");
7434 if (!DC->isDeclInLexicalTraversal(D))
7440 if (isa<TranslationUnitDecl>(DC)) {
7441 for (auto Lexical : TULexicalDecls)
7442 Visit(Lexical.first, Lexical.second);
7444 auto I = LexicalDecls.find(DC);
7445 if (I != LexicalDecls.end())
7446 Visit(I->second.first, I->second.second);
7449 ++NumLexicalDeclContextsRead;
7459 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7461 bool operator()(LocalDeclID L, LocalDeclID R) const {
7462 SourceLocation LHS = getLocation(L);
7463 SourceLocation RHS = getLocation(R);
7464 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7467 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7468 SourceLocation RHS = getLocation(R);
7469 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7472 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7473 SourceLocation LHS = getLocation(L);
7474 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7477 SourceLocation getLocation(LocalDeclID ID) const {
7478 return Reader.getSourceManager().getFileLoc(
7479 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7485 void ASTReader::FindFileRegionDecls(FileID File,
7486 unsigned Offset, unsigned Length,
7487 SmallVectorImpl<Decl *> &Decls) {
7488 SourceManager &SM = getSourceManager();
7490 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7491 if (I == FileDeclIDs.end())
7494 FileDeclsInfo &DInfo = I->second;
7495 if (DInfo.Decls.empty())
7499 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7500 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7502 DeclIDComp DIDComp(*this, *DInfo.Mod);
7503 ArrayRef<serialization::LocalDeclID>::iterator
7504 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7506 if (BeginIt != DInfo.Decls.begin())
7509 // If we are pointing at a top-level decl inside an objc container, we need
7510 // to backtrack until we find it otherwise we will fail to report that the
7511 // region overlaps with an objc container.
7512 while (BeginIt != DInfo.Decls.begin() &&
7513 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7514 ->isTopLevelDeclInObjCContainer())
7517 ArrayRef<serialization::LocalDeclID>::iterator
7518 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7520 if (EndIt != DInfo.Decls.end())
7523 for (ArrayRef<serialization::LocalDeclID>::iterator
7524 DIt = BeginIt; DIt != EndIt; ++DIt)
7525 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7529 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7530 DeclarationName Name) {
7531 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7532 "DeclContext has no visible decls in storage");
7536 auto It = Lookups.find(DC);
7537 if (It == Lookups.end())
7540 Deserializing LookupResults(this);
7542 // Load the list of declarations.
7543 SmallVector<NamedDecl *, 64> Decls;
7544 for (DeclID ID : It->second.Table.find(Name)) {
7545 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7546 if (ND->getDeclName() == Name)
7547 Decls.push_back(ND);
7550 ++NumVisibleDeclContextsRead;
7551 SetExternalVisibleDeclsForName(DC, Name, Decls);
7552 return !Decls.empty();
7555 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7556 if (!DC->hasExternalVisibleStorage())
7559 auto It = Lookups.find(DC);
7560 assert(It != Lookups.end() &&
7561 "have external visible storage but no lookup tables");
7565 for (DeclID ID : It->second.Table.findAll()) {
7566 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7567 Decls[ND->getDeclName()].push_back(ND);
7570 ++NumVisibleDeclContextsRead;
7572 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7573 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7575 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7578 const serialization::reader::DeclContextLookupTable *
7579 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7580 auto I = Lookups.find(Primary);
7581 return I == Lookups.end() ? nullptr : &I->second;
7584 /// Under non-PCH compilation the consumer receives the objc methods
7585 /// before receiving the implementation, and codegen depends on this.
7586 /// We simulate this by deserializing and passing to consumer the methods of the
7587 /// implementation before passing the deserialized implementation decl.
7588 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7589 ASTConsumer *Consumer) {
7590 assert(ImplD && Consumer);
7592 for (auto *I : ImplD->methods())
7593 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7595 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7598 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7599 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7600 PassObjCImplDeclToConsumer(ImplD, Consumer);
7602 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7605 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7606 this->Consumer = Consumer;
7609 PassInterestingDeclsToConsumer();
7611 if (DeserializationListener)
7612 DeserializationListener->ReaderInitialized(this);
7615 void ASTReader::PrintStats() {
7616 std::fprintf(stderr, "*** AST File Statistics:\n");
7618 unsigned NumTypesLoaded
7619 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7621 unsigned NumDeclsLoaded
7622 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7624 unsigned NumIdentifiersLoaded
7625 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7626 IdentifiersLoaded.end(),
7627 (IdentifierInfo *)nullptr);
7628 unsigned NumMacrosLoaded
7629 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7631 (MacroInfo *)nullptr);
7632 unsigned NumSelectorsLoaded
7633 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7634 SelectorsLoaded.end(),
7637 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7638 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7639 NumSLocEntriesRead, TotalNumSLocEntries,
7640 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7641 if (!TypesLoaded.empty())
7642 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7643 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7644 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7645 if (!DeclsLoaded.empty())
7646 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7647 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7648 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7649 if (!IdentifiersLoaded.empty())
7650 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7651 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7652 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7653 if (!MacrosLoaded.empty())
7654 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7655 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7656 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7657 if (!SelectorsLoaded.empty())
7658 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7659 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7660 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7661 if (TotalNumStatements)
7662 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7663 NumStatementsRead, TotalNumStatements,
7664 ((float)NumStatementsRead/TotalNumStatements * 100));
7666 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7667 NumMacrosRead, TotalNumMacros,
7668 ((float)NumMacrosRead/TotalNumMacros * 100));
7669 if (TotalLexicalDeclContexts)
7670 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7671 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7672 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7674 if (TotalVisibleDeclContexts)
7675 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7676 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7677 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7679 if (TotalNumMethodPoolEntries)
7680 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7681 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7682 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7684 if (NumMethodPoolLookups)
7685 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7686 NumMethodPoolHits, NumMethodPoolLookups,
7687 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7688 if (NumMethodPoolTableLookups)
7689 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7690 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7691 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7693 if (NumIdentifierLookupHits)
7694 std::fprintf(stderr,
7695 " %u / %u identifier table lookups succeeded (%f%%)\n",
7696 NumIdentifierLookupHits, NumIdentifierLookups,
7697 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7700 std::fprintf(stderr, "\n");
7701 GlobalIndex->printStats();
7704 std::fprintf(stderr, "\n");
7706 std::fprintf(stderr, "\n");
7709 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7710 LLVM_DUMP_METHOD static void
7711 dumpModuleIDMap(StringRef Name,
7712 const ContinuousRangeMap<Key, ModuleFile *,
7713 InitialCapacity> &Map) {
7714 if (Map.begin() == Map.end())
7717 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7719 llvm::errs() << Name << ":\n";
7720 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7722 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7727 LLVM_DUMP_METHOD void ASTReader::dump() {
7728 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7729 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7730 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7731 dumpModuleIDMap("Global type map", GlobalTypeMap);
7732 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7733 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7734 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7735 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7736 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7737 dumpModuleIDMap("Global preprocessed entity map",
7738 GlobalPreprocessedEntityMap);
7740 llvm::errs() << "\n*** PCH/Modules Loaded:";
7741 for (ModuleFile &M : ModuleMgr)
7745 /// Return the amount of memory used by memory buffers, breaking down
7746 /// by heap-backed versus mmap'ed memory.
7747 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7748 for (ModuleFile &I : ModuleMgr) {
7749 if (llvm::MemoryBuffer *buf = I.Buffer) {
7750 size_t bytes = buf->getBufferSize();
7751 switch (buf->getBufferKind()) {
7752 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7753 sizes.malloc_bytes += bytes;
7755 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7756 sizes.mmap_bytes += bytes;
7763 void ASTReader::InitializeSema(Sema &S) {
7765 S.addExternalSource(this);
7767 // Makes sure any declarations that were deserialized "too early"
7768 // still get added to the identifier's declaration chains.
7769 for (uint64_t ID : PreloadedDeclIDs) {
7770 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7771 pushExternalDeclIntoScope(D, D->getDeclName());
7773 PreloadedDeclIDs.clear();
7775 // FIXME: What happens if these are changed by a module import?
7776 if (!FPPragmaOptions.empty()) {
7777 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7778 SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7781 SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7782 SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7783 SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7788 void ASTReader::UpdateSema() {
7789 assert(SemaObj && "no Sema to update");
7791 // Load the offsets of the declarations that Sema references.
7792 // They will be lazily deserialized when needed.
7793 if (!SemaDeclRefs.empty()) {
7794 assert(SemaDeclRefs.size() % 3 == 0);
7795 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7796 if (!SemaObj->StdNamespace)
7797 SemaObj->StdNamespace = SemaDeclRefs[I];
7798 if (!SemaObj->StdBadAlloc)
7799 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7800 if (!SemaObj->StdAlignValT)
7801 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7803 SemaDeclRefs.clear();
7806 // Update the state of pragmas. Use the same API as if we had encountered the
7807 // pragma in the source.
7808 if(OptimizeOffPragmaLocation.isValid())
7809 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7810 if (PragmaMSStructState != -1)
7811 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7812 if (PointersToMembersPragmaLocation.isValid()) {
7813 SemaObj->ActOnPragmaMSPointersToMembers(
7814 (LangOptions::PragmaMSPointersToMembersKind)
7815 PragmaMSPointersToMembersState,
7816 PointersToMembersPragmaLocation);
7818 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7820 if (PragmaPackCurrentValue) {
7821 // The bottom of the stack might have a default value. It must be adjusted
7822 // to the current value to ensure that the packing state is preserved after
7823 // popping entries that were included/imported from a PCH/module.
7824 bool DropFirst = false;
7825 if (!PragmaPackStack.empty() &&
7826 PragmaPackStack.front().Location.isInvalid()) {
7827 assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7828 "Expected a default alignment value");
7829 SemaObj->PackStack.Stack.emplace_back(
7830 PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7831 SemaObj->PackStack.CurrentPragmaLocation,
7832 PragmaPackStack.front().PushLocation);
7835 for (const auto &Entry :
7836 llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7837 SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7838 Entry.Location, Entry.PushLocation);
7839 if (PragmaPackCurrentLocation.isInvalid()) {
7840 assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7841 "Expected a default alignment value");
7842 // Keep the current values.
7844 SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7845 SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7850 IdentifierInfo *ASTReader::get(StringRef Name) {
7851 // Note that we are loading an identifier.
7852 Deserializing AnIdentifier(this);
7854 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7855 NumIdentifierLookups,
7856 NumIdentifierLookupHits);
7858 // We don't need to do identifier table lookups in C++ modules (we preload
7859 // all interesting declarations, and don't need to use the scope for name
7860 // lookups). Perform the lookup in PCH files, though, since we don't build
7861 // a complete initial identifier table if we're carrying on from a PCH.
7862 if (PP.getLangOpts().CPlusPlus) {
7863 for (auto F : ModuleMgr.pch_modules())
7867 // If there is a global index, look there first to determine which modules
7868 // provably do not have any results for this identifier.
7869 GlobalModuleIndex::HitSet Hits;
7870 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7871 if (!loadGlobalIndex()) {
7872 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7877 ModuleMgr.visit(Visitor, HitsPtr);
7880 IdentifierInfo *II = Visitor.getIdentifierInfo();
7881 markIdentifierUpToDate(II);
7887 /// An identifier-lookup iterator that enumerates all of the
7888 /// identifiers stored within a set of AST files.
7889 class ASTIdentifierIterator : public IdentifierIterator {
7890 /// The AST reader whose identifiers are being enumerated.
7891 const ASTReader &Reader;
7893 /// The current index into the chain of AST files stored in
7897 /// The current position within the identifier lookup table
7898 /// of the current AST file.
7899 ASTIdentifierLookupTable::key_iterator Current;
7901 /// The end position within the identifier lookup table of
7902 /// the current AST file.
7903 ASTIdentifierLookupTable::key_iterator End;
7905 /// Whether to skip any modules in the ASTReader.
7909 explicit ASTIdentifierIterator(const ASTReader &Reader,
7910 bool SkipModules = false);
7912 StringRef Next() override;
7915 } // namespace clang
7917 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
7919 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7922 StringRef ASTIdentifierIterator::Next() {
7923 while (Current == End) {
7924 // If we have exhausted all of our AST files, we're done.
7929 ModuleFile &F = Reader.ModuleMgr[Index];
7930 if (SkipModules && F.isModule())
7933 ASTIdentifierLookupTable *IdTable =
7934 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7935 Current = IdTable->key_begin();
7936 End = IdTable->key_end();
7939 // We have any identifiers remaining in the current AST file; return
7941 StringRef Result = *Current;
7948 /// A utility for appending two IdentifierIterators.
7949 class ChainedIdentifierIterator : public IdentifierIterator {
7950 std::unique_ptr<IdentifierIterator> Current;
7951 std::unique_ptr<IdentifierIterator> Queued;
7954 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7955 std::unique_ptr<IdentifierIterator> Second)
7956 : Current(std::move(First)), Queued(std::move(Second)) {}
7958 StringRef Next() override {
7962 StringRef result = Current->Next();
7963 if (!result.empty())
7966 // Try the queued iterator, which may itself be empty.
7968 std::swap(Current, Queued);
7975 IdentifierIterator *ASTReader::getIdentifiers() {
7976 if (!loadGlobalIndex()) {
7977 std::unique_ptr<IdentifierIterator> ReaderIter(
7978 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7979 std::unique_ptr<IdentifierIterator> ModulesIter(
7980 GlobalIndex->createIdentifierIterator());
7981 return new ChainedIdentifierIterator(std::move(ReaderIter),
7982 std::move(ModulesIter));
7985 return new ASTIdentifierIterator(*this);
7989 namespace serialization {
7991 class ReadMethodPoolVisitor {
7994 unsigned PriorGeneration;
7995 unsigned InstanceBits = 0;
7996 unsigned FactoryBits = 0;
7997 bool InstanceHasMoreThanOneDecl = false;
7998 bool FactoryHasMoreThanOneDecl = false;
7999 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8000 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8003 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8004 unsigned PriorGeneration)
8005 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8007 bool operator()(ModuleFile &M) {
8008 if (!M.SelectorLookupTable)
8011 // If we've already searched this module file, skip it now.
8012 if (M.Generation <= PriorGeneration)
8015 ++Reader.NumMethodPoolTableLookups;
8016 ASTSelectorLookupTable *PoolTable
8017 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8018 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8019 if (Pos == PoolTable->end())
8022 ++Reader.NumMethodPoolTableHits;
8023 ++Reader.NumSelectorsRead;
8024 // FIXME: Not quite happy with the statistics here. We probably should
8025 // disable this tracking when called via LoadSelector.
8026 // Also, should entries without methods count as misses?
8027 ++Reader.NumMethodPoolEntriesRead;
8028 ASTSelectorLookupTrait::data_type Data = *Pos;
8029 if (Reader.DeserializationListener)
8030 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8032 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8033 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8034 InstanceBits = Data.InstanceBits;
8035 FactoryBits = Data.FactoryBits;
8036 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8037 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8041 /// Retrieve the instance methods found by this visitor.
8042 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8043 return InstanceMethods;
8046 /// Retrieve the instance methods found by this visitor.
8047 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8048 return FactoryMethods;
8051 unsigned getInstanceBits() const { return InstanceBits; }
8052 unsigned getFactoryBits() const { return FactoryBits; }
8054 bool instanceHasMoreThanOneDecl() const {
8055 return InstanceHasMoreThanOneDecl;
8058 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8061 } // namespace serialization
8062 } // namespace clang
8064 /// Add the given set of methods to the method list.
8065 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8066 ObjCMethodList &List) {
8067 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8068 S.addMethodToGlobalList(&List, Methods[I]);
8072 void ASTReader::ReadMethodPool(Selector Sel) {
8073 // Get the selector generation and update it to the current generation.
8074 unsigned &Generation = SelectorGeneration[Sel];
8075 unsigned PriorGeneration = Generation;
8076 Generation = getGeneration();
8077 SelectorOutOfDate[Sel] = false;
8079 // Search for methods defined with this selector.
8080 ++NumMethodPoolLookups;
8081 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8082 ModuleMgr.visit(Visitor);
8084 if (Visitor.getInstanceMethods().empty() &&
8085 Visitor.getFactoryMethods().empty())
8088 ++NumMethodPoolHits;
8093 Sema &S = *getSema();
8094 Sema::GlobalMethodPool::iterator Pos
8095 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8097 Pos->second.first.setBits(Visitor.getInstanceBits());
8098 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8099 Pos->second.second.setBits(Visitor.getFactoryBits());
8100 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8102 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8103 // when building a module we keep every method individually and may need to
8104 // update hasMoreThanOneDecl as we add the methods.
8105 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8106 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8109 void ASTReader::updateOutOfDateSelector(Selector Sel) {
8110 if (SelectorOutOfDate[Sel])
8111 ReadMethodPool(Sel);
8114 void ASTReader::ReadKnownNamespaces(
8115 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8118 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8119 if (NamespaceDecl *Namespace
8120 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8121 Namespaces.push_back(Namespace);
8125 void ASTReader::ReadUndefinedButUsed(
8126 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8127 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8128 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8129 SourceLocation Loc =
8130 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8131 Undefined.insert(std::make_pair(D, Loc));
8135 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8136 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8138 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8139 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8140 uint64_t Count = DelayedDeleteExprs[Idx++];
8141 for (uint64_t C = 0; C < Count; ++C) {
8142 SourceLocation DeleteLoc =
8143 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8144 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8145 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8150 void ASTReader::ReadTentativeDefinitions(
8151 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8152 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8153 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8155 TentativeDefs.push_back(Var);
8157 TentativeDefinitions.clear();
8160 void ASTReader::ReadUnusedFileScopedDecls(
8161 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8162 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8164 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8168 UnusedFileScopedDecls.clear();
8171 void ASTReader::ReadDelegatingConstructors(
8172 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8173 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8174 CXXConstructorDecl *D
8175 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8179 DelegatingCtorDecls.clear();
8182 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8183 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8185 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8189 ExtVectorDecls.clear();
8192 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8193 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8194 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8196 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8197 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8201 UnusedLocalTypedefNameCandidates.clear();
8204 void ASTReader::ReadReferencedSelectors(
8205 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8206 if (ReferencedSelectorsData.empty())
8209 // If there are @selector references added them to its pool. This is for
8210 // implementation of -Wselector.
8211 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8213 while (I < DataSize) {
8214 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8215 SourceLocation SelLoc
8216 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8217 Sels.push_back(std::make_pair(Sel, SelLoc));
8219 ReferencedSelectorsData.clear();
8222 void ASTReader::ReadWeakUndeclaredIdentifiers(
8223 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8224 if (WeakUndeclaredIdentifiers.empty())
8227 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8228 IdentifierInfo *WeakId
8229 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8230 IdentifierInfo *AliasId
8231 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8233 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8234 bool Used = WeakUndeclaredIdentifiers[I++];
8235 WeakInfo WI(AliasId, Loc);
8237 WeakIDs.push_back(std::make_pair(WeakId, WI));
8239 WeakUndeclaredIdentifiers.clear();
8242 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8243 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8244 ExternalVTableUse VT;
8245 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8246 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8247 VT.DefinitionRequired = VTableUses[Idx++];
8248 VTables.push_back(VT);
8254 void ASTReader::ReadPendingInstantiations(
8255 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8256 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8257 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8259 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8261 Pending.push_back(std::make_pair(D, Loc));
8263 PendingInstantiations.clear();
8266 void ASTReader::ReadLateParsedTemplates(
8267 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8269 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8271 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8273 auto LT = llvm::make_unique<LateParsedTemplate>();
8274 LT->D = GetDecl(LateParsedTemplates[Idx++]);
8276 ModuleFile *F = getOwningModuleFile(LT->D);
8277 assert(F && "No module");
8279 unsigned TokN = LateParsedTemplates[Idx++];
8280 LT->Toks.reserve(TokN);
8281 for (unsigned T = 0; T < TokN; ++T)
8282 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8284 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8287 LateParsedTemplates.clear();
8290 void ASTReader::LoadSelector(Selector Sel) {
8291 // It would be complicated to avoid reading the methods anyway. So don't.
8292 ReadMethodPool(Sel);
8295 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8296 assert(ID && "Non-zero identifier ID required");
8297 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8298 IdentifiersLoaded[ID - 1] = II;
8299 if (DeserializationListener)
8300 DeserializationListener->IdentifierRead(ID, II);
8303 /// Set the globally-visible declarations associated with the given
8306 /// If the AST reader is currently in a state where the given declaration IDs
8307 /// cannot safely be resolved, they are queued until it is safe to resolve
8310 /// \param II an IdentifierInfo that refers to one or more globally-visible
8313 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8314 /// visible at global scope.
8316 /// \param Decls if non-null, this vector will be populated with the set of
8317 /// deserialized declarations. These declarations will not be pushed into
8320 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8321 const SmallVectorImpl<uint32_t> &DeclIDs,
8322 SmallVectorImpl<Decl *> *Decls) {
8323 if (NumCurrentElementsDeserializing && !Decls) {
8324 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8328 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8330 // Queue this declaration so that it will be added to the
8331 // translation unit scope and identifier's declaration chain
8332 // once a Sema object is known.
8333 PreloadedDeclIDs.push_back(DeclIDs[I]);
8337 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8339 // If we're simply supposed to record the declarations, do so now.
8341 Decls->push_back(D);
8345 // Introduce this declaration into the translation-unit scope
8346 // and add it to the declaration chain for this identifier, so
8347 // that (unqualified) name lookup will find it.
8348 pushExternalDeclIntoScope(D, II);
8352 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8356 if (IdentifiersLoaded.empty()) {
8357 Error("no identifier table in AST file");
8362 if (!IdentifiersLoaded[ID]) {
8363 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8364 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8365 ModuleFile *M = I->second;
8366 unsigned Index = ID - M->BaseIdentifierID;
8367 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8369 // All of the strings in the AST file are preceded by a 16-bit length.
8370 // Extract that 16-bit length to avoid having to execute strlen().
8371 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8372 // unsigned integers. This is important to avoid integer overflow when
8373 // we cast them to 'unsigned'.
8374 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8375 unsigned StrLen = (((unsigned) StrLenPtr[0])
8376 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8377 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8378 IdentifiersLoaded[ID] = &II;
8379 markIdentifierFromAST(*this, II);
8380 if (DeserializationListener)
8381 DeserializationListener->IdentifierRead(ID + 1, &II);
8384 return IdentifiersLoaded[ID];
8387 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8388 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8391 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8392 if (LocalID < NUM_PREDEF_IDENT_IDS)
8395 if (!M.ModuleOffsetMap.empty())
8396 ReadModuleOffsetMap(M);
8398 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8399 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8400 assert(I != M.IdentifierRemap.end()
8401 && "Invalid index into identifier index remap");
8403 return LocalID + I->second;
8406 MacroInfo *ASTReader::getMacro(MacroID ID) {
8410 if (MacrosLoaded.empty()) {
8411 Error("no macro table in AST file");
8415 ID -= NUM_PREDEF_MACRO_IDS;
8416 if (!MacrosLoaded[ID]) {
8417 GlobalMacroMapType::iterator I
8418 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8419 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8420 ModuleFile *M = I->second;
8421 unsigned Index = ID - M->BaseMacroID;
8422 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8424 if (DeserializationListener)
8425 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8429 return MacrosLoaded[ID];
8432 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8433 if (LocalID < NUM_PREDEF_MACRO_IDS)
8436 if (!M.ModuleOffsetMap.empty())
8437 ReadModuleOffsetMap(M);
8439 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8440 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8441 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8443 return LocalID + I->second;
8446 serialization::SubmoduleID
8447 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8448 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8451 if (!M.ModuleOffsetMap.empty())
8452 ReadModuleOffsetMap(M);
8454 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8455 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8456 assert(I != M.SubmoduleRemap.end()
8457 && "Invalid index into submodule index remap");
8459 return LocalID + I->second;
8462 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8463 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8464 assert(GlobalID == 0 && "Unhandled global submodule ID");
8468 if (GlobalID > SubmodulesLoaded.size()) {
8469 Error("submodule ID out of range in AST file");
8473 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8476 Module *ASTReader::getModule(unsigned ID) {
8477 return getSubmodule(ID);
8480 bool ASTReader::DeclIsFromPCHWithObjectFile(const Decl *D) {
8481 ModuleFile *MF = getOwningModuleFile(D);
8482 return MF && MF->PCHHasObjectFile;
8485 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8487 // It's a module, look it up by submodule ID.
8488 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8489 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8491 // It's a prefix (preamble, PCH, ...). Look it up by index.
8492 unsigned IndexFromEnd = ID >> 1;
8493 assert(IndexFromEnd && "got reference to unknown module file");
8494 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8498 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8502 // For a file representing a module, use the submodule ID of the top-level
8503 // module as the file ID. For any other kind of file, the number of such
8504 // files loaded beforehand will be the same on reload.
8505 // FIXME: Is this true even if we have an explicit module file and a PCH?
8507 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8509 auto PCHModules = getModuleManager().pch_modules();
8510 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
8511 assert(I != PCHModules.end() && "emitting reference to unknown file");
8512 return (I - PCHModules.end()) << 1;
8515 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
8516 ASTReader::getSourceDescriptor(unsigned ID) {
8517 if (const Module *M = getSubmodule(ID))
8518 return ExternalASTSource::ASTSourceDescriptor(*M);
8520 // If there is only a single PCH, return it instead.
8521 // Chained PCH are not supported.
8522 const auto &PCHChain = ModuleMgr.pch_modules();
8523 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8524 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8525 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8526 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8527 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8533 ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8534 auto I = DefinitionSource.find(FD);
8535 if (I == DefinitionSource.end())
8536 return EK_ReplyHazy;
8537 return I->second ? EK_Never : EK_Always;
8540 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8541 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8544 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8548 if (ID > SelectorsLoaded.size()) {
8549 Error("selector ID out of range in AST file");
8553 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8554 // Load this selector from the selector table.
8555 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8556 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8557 ModuleFile &M = *I->second;
8558 ASTSelectorLookupTrait Trait(*this, M);
8559 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8560 SelectorsLoaded[ID - 1] =
8561 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8562 if (DeserializationListener)
8563 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8566 return SelectorsLoaded[ID - 1];
8569 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8570 return DecodeSelector(ID);
8573 uint32_t ASTReader::GetNumExternalSelectors() {
8574 // ID 0 (the null selector) is considered an external selector.
8575 return getTotalNumSelectors() + 1;
8578 serialization::SelectorID
8579 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8580 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8583 if (!M.ModuleOffsetMap.empty())
8584 ReadModuleOffsetMap(M);
8586 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8587 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8588 assert(I != M.SelectorRemap.end()
8589 && "Invalid index into selector index remap");
8591 return LocalID + I->second;
8595 ASTReader::ReadDeclarationName(ModuleFile &F,
8596 const RecordData &Record, unsigned &Idx) {
8597 ASTContext &Context = getContext();
8598 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
8600 case DeclarationName::Identifier:
8601 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8603 case DeclarationName::ObjCZeroArgSelector:
8604 case DeclarationName::ObjCOneArgSelector:
8605 case DeclarationName::ObjCMultiArgSelector:
8606 return DeclarationName(ReadSelector(F, Record, Idx));
8608 case DeclarationName::CXXConstructorName:
8609 return Context.DeclarationNames.getCXXConstructorName(
8610 Context.getCanonicalType(readType(F, Record, Idx)));
8612 case DeclarationName::CXXDestructorName:
8613 return Context.DeclarationNames.getCXXDestructorName(
8614 Context.getCanonicalType(readType(F, Record, Idx)));
8616 case DeclarationName::CXXDeductionGuideName:
8617 return Context.DeclarationNames.getCXXDeductionGuideName(
8618 ReadDeclAs<TemplateDecl>(F, Record, Idx));
8620 case DeclarationName::CXXConversionFunctionName:
8621 return Context.DeclarationNames.getCXXConversionFunctionName(
8622 Context.getCanonicalType(readType(F, Record, Idx)));
8624 case DeclarationName::CXXOperatorName:
8625 return Context.DeclarationNames.getCXXOperatorName(
8626 (OverloadedOperatorKind)Record[Idx++]);
8628 case DeclarationName::CXXLiteralOperatorName:
8629 return Context.DeclarationNames.getCXXLiteralOperatorName(
8630 GetIdentifierInfo(F, Record, Idx));
8632 case DeclarationName::CXXUsingDirective:
8633 return DeclarationName::getUsingDirectiveName();
8636 llvm_unreachable("Invalid NameKind!");
8639 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
8640 DeclarationNameLoc &DNLoc,
8641 DeclarationName Name,
8642 const RecordData &Record, unsigned &Idx) {
8643 switch (Name.getNameKind()) {
8644 case DeclarationName::CXXConstructorName:
8645 case DeclarationName::CXXDestructorName:
8646 case DeclarationName::CXXConversionFunctionName:
8647 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8650 case DeclarationName::CXXOperatorName:
8651 DNLoc.CXXOperatorName.BeginOpNameLoc
8652 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8653 DNLoc.CXXOperatorName.EndOpNameLoc
8654 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8657 case DeclarationName::CXXLiteralOperatorName:
8658 DNLoc.CXXLiteralOperatorName.OpNameLoc
8659 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8662 case DeclarationName::Identifier:
8663 case DeclarationName::ObjCZeroArgSelector:
8664 case DeclarationName::ObjCOneArgSelector:
8665 case DeclarationName::ObjCMultiArgSelector:
8666 case DeclarationName::CXXUsingDirective:
8667 case DeclarationName::CXXDeductionGuideName:
8672 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
8673 DeclarationNameInfo &NameInfo,
8674 const RecordData &Record, unsigned &Idx) {
8675 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8676 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8677 DeclarationNameLoc DNLoc;
8678 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8679 NameInfo.setInfo(DNLoc);
8682 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
8683 const RecordData &Record, unsigned &Idx) {
8684 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8685 unsigned NumTPLists = Record[Idx++];
8686 Info.NumTemplParamLists = NumTPLists;
8688 Info.TemplParamLists =
8689 new (getContext()) TemplateParameterList *[NumTPLists];
8690 for (unsigned i = 0; i != NumTPLists; ++i)
8691 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8696 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8698 ASTContext &Context = getContext();
8699 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
8701 case TemplateName::Template:
8702 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8704 case TemplateName::OverloadedTemplate: {
8705 unsigned size = Record[Idx++];
8706 UnresolvedSet<8> Decls;
8708 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8710 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8713 case TemplateName::QualifiedTemplate: {
8714 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8715 bool hasTemplKeyword = Record[Idx++];
8716 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8717 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8720 case TemplateName::DependentTemplate: {
8721 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8722 if (Record[Idx++]) // isIdentifier
8723 return Context.getDependentTemplateName(NNS,
8724 GetIdentifierInfo(F, Record,
8726 return Context.getDependentTemplateName(NNS,
8727 (OverloadedOperatorKind)Record[Idx++]);
8730 case TemplateName::SubstTemplateTemplateParm: {
8731 TemplateTemplateParmDecl *param
8732 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8733 if (!param) return TemplateName();
8734 TemplateName replacement = ReadTemplateName(F, Record, Idx);
8735 return Context.getSubstTemplateTemplateParm(param, replacement);
8738 case TemplateName::SubstTemplateTemplateParmPack: {
8739 TemplateTemplateParmDecl *Param
8740 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8742 return TemplateName();
8744 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8745 if (ArgPack.getKind() != TemplateArgument::Pack)
8746 return TemplateName();
8748 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8752 llvm_unreachable("Unhandled template name kind!");
8755 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
8756 const RecordData &Record,
8758 bool Canonicalize) {
8759 ASTContext &Context = getContext();
8761 // The caller wants a canonical template argument. Sometimes the AST only
8762 // wants template arguments in canonical form (particularly as the template
8763 // argument lists of template specializations) so ensure we preserve that
8764 // canonical form across serialization.
8765 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8766 return Context.getCanonicalTemplateArgument(Arg);
8769 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
8771 case TemplateArgument::Null:
8772 return TemplateArgument();
8773 case TemplateArgument::Type:
8774 return TemplateArgument(readType(F, Record, Idx));
8775 case TemplateArgument::Declaration: {
8776 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8777 return TemplateArgument(D, readType(F, Record, Idx));
8779 case TemplateArgument::NullPtr:
8780 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8781 case TemplateArgument::Integral: {
8782 llvm::APSInt Value = ReadAPSInt(Record, Idx);
8783 QualType T = readType(F, Record, Idx);
8784 return TemplateArgument(Context, Value, T);
8786 case TemplateArgument::Template:
8787 return TemplateArgument(ReadTemplateName(F, Record, Idx));
8788 case TemplateArgument::TemplateExpansion: {
8789 TemplateName Name = ReadTemplateName(F, Record, Idx);
8790 Optional<unsigned> NumTemplateExpansions;
8791 if (unsigned NumExpansions = Record[Idx++])
8792 NumTemplateExpansions = NumExpansions - 1;
8793 return TemplateArgument(Name, NumTemplateExpansions);
8795 case TemplateArgument::Expression:
8796 return TemplateArgument(ReadExpr(F));
8797 case TemplateArgument::Pack: {
8798 unsigned NumArgs = Record[Idx++];
8799 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8800 for (unsigned I = 0; I != NumArgs; ++I)
8801 Args[I] = ReadTemplateArgument(F, Record, Idx);
8802 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8806 llvm_unreachable("Unhandled template argument kind!");
8809 TemplateParameterList *
8810 ASTReader::ReadTemplateParameterList(ModuleFile &F,
8811 const RecordData &Record, unsigned &Idx) {
8812 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8813 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8814 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8816 unsigned NumParams = Record[Idx++];
8817 SmallVector<NamedDecl *, 16> Params;
8818 Params.reserve(NumParams);
8820 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8823 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8824 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8825 return TemplateParams;
8830 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
8831 ModuleFile &F, const RecordData &Record,
8832 unsigned &Idx, bool Canonicalize) {
8833 unsigned NumTemplateArgs = Record[Idx++];
8834 TemplArgs.reserve(NumTemplateArgs);
8835 while (NumTemplateArgs--)
8836 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8839 /// Read a UnresolvedSet structure.
8840 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
8841 const RecordData &Record, unsigned &Idx) {
8842 unsigned NumDecls = Record[Idx++];
8843 Set.reserve(getContext(), NumDecls);
8844 while (NumDecls--) {
8845 DeclID ID = ReadDeclID(F, Record, Idx);
8846 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8847 Set.addLazyDecl(getContext(), ID, AS);
8852 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
8853 const RecordData &Record, unsigned &Idx) {
8854 bool isVirtual = static_cast<bool>(Record[Idx++]);
8855 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8856 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8857 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8858 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8859 SourceRange Range = ReadSourceRange(F, Record, Idx);
8860 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8861 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8863 Result.setInheritConstructors(inheritConstructors);
8867 CXXCtorInitializer **
8868 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8870 ASTContext &Context = getContext();
8871 unsigned NumInitializers = Record[Idx++];
8872 assert(NumInitializers && "wrote ctor initializers but have no inits");
8873 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8874 for (unsigned i = 0; i != NumInitializers; ++i) {
8875 TypeSourceInfo *TInfo = nullptr;
8876 bool IsBaseVirtual = false;
8877 FieldDecl *Member = nullptr;
8878 IndirectFieldDecl *IndirectMember = nullptr;
8880 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8882 case CTOR_INITIALIZER_BASE:
8883 TInfo = GetTypeSourceInfo(F, Record, Idx);
8884 IsBaseVirtual = Record[Idx++];
8887 case CTOR_INITIALIZER_DELEGATING:
8888 TInfo = GetTypeSourceInfo(F, Record, Idx);
8891 case CTOR_INITIALIZER_MEMBER:
8892 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8895 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8896 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8900 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8901 Expr *Init = ReadExpr(F);
8902 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8903 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8905 CXXCtorInitializer *BOMInit;
8906 if (Type == CTOR_INITIALIZER_BASE)
8907 BOMInit = new (Context)
8908 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8909 RParenLoc, MemberOrEllipsisLoc);
8910 else if (Type == CTOR_INITIALIZER_DELEGATING)
8911 BOMInit = new (Context)
8912 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8914 BOMInit = new (Context)
8915 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8918 BOMInit = new (Context)
8919 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8920 LParenLoc, Init, RParenLoc);
8922 if (/*IsWritten*/Record[Idx++]) {
8923 unsigned SourceOrder = Record[Idx++];
8924 BOMInit->setSourceOrder(SourceOrder);
8927 CtorInitializers[i] = BOMInit;
8930 return CtorInitializers;
8933 NestedNameSpecifier *
8934 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8935 const RecordData &Record, unsigned &Idx) {
8936 ASTContext &Context = getContext();
8937 unsigned N = Record[Idx++];
8938 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8939 for (unsigned I = 0; I != N; ++I) {
8940 NestedNameSpecifier::SpecifierKind Kind
8941 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8943 case NestedNameSpecifier::Identifier: {
8944 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8945 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8949 case NestedNameSpecifier::Namespace: {
8950 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8951 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8955 case NestedNameSpecifier::NamespaceAlias: {
8956 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8957 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8961 case NestedNameSpecifier::TypeSpec:
8962 case NestedNameSpecifier::TypeSpecWithTemplate: {
8963 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8967 bool Template = Record[Idx++];
8968 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8972 case NestedNameSpecifier::Global:
8973 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8974 // No associated value, and there can't be a prefix.
8977 case NestedNameSpecifier::Super: {
8978 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8979 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8988 NestedNameSpecifierLoc
8989 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
8991 ASTContext &Context = getContext();
8992 unsigned N = Record[Idx++];
8993 NestedNameSpecifierLocBuilder Builder;
8994 for (unsigned I = 0; I != N; ++I) {
8995 NestedNameSpecifier::SpecifierKind Kind
8996 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8998 case NestedNameSpecifier::Identifier: {
8999 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9000 SourceRange Range = ReadSourceRange(F, Record, Idx);
9001 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9005 case NestedNameSpecifier::Namespace: {
9006 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9007 SourceRange Range = ReadSourceRange(F, Record, Idx);
9008 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9012 case NestedNameSpecifier::NamespaceAlias: {
9013 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9014 SourceRange Range = ReadSourceRange(F, Record, Idx);
9015 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9019 case NestedNameSpecifier::TypeSpec:
9020 case NestedNameSpecifier::TypeSpecWithTemplate: {
9021 bool Template = Record[Idx++];
9022 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
9024 return NestedNameSpecifierLoc();
9025 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9027 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9028 Builder.Extend(Context,
9029 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9030 T->getTypeLoc(), ColonColonLoc);
9034 case NestedNameSpecifier::Global: {
9035 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9036 Builder.MakeGlobal(Context, ColonColonLoc);
9040 case NestedNameSpecifier::Super: {
9041 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9042 SourceRange Range = ReadSourceRange(F, Record, Idx);
9043 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9049 return Builder.getWithLocInContext(Context);
9053 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9055 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
9056 SourceLocation end = ReadSourceLocation(F, Record, Idx);
9057 return SourceRange(beg, end);
9060 /// Read an integral value
9061 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
9062 unsigned BitWidth = Record[Idx++];
9063 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
9064 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9069 /// Read a signed integral value
9070 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
9071 bool isUnsigned = Record[Idx++];
9072 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
9075 /// Read a floating-point value
9076 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
9077 const llvm::fltSemantics &Sem,
9079 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
9083 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9084 unsigned Len = Record[Idx++];
9085 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9090 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9092 std::string Filename = ReadString(Record, Idx);
9093 ResolveImportedPath(F, Filename);
9097 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9099 unsigned Major = Record[Idx++];
9100 unsigned Minor = Record[Idx++];
9101 unsigned Subminor = Record[Idx++];
9103 return VersionTuple(Major);
9105 return VersionTuple(Major, Minor - 1);
9106 return VersionTuple(Major, Minor - 1, Subminor - 1);
9109 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9110 const RecordData &Record,
9112 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9113 return CXXTemporary::Create(getContext(), Decl);
9116 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9117 return Diag(CurrentImportLoc, DiagID);
9120 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9121 return Diags.Report(Loc, DiagID);
9124 /// Retrieve the identifier table associated with the
9126 IdentifierTable &ASTReader::getIdentifierTable() {
9127 return PP.getIdentifierTable();
9130 /// Record that the given ID maps to the given switch-case
9132 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9133 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9134 "Already have a SwitchCase with this ID");
9135 (*CurrSwitchCaseStmts)[ID] = SC;
9138 /// Retrieve the switch-case statement with the given ID.
9139 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9140 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9141 return (*CurrSwitchCaseStmts)[ID];
9144 void ASTReader::ClearSwitchCaseIDs() {
9145 CurrSwitchCaseStmts->clear();
9148 void ASTReader::ReadComments() {
9149 ASTContext &Context = getContext();
9150 std::vector<RawComment *> Comments;
9151 for (SmallVectorImpl<std::pair<BitstreamCursor,
9152 serialization::ModuleFile *>>::iterator
9153 I = CommentsCursors.begin(),
9154 E = CommentsCursors.end();
9157 BitstreamCursor &Cursor = I->first;
9158 serialization::ModuleFile &F = *I->second;
9159 SavedStreamPosition SavedPosition(Cursor);
9163 llvm::BitstreamEntry Entry =
9164 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9166 switch (Entry.Kind) {
9167 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9168 case llvm::BitstreamEntry::Error:
9169 Error("malformed block record in AST file");
9171 case llvm::BitstreamEntry::EndBlock:
9173 case llvm::BitstreamEntry::Record:
9174 // The interesting case.
9180 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9181 case COMMENTS_RAW_COMMENT: {
9183 SourceRange SR = ReadSourceRange(F, Record, Idx);
9184 RawComment::CommentKind Kind =
9185 (RawComment::CommentKind) Record[Idx++];
9186 bool IsTrailingComment = Record[Idx++];
9187 bool IsAlmostTrailingComment = Record[Idx++];
9188 Comments.push_back(new (Context) RawComment(
9189 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9195 // De-serialized SourceLocations get negative FileIDs for other modules,
9196 // potentially invalidating the original order. Sort it again.
9197 llvm::sort(Comments, BeforeThanCompare<RawComment>(SourceMgr));
9198 Context.Comments.addDeserializedComments(Comments);
9202 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9203 bool IncludeSystem, bool Complain,
9204 llvm::function_ref<void(const serialization::InputFile &IF,
9205 bool isSystem)> Visitor) {
9206 unsigned NumUserInputs = MF.NumUserInputFiles;
9207 unsigned NumInputs = MF.InputFilesLoaded.size();
9208 assert(NumUserInputs <= NumInputs);
9209 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9210 for (unsigned I = 0; I < N; ++I) {
9211 bool IsSystem = I >= NumUserInputs;
9212 InputFile IF = getInputFile(MF, I+1, Complain);
9213 Visitor(IF, IsSystem);
9217 void ASTReader::visitTopLevelModuleMaps(
9218 serialization::ModuleFile &MF,
9219 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9220 unsigned NumInputs = MF.InputFilesLoaded.size();
9221 for (unsigned I = 0; I < NumInputs; ++I) {
9222 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9223 if (IFI.TopLevelModuleMap)
9224 // FIXME: This unnecessarily re-reads the InputFileInfo.
9225 if (auto *FE = getInputFile(MF, I + 1).getFile())
9230 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9231 // If we know the owning module, use it.
9232 if (Module *M = D->getImportedOwningModule())
9233 return M->getFullModuleName();
9235 // Otherwise, use the name of the top-level module the decl is within.
9236 if (ModuleFile *M = getOwningModuleFile(D))
9237 return M->ModuleName;
9239 // Not from a module.
9243 void ASTReader::finishPendingActions() {
9244 while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
9245 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9246 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9247 !PendingUpdateRecords.empty()) {
9248 // If any identifiers with corresponding top-level declarations have
9249 // been loaded, load those declarations now.
9250 using TopLevelDeclsMap =
9251 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9252 TopLevelDeclsMap TopLevelDecls;
9254 while (!PendingIdentifierInfos.empty()) {
9255 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9256 SmallVector<uint32_t, 4> DeclIDs =
9257 std::move(PendingIdentifierInfos.back().second);
9258 PendingIdentifierInfos.pop_back();
9260 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9263 // Load each function type that we deferred loading because it was a
9264 // deduced type that might refer to a local type declared within itself.
9265 for (unsigned I = 0; I != PendingFunctionTypes.size(); ++I) {
9266 auto *FD = PendingFunctionTypes[I].first;
9267 FD->setType(GetType(PendingFunctionTypes[I].second));
9269 // If we gave a function a deduced return type, remember that we need to
9270 // propagate that along the redeclaration chain.
9271 auto *DT = FD->getReturnType()->getContainedDeducedType();
9272 if (DT && DT->isDeduced())
9273 PendingDeducedTypeUpdates.insert(
9274 {FD->getCanonicalDecl(), FD->getReturnType()});
9276 PendingFunctionTypes.clear();
9278 // For each decl chain that we wanted to complete while deserializing, mark
9279 // it as "still needs to be completed".
9280 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9281 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9283 PendingIncompleteDeclChains.clear();
9285 // Load pending declaration chains.
9286 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9287 loadPendingDeclChain(PendingDeclChains[I].first,
9288 PendingDeclChains[I].second);
9289 PendingDeclChains.clear();
9291 // Make the most recent of the top-level declarations visible.
9292 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9293 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9294 IdentifierInfo *II = TLD->first;
9295 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9296 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9300 // Load any pending macro definitions.
9301 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9302 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9303 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9304 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9305 // Initialize the macro history from chained-PCHs ahead of module imports.
9306 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9308 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9309 if (!Info.M->isModule())
9310 resolvePendingMacro(II, Info);
9312 // Handle module imports.
9313 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9315 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9316 if (Info.M->isModule())
9317 resolvePendingMacro(II, Info);
9320 PendingMacroIDs.clear();
9322 // Wire up the DeclContexts for Decls that we delayed setting until
9323 // recursive loading is completed.
9324 while (!PendingDeclContextInfos.empty()) {
9325 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9326 PendingDeclContextInfos.pop_front();
9327 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9328 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9329 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9332 // Perform any pending declaration updates.
9333 while (!PendingUpdateRecords.empty()) {
9334 auto Update = PendingUpdateRecords.pop_back_val();
9335 ReadingKindTracker ReadingKind(Read_Decl, *this);
9336 loadDeclUpdateRecords(Update);
9340 // At this point, all update records for loaded decls are in place, so any
9341 // fake class definitions should have become real.
9342 assert(PendingFakeDefinitionData.empty() &&
9343 "faked up a class definition but never saw the real one");
9345 // If we deserialized any C++ or Objective-C class definitions, any
9346 // Objective-C protocol definitions, or any redeclarable templates, make sure
9347 // that all redeclarations point to the definitions. Note that this can only
9348 // happen now, after the redeclaration chains have been fully wired.
9349 for (Decl *D : PendingDefinitions) {
9350 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9351 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9352 // Make sure that the TagType points at the definition.
9353 const_cast<TagType*>(TagT)->decl = TD;
9356 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9357 for (auto *R = getMostRecentExistingDecl(RD); R;
9358 R = R->getPreviousDecl()) {
9360 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9361 "declaration thinks it's the definition but it isn't");
9362 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9369 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9370 // Make sure that the ObjCInterfaceType points at the definition.
9371 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9374 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9375 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9380 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9381 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9382 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9387 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9388 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9389 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9391 PendingDefinitions.clear();
9393 // Load the bodies of any functions or methods we've encountered. We do
9394 // this now (delayed) so that we can be sure that the declaration chains
9395 // have been fully wired up (hasBody relies on this).
9396 // FIXME: We shouldn't require complete redeclaration chains here.
9397 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9398 PBEnd = PendingBodies.end();
9399 PB != PBEnd; ++PB) {
9400 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9401 // For a function defined inline within a class template, force the
9402 // canonical definition to be the one inside the canonical definition of
9403 // the template. This ensures that we instantiate from a correct view
9406 // Sadly we can't do this more generally: we can't be sure that all
9407 // copies of an arbitrary class definition will have the same members
9408 // defined (eg, some member functions may not be instantiated, and some
9409 // special members may or may not have been implicitly defined).
9410 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9411 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9414 // FIXME: Check for =delete/=default?
9415 // FIXME: Complain about ODR violations here?
9416 const FunctionDecl *Defn = nullptr;
9417 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9418 FD->setLazyBody(PB->second);
9420 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9421 mergeDefinitionVisibility(NonConstDefn, FD);
9423 if (!FD->isLateTemplateParsed() &&
9424 !NonConstDefn->isLateTemplateParsed() &&
9425 FD->getODRHash() != NonConstDefn->getODRHash()) {
9426 if (!isa<CXXMethodDecl>(FD)) {
9427 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9428 } else if (FD->getLexicalParent()->isFileContext() &&
9429 NonConstDefn->getLexicalParent()->isFileContext()) {
9430 // Only diagnose out-of-line method definitions. If they are
9431 // in class definitions, then an error will be generated when
9432 // processing the class bodies.
9433 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9440 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9441 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9442 MD->setLazyBody(PB->second);
9444 PendingBodies.clear();
9447 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9448 getContext().deduplicateMergedDefinitonsFor(ND);
9449 PendingMergedDefinitionsToDeduplicate.clear();
9452 void ASTReader::diagnoseOdrViolations() {
9453 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9454 PendingFunctionOdrMergeFailures.empty() &&
9455 PendingEnumOdrMergeFailures.empty())
9458 // Trigger the import of the full definition of each class that had any
9459 // odr-merging problems, so we can produce better diagnostics for them.
9460 // These updates may in turn find and diagnose some ODR failures, so take
9461 // ownership of the set first.
9462 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9463 PendingOdrMergeFailures.clear();
9464 for (auto &Merge : OdrMergeFailures) {
9465 Merge.first->buildLookup();
9466 Merge.first->decls_begin();
9467 Merge.first->bases_begin();
9468 Merge.first->vbases_begin();
9469 for (auto &RecordPair : Merge.second) {
9470 auto *RD = RecordPair.first;
9477 // Trigger the import of functions.
9478 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9479 PendingFunctionOdrMergeFailures.clear();
9480 for (auto &Merge : FunctionOdrMergeFailures) {
9481 Merge.first->buildLookup();
9482 Merge.first->decls_begin();
9483 Merge.first->getBody();
9484 for (auto &FD : Merge.second) {
9491 // Trigger the import of enums.
9492 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9493 PendingEnumOdrMergeFailures.clear();
9494 for (auto &Merge : EnumOdrMergeFailures) {
9495 Merge.first->decls_begin();
9496 for (auto &Enum : Merge.second) {
9497 Enum->decls_begin();
9501 // For each declaration from a merged context, check that the canonical
9502 // definition of that context also contains a declaration of the same
9505 // Caution: this loop does things that might invalidate iterators into
9506 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9507 while (!PendingOdrMergeChecks.empty()) {
9508 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9510 // FIXME: Skip over implicit declarations for now. This matters for things
9511 // like implicitly-declared special member functions. This isn't entirely
9512 // correct; we can end up with multiple unmerged declarations of the same
9514 if (D->isImplicit())
9517 DeclContext *CanonDef = D->getDeclContext();
9520 const Decl *DCanon = D->getCanonicalDecl();
9522 for (auto RI : D->redecls()) {
9523 if (RI->getLexicalDeclContext() == CanonDef) {
9531 // Quick check failed, time to do the slow thing. Note, we can't just
9532 // look up the name of D in CanonDef here, because the member that is
9533 // in CanonDef might not be found by name lookup (it might have been
9534 // replaced by a more recent declaration in the lookup table), and we
9535 // can't necessarily find it in the redeclaration chain because it might
9536 // be merely mergeable, not redeclarable.
9537 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9538 for (auto *CanonMember : CanonDef->decls()) {
9539 if (CanonMember->getCanonicalDecl() == DCanon) {
9540 // This can happen if the declaration is merely mergeable and not
9541 // actually redeclarable (we looked for redeclarations earlier).
9543 // FIXME: We should be able to detect this more efficiently, without
9544 // pulling in all of the members of CanonDef.
9548 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9549 if (ND->getDeclName() == D->getDeclName())
9550 Candidates.push_back(ND);
9554 // The AST doesn't like TagDecls becoming invalid after they've been
9555 // completed. We only really need to mark FieldDecls as invalid here.
9556 if (!isa<TagDecl>(D))
9557 D->setInvalidDecl();
9559 // Ensure we don't accidentally recursively enter deserialization while
9560 // we're producing our diagnostic.
9561 Deserializing RecursionGuard(this);
9563 std::string CanonDefModule =
9564 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9565 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9566 << D << getOwningModuleNameForDiagnostic(D)
9567 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9569 if (Candidates.empty())
9570 Diag(cast<Decl>(CanonDef)->getLocation(),
9571 diag::note_module_odr_violation_no_possible_decls) << D;
9573 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9574 Diag(Candidates[I]->getLocation(),
9575 diag::note_module_odr_violation_possible_decl)
9579 DiagnosedOdrMergeFailures.insert(CanonDef);
9583 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9584 EnumOdrMergeFailures.empty())
9587 // Ensure we don't accidentally recursively enter deserialization while
9588 // we're producing our diagnostics.
9589 Deserializing RecursionGuard(this);
9591 // Common code for hashing helpers.
9593 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9595 Hash.AddQualType(Ty);
9596 return Hash.CalculateHash();
9599 auto ComputeODRHash = [&Hash](const Stmt *S) {
9603 return Hash.CalculateHash();
9606 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9610 return Hash.CalculateHash();
9613 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9615 Hash.AddTemplateArgument(TA);
9616 return Hash.CalculateHash();
9619 auto ComputeTemplateParameterListODRHash =
9620 [&Hash](const TemplateParameterList *TPL) {
9623 Hash.AddTemplateParameterList(TPL);
9624 return Hash.CalculateHash();
9627 // Issue any pending ODR-failure diagnostics.
9628 for (auto &Merge : OdrMergeFailures) {
9629 // If we've already pointed out a specific problem with this class, don't
9630 // bother issuing a general "something's different" diagnostic.
9631 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9634 bool Diagnosed = false;
9635 CXXRecordDecl *FirstRecord = Merge.first;
9636 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9637 for (auto &RecordPair : Merge.second) {
9638 CXXRecordDecl *SecondRecord = RecordPair.first;
9639 // Multiple different declarations got merged together; tell the user
9640 // where they came from.
9641 if (FirstRecord == SecondRecord)
9644 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9646 auto *FirstDD = FirstRecord->DefinitionData;
9647 auto *SecondDD = RecordPair.second;
9649 assert(FirstDD && SecondDD && "Definitions without DefinitionData");
9651 // Diagnostics from DefinitionData are emitted here.
9652 if (FirstDD != SecondDD) {
9653 enum ODRDefinitionDataDifference {
9660 auto ODRDiagError = [FirstRecord, &FirstModule,
9661 this](SourceLocation Loc, SourceRange Range,
9662 ODRDefinitionDataDifference DiffType) {
9663 return Diag(Loc, diag::err_module_odr_violation_definition_data)
9664 << FirstRecord << FirstModule.empty() << FirstModule << Range
9667 auto ODRDiagNote = [&SecondModule,
9668 this](SourceLocation Loc, SourceRange Range,
9669 ODRDefinitionDataDifference DiffType) {
9670 return Diag(Loc, diag::note_module_odr_violation_definition_data)
9671 << SecondModule << Range << DiffType;
9674 unsigned FirstNumBases = FirstDD->NumBases;
9675 unsigned FirstNumVBases = FirstDD->NumVBases;
9676 unsigned SecondNumBases = SecondDD->NumBases;
9677 unsigned SecondNumVBases = SecondDD->NumVBases;
9679 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9680 unsigned NumBases = DD->NumBases;
9681 if (NumBases == 0) return SourceRange();
9682 auto bases = DD->bases();
9683 return SourceRange(bases[0].getBeginLoc(),
9684 bases[NumBases - 1].getEndLoc());
9687 if (FirstNumBases != SecondNumBases) {
9688 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9691 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9698 if (FirstNumVBases != SecondNumVBases) {
9699 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9702 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9709 auto FirstBases = FirstDD->bases();
9710 auto SecondBases = SecondDD->bases();
9712 for (i = 0; i < FirstNumBases; ++i) {
9713 auto FirstBase = FirstBases[i];
9714 auto SecondBase = SecondBases[i];
9715 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9716 ComputeQualTypeODRHash(SecondBase.getType())) {
9717 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9719 << (i + 1) << FirstBase.getType();
9720 ODRDiagNote(SecondRecord->getLocation(),
9721 SecondBase.getSourceRange(), BaseType)
9722 << (i + 1) << SecondBase.getType();
9726 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9727 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9729 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9730 ODRDiagNote(SecondRecord->getLocation(),
9731 SecondBase.getSourceRange(), BaseVirtual)
9732 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9736 if (FirstBase.getAccessSpecifierAsWritten() !=
9737 SecondBase.getAccessSpecifierAsWritten()) {
9738 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9740 << (i + 1) << FirstBase.getType()
9741 << (int)FirstBase.getAccessSpecifierAsWritten();
9742 ODRDiagNote(SecondRecord->getLocation(),
9743 SecondBase.getSourceRange(), BaseAccess)
9744 << (i + 1) << SecondBase.getType()
9745 << (int)SecondBase.getAccessSpecifierAsWritten();
9750 if (i != FirstNumBases) {
9756 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9758 const ClassTemplateDecl *FirstTemplate =
9759 FirstRecord->getDescribedClassTemplate();
9760 const ClassTemplateDecl *SecondTemplate =
9761 SecondRecord->getDescribedClassTemplate();
9763 assert(!FirstTemplate == !SecondTemplate &&
9764 "Both pointers should be null or non-null");
9766 enum ODRTemplateDifference {
9769 ParamSingleDefaultArgument,
9770 ParamDifferentDefaultArgument,
9773 if (FirstTemplate && SecondTemplate) {
9774 DeclHashes FirstTemplateHashes;
9775 DeclHashes SecondTemplateHashes;
9777 auto PopulateTemplateParameterHashs =
9778 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9779 const ClassTemplateDecl *TD) {
9780 for (auto *D : TD->getTemplateParameters()->asArray()) {
9781 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9785 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9786 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9788 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
9789 "Number of template parameters should be equal.");
9791 auto FirstIt = FirstTemplateHashes.begin();
9792 auto FirstEnd = FirstTemplateHashes.end();
9793 auto SecondIt = SecondTemplateHashes.begin();
9794 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9795 if (FirstIt->second == SecondIt->second)
9798 auto ODRDiagError = [FirstRecord, &FirstModule,
9799 this](SourceLocation Loc, SourceRange Range,
9800 ODRTemplateDifference DiffType) {
9801 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9802 << FirstRecord << FirstModule.empty() << FirstModule << Range
9805 auto ODRDiagNote = [&SecondModule,
9806 this](SourceLocation Loc, SourceRange Range,
9807 ODRTemplateDifference DiffType) {
9808 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9809 << SecondModule << Range << DiffType;
9812 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9813 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9815 assert(FirstDecl->getKind() == SecondDecl->getKind() &&
9816 "Parameter Decl's should be the same kind.");
9818 DeclarationName FirstName = FirstDecl->getDeclName();
9819 DeclarationName SecondName = SecondDecl->getDeclName();
9821 if (FirstName != SecondName) {
9822 const bool FirstNameEmpty =
9823 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9824 const bool SecondNameEmpty =
9825 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9826 assert((!FirstNameEmpty || !SecondNameEmpty) &&
9827 "Both template parameters cannot be unnamed.");
9828 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9829 FirstNameEmpty ? ParamEmptyName : ParamName)
9831 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9832 SecondNameEmpty ? ParamEmptyName : ParamName)
9837 switch (FirstDecl->getKind()) {
9839 llvm_unreachable("Invalid template parameter type.");
9840 case Decl::TemplateTypeParm: {
9841 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9842 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9843 const bool HasFirstDefaultArgument =
9844 FirstParam->hasDefaultArgument() &&
9845 !FirstParam->defaultArgumentWasInherited();
9846 const bool HasSecondDefaultArgument =
9847 SecondParam->hasDefaultArgument() &&
9848 !SecondParam->defaultArgumentWasInherited();
9850 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9851 ODRDiagError(FirstDecl->getLocation(),
9852 FirstDecl->getSourceRange(),
9853 ParamSingleDefaultArgument)
9854 << HasFirstDefaultArgument;
9855 ODRDiagNote(SecondDecl->getLocation(),
9856 SecondDecl->getSourceRange(),
9857 ParamSingleDefaultArgument)
9858 << HasSecondDefaultArgument;
9862 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9863 "Expecting default arguments.");
9865 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9866 ParamDifferentDefaultArgument);
9867 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9868 ParamDifferentDefaultArgument);
9872 case Decl::NonTypeTemplateParm: {
9873 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9874 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9875 const bool HasFirstDefaultArgument =
9876 FirstParam->hasDefaultArgument() &&
9877 !FirstParam->defaultArgumentWasInherited();
9878 const bool HasSecondDefaultArgument =
9879 SecondParam->hasDefaultArgument() &&
9880 !SecondParam->defaultArgumentWasInherited();
9882 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9883 ODRDiagError(FirstDecl->getLocation(),
9884 FirstDecl->getSourceRange(),
9885 ParamSingleDefaultArgument)
9886 << HasFirstDefaultArgument;
9887 ODRDiagNote(SecondDecl->getLocation(),
9888 SecondDecl->getSourceRange(),
9889 ParamSingleDefaultArgument)
9890 << HasSecondDefaultArgument;
9894 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9895 "Expecting default arguments.");
9897 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9898 ParamDifferentDefaultArgument);
9899 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9900 ParamDifferentDefaultArgument);
9904 case Decl::TemplateTemplateParm: {
9905 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
9906 const auto *SecondParam =
9907 cast<TemplateTemplateParmDecl>(SecondDecl);
9908 const bool HasFirstDefaultArgument =
9909 FirstParam->hasDefaultArgument() &&
9910 !FirstParam->defaultArgumentWasInherited();
9911 const bool HasSecondDefaultArgument =
9912 SecondParam->hasDefaultArgument() &&
9913 !SecondParam->defaultArgumentWasInherited();
9915 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9916 ODRDiagError(FirstDecl->getLocation(),
9917 FirstDecl->getSourceRange(),
9918 ParamSingleDefaultArgument)
9919 << HasFirstDefaultArgument;
9920 ODRDiagNote(SecondDecl->getLocation(),
9921 SecondDecl->getSourceRange(),
9922 ParamSingleDefaultArgument)
9923 << HasSecondDefaultArgument;
9927 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9928 "Expecting default arguments.");
9930 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9931 ParamDifferentDefaultArgument);
9932 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9933 ParamDifferentDefaultArgument);
9942 if (FirstIt != FirstEnd) {
9948 DeclHashes FirstHashes;
9949 DeclHashes SecondHashes;
9951 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
9952 DeclHashes &Hashes, CXXRecordDecl *Record) {
9953 for (auto *D : Record->decls()) {
9954 // Due to decl merging, the first CXXRecordDecl is the parent of
9955 // Decls in both records.
9956 if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
9958 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9961 PopulateHashes(FirstHashes, FirstRecord);
9962 PopulateHashes(SecondHashes, SecondRecord);
9964 // Used with err_module_odr_violation_mismatch_decl and
9965 // note_module_odr_violation_mismatch_decl
9966 // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
9981 } FirstDiffType = Other,
9982 SecondDiffType = Other;
9984 auto DifferenceSelector = [](Decl *D) {
9985 assert(D && "valid Decl required");
9986 switch (D->getKind()) {
9989 case Decl::AccessSpec:
9990 switch (D->getAccess()) {
9992 return PublicSpecifer;
9994 return PrivateSpecifer;
9996 return ProtectedSpecifer;
10000 llvm_unreachable("Invalid access specifier");
10001 case Decl::StaticAssert:
10002 return StaticAssert;
10005 case Decl::CXXMethod:
10006 case Decl::CXXConstructor:
10007 case Decl::CXXDestructor:
10009 case Decl::TypeAlias:
10011 case Decl::Typedef:
10017 case Decl::FunctionTemplate:
10018 return FunctionTemplate;
10022 Decl *FirstDecl = nullptr;
10023 Decl *SecondDecl = nullptr;
10024 auto FirstIt = FirstHashes.begin();
10025 auto SecondIt = SecondHashes.begin();
10027 // If there is a diagnoseable difference, FirstDiffType and
10028 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
10029 // filled in if not EndOfClass.
10030 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
10031 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
10032 FirstIt->second == SecondIt->second) {
10038 FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
10039 SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
10041 FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
10043 SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
10048 if (FirstDiffType == Other || SecondDiffType == Other) {
10049 // Reaching this point means an unexpected Decl was encountered
10050 // or no difference was detected. This causes a generic error
10051 // message to be emitted.
10052 Diag(FirstRecord->getLocation(),
10053 diag::err_module_odr_violation_different_definitions)
10054 << FirstRecord << FirstModule.empty() << FirstModule;
10057 Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
10058 << FirstRecord << FirstDecl->getSourceRange();
10061 Diag(SecondRecord->getLocation(),
10062 diag::note_module_odr_violation_different_definitions)
10066 Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
10067 << SecondDecl->getSourceRange();
10074 if (FirstDiffType != SecondDiffType) {
10075 SourceLocation FirstLoc;
10076 SourceRange FirstRange;
10077 if (FirstDiffType == EndOfClass) {
10078 FirstLoc = FirstRecord->getBraceRange().getEnd();
10080 FirstLoc = FirstIt->first->getLocation();
10081 FirstRange = FirstIt->first->getSourceRange();
10083 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10084 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10087 SourceLocation SecondLoc;
10088 SourceRange SecondRange;
10089 if (SecondDiffType == EndOfClass) {
10090 SecondLoc = SecondRecord->getBraceRange().getEnd();
10092 SecondLoc = SecondDecl->getLocation();
10093 SecondRange = SecondDecl->getSourceRange();
10095 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10096 << SecondModule << SecondRange << SecondDiffType;
10101 assert(FirstDiffType == SecondDiffType);
10103 // Used with err_module_odr_violation_mismatch_decl_diff and
10104 // note_module_odr_violation_mismatch_decl_diff
10105 enum ODRDeclDifference {
10106 StaticAssertCondition,
10107 StaticAssertMessage,
10108 StaticAssertOnlyMessage,
10111 FieldSingleBitField,
10112 FieldDifferentWidthBitField,
10113 FieldSingleMutable,
10114 FieldSingleInitializer,
10115 FieldDifferentInitializers,
10124 MethodNumberParameters,
10125 MethodParameterType,
10126 MethodParameterName,
10127 MethodParameterSingleDefaultArgument,
10128 MethodParameterDifferentDefaultArgument,
10129 MethodNoTemplateArguments,
10130 MethodDifferentNumberTemplateArguments,
10131 MethodDifferentTemplateArgument,
10133 MethodDifferentBody,
10138 VarSingleInitializer,
10139 VarDifferentInitializer,
10141 FriendTypeFunction,
10144 FunctionTemplateDifferentNumberParameters,
10145 FunctionTemplateParameterDifferentKind,
10146 FunctionTemplateParameterName,
10147 FunctionTemplateParameterSingleDefaultArgument,
10148 FunctionTemplateParameterDifferentDefaultArgument,
10149 FunctionTemplateParameterDifferentType,
10150 FunctionTemplatePackParameter,
10153 // These lambdas have the common portions of the ODR diagnostics. This
10154 // has the same return as Diag(), so addition parameters can be passed
10155 // in with operator<<
10156 auto ODRDiagError = [FirstRecord, &FirstModule, this](
10157 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10158 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
10159 << FirstRecord << FirstModule.empty() << FirstModule << Range
10162 auto ODRDiagNote = [&SecondModule, this](
10163 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10164 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
10165 << SecondModule << Range << DiffType;
10168 switch (FirstDiffType) {
10171 case PublicSpecifer:
10172 case PrivateSpecifer:
10173 case ProtectedSpecifer:
10174 llvm_unreachable("Invalid diff type");
10176 case StaticAssert: {
10177 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10178 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10180 Expr *FirstExpr = FirstSA->getAssertExpr();
10181 Expr *SecondExpr = SecondSA->getAssertExpr();
10182 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10183 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10184 if (FirstODRHash != SecondODRHash) {
10185 ODRDiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
10186 StaticAssertCondition);
10187 ODRDiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
10188 StaticAssertCondition);
10193 StringLiteral *FirstStr = FirstSA->getMessage();
10194 StringLiteral *SecondStr = SecondSA->getMessage();
10195 assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10196 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10197 SourceLocation FirstLoc, SecondLoc;
10198 SourceRange FirstRange, SecondRange;
10200 FirstLoc = FirstStr->getBeginLoc();
10201 FirstRange = FirstStr->getSourceRange();
10203 FirstLoc = FirstSA->getBeginLoc();
10204 FirstRange = FirstSA->getSourceRange();
10207 SecondLoc = SecondStr->getBeginLoc();
10208 SecondRange = SecondStr->getSourceRange();
10210 SecondLoc = SecondSA->getBeginLoc();
10211 SecondRange = SecondSA->getSourceRange();
10213 ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
10214 << (FirstStr == nullptr);
10215 ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
10216 << (SecondStr == nullptr);
10221 if (FirstStr && SecondStr &&
10222 FirstStr->getString() != SecondStr->getString()) {
10223 ODRDiagError(FirstStr->getBeginLoc(), FirstStr->getSourceRange(),
10224 StaticAssertMessage);
10225 ODRDiagNote(SecondStr->getBeginLoc(), SecondStr->getSourceRange(),
10226 StaticAssertMessage);
10233 FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10234 FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10235 IdentifierInfo *FirstII = FirstField->getIdentifier();
10236 IdentifierInfo *SecondII = SecondField->getIdentifier();
10237 if (FirstII->getName() != SecondII->getName()) {
10238 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10241 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10249 assert(getContext().hasSameType(FirstField->getType(),
10250 SecondField->getType()));
10252 QualType FirstType = FirstField->getType();
10253 QualType SecondType = SecondField->getType();
10254 if (ComputeQualTypeODRHash(FirstType) !=
10255 ComputeQualTypeODRHash(SecondType)) {
10256 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10258 << FirstII << FirstType;
10259 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10261 << SecondII << SecondType;
10267 const bool IsFirstBitField = FirstField->isBitField();
10268 const bool IsSecondBitField = SecondField->isBitField();
10269 if (IsFirstBitField != IsSecondBitField) {
10270 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10271 FieldSingleBitField)
10272 << FirstII << IsFirstBitField;
10273 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10274 FieldSingleBitField)
10275 << SecondII << IsSecondBitField;
10280 if (IsFirstBitField && IsSecondBitField) {
10281 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10282 FieldDifferentWidthBitField)
10283 << FirstII << FirstField->getBitWidth()->getSourceRange();
10284 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10285 FieldDifferentWidthBitField)
10286 << SecondII << SecondField->getBitWidth()->getSourceRange();
10291 const bool IsFirstMutable = FirstField->isMutable();
10292 const bool IsSecondMutable = SecondField->isMutable();
10293 if (IsFirstMutable != IsSecondMutable) {
10294 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10295 FieldSingleMutable)
10296 << FirstII << IsFirstMutable;
10297 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10298 FieldSingleMutable)
10299 << SecondII << IsSecondMutable;
10304 const Expr *FirstInitializer = FirstField->getInClassInitializer();
10305 const Expr *SecondInitializer = SecondField->getInClassInitializer();
10306 if ((!FirstInitializer && SecondInitializer) ||
10307 (FirstInitializer && !SecondInitializer)) {
10308 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10309 FieldSingleInitializer)
10310 << FirstII << (FirstInitializer != nullptr);
10311 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10312 FieldSingleInitializer)
10313 << SecondII << (SecondInitializer != nullptr);
10318 if (FirstInitializer && SecondInitializer) {
10319 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10320 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10321 if (FirstInitHash != SecondInitHash) {
10322 ODRDiagError(FirstField->getLocation(),
10323 FirstField->getSourceRange(),
10324 FieldDifferentInitializers)
10325 << FirstII << FirstInitializer->getSourceRange();
10326 ODRDiagNote(SecondField->getLocation(),
10327 SecondField->getSourceRange(),
10328 FieldDifferentInitializers)
10329 << SecondII << SecondInitializer->getSourceRange();
10344 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10345 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10346 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10349 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10350 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10351 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10352 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10353 auto FirstName = FirstMethod->getDeclName();
10354 auto SecondName = SecondMethod->getDeclName();
10355 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10356 ODRDiagError(FirstMethod->getLocation(),
10357 FirstMethod->getSourceRange(), MethodName)
10358 << FirstMethodType << FirstName;
10359 ODRDiagNote(SecondMethod->getLocation(),
10360 SecondMethod->getSourceRange(), MethodName)
10361 << SecondMethodType << SecondName;
10367 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10368 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10369 if (FirstDeleted != SecondDeleted) {
10370 ODRDiagError(FirstMethod->getLocation(),
10371 FirstMethod->getSourceRange(), MethodDeleted)
10372 << FirstMethodType << FirstName << FirstDeleted;
10374 ODRDiagNote(SecondMethod->getLocation(),
10375 SecondMethod->getSourceRange(), MethodDeleted)
10376 << SecondMethodType << SecondName << SecondDeleted;
10381 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10382 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10383 if (FirstDefaulted != SecondDefaulted) {
10384 ODRDiagError(FirstMethod->getLocation(),
10385 FirstMethod->getSourceRange(), MethodDefaulted)
10386 << FirstMethodType << FirstName << FirstDefaulted;
10388 ODRDiagNote(SecondMethod->getLocation(),
10389 SecondMethod->getSourceRange(), MethodDefaulted)
10390 << SecondMethodType << SecondName << SecondDefaulted;
10395 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10396 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10397 const bool FirstPure = FirstMethod->isPure();
10398 const bool SecondPure = SecondMethod->isPure();
10399 if ((FirstVirtual || SecondVirtual) &&
10400 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10401 ODRDiagError(FirstMethod->getLocation(),
10402 FirstMethod->getSourceRange(), MethodVirtual)
10403 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10404 ODRDiagNote(SecondMethod->getLocation(),
10405 SecondMethod->getSourceRange(), MethodVirtual)
10406 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10411 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10412 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10413 // class needs to be checked instead.
10414 const auto FirstStorage = FirstMethod->getStorageClass();
10415 const auto SecondStorage = SecondMethod->getStorageClass();
10416 const bool FirstStatic = FirstStorage == SC_Static;
10417 const bool SecondStatic = SecondStorage == SC_Static;
10418 if (FirstStatic != SecondStatic) {
10419 ODRDiagError(FirstMethod->getLocation(),
10420 FirstMethod->getSourceRange(), MethodStatic)
10421 << FirstMethodType << FirstName << FirstStatic;
10422 ODRDiagNote(SecondMethod->getLocation(),
10423 SecondMethod->getSourceRange(), MethodStatic)
10424 << SecondMethodType << SecondName << SecondStatic;
10429 const bool FirstVolatile = FirstMethod->isVolatile();
10430 const bool SecondVolatile = SecondMethod->isVolatile();
10431 if (FirstVolatile != SecondVolatile) {
10432 ODRDiagError(FirstMethod->getLocation(),
10433 FirstMethod->getSourceRange(), MethodVolatile)
10434 << FirstMethodType << FirstName << FirstVolatile;
10435 ODRDiagNote(SecondMethod->getLocation(),
10436 SecondMethod->getSourceRange(), MethodVolatile)
10437 << SecondMethodType << SecondName << SecondVolatile;
10442 const bool FirstConst = FirstMethod->isConst();
10443 const bool SecondConst = SecondMethod->isConst();
10444 if (FirstConst != SecondConst) {
10445 ODRDiagError(FirstMethod->getLocation(),
10446 FirstMethod->getSourceRange(), MethodConst)
10447 << FirstMethodType << FirstName << FirstConst;
10448 ODRDiagNote(SecondMethod->getLocation(),
10449 SecondMethod->getSourceRange(), MethodConst)
10450 << SecondMethodType << SecondName << SecondConst;
10455 const bool FirstInline = FirstMethod->isInlineSpecified();
10456 const bool SecondInline = SecondMethod->isInlineSpecified();
10457 if (FirstInline != SecondInline) {
10458 ODRDiagError(FirstMethod->getLocation(),
10459 FirstMethod->getSourceRange(), MethodInline)
10460 << FirstMethodType << FirstName << FirstInline;
10461 ODRDiagNote(SecondMethod->getLocation(),
10462 SecondMethod->getSourceRange(), MethodInline)
10463 << SecondMethodType << SecondName << SecondInline;
10468 const unsigned FirstNumParameters = FirstMethod->param_size();
10469 const unsigned SecondNumParameters = SecondMethod->param_size();
10470 if (FirstNumParameters != SecondNumParameters) {
10471 ODRDiagError(FirstMethod->getLocation(),
10472 FirstMethod->getSourceRange(), MethodNumberParameters)
10473 << FirstMethodType << FirstName << FirstNumParameters;
10474 ODRDiagNote(SecondMethod->getLocation(),
10475 SecondMethod->getSourceRange(), MethodNumberParameters)
10476 << SecondMethodType << SecondName << SecondNumParameters;
10481 // Need this status boolean to know when break out of the switch.
10482 bool ParameterMismatch = false;
10483 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10484 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10485 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10487 QualType FirstParamType = FirstParam->getType();
10488 QualType SecondParamType = SecondParam->getType();
10489 if (FirstParamType != SecondParamType &&
10490 ComputeQualTypeODRHash(FirstParamType) !=
10491 ComputeQualTypeODRHash(SecondParamType)) {
10492 if (const DecayedType *ParamDecayedType =
10493 FirstParamType->getAs<DecayedType>()) {
10494 ODRDiagError(FirstMethod->getLocation(),
10495 FirstMethod->getSourceRange(), MethodParameterType)
10496 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10497 << true << ParamDecayedType->getOriginalType();
10499 ODRDiagError(FirstMethod->getLocation(),
10500 FirstMethod->getSourceRange(), MethodParameterType)
10501 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10505 if (const DecayedType *ParamDecayedType =
10506 SecondParamType->getAs<DecayedType>()) {
10507 ODRDiagNote(SecondMethod->getLocation(),
10508 SecondMethod->getSourceRange(), MethodParameterType)
10509 << SecondMethodType << SecondName << (I + 1)
10510 << SecondParamType << true
10511 << ParamDecayedType->getOriginalType();
10513 ODRDiagNote(SecondMethod->getLocation(),
10514 SecondMethod->getSourceRange(), MethodParameterType)
10515 << SecondMethodType << SecondName << (I + 1)
10516 << SecondParamType << false;
10518 ParameterMismatch = true;
10522 DeclarationName FirstParamName = FirstParam->getDeclName();
10523 DeclarationName SecondParamName = SecondParam->getDeclName();
10524 if (FirstParamName != SecondParamName) {
10525 ODRDiagError(FirstMethod->getLocation(),
10526 FirstMethod->getSourceRange(), MethodParameterName)
10527 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10528 ODRDiagNote(SecondMethod->getLocation(),
10529 SecondMethod->getSourceRange(), MethodParameterName)
10530 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10531 ParameterMismatch = true;
10535 const Expr *FirstInit = FirstParam->getInit();
10536 const Expr *SecondInit = SecondParam->getInit();
10537 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10538 ODRDiagError(FirstMethod->getLocation(),
10539 FirstMethod->getSourceRange(),
10540 MethodParameterSingleDefaultArgument)
10541 << FirstMethodType << FirstName << (I + 1)
10542 << (FirstInit == nullptr)
10543 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10544 ODRDiagNote(SecondMethod->getLocation(),
10545 SecondMethod->getSourceRange(),
10546 MethodParameterSingleDefaultArgument)
10547 << SecondMethodType << SecondName << (I + 1)
10548 << (SecondInit == nullptr)
10549 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10550 ParameterMismatch = true;
10554 if (FirstInit && SecondInit &&
10555 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10556 ODRDiagError(FirstMethod->getLocation(),
10557 FirstMethod->getSourceRange(),
10558 MethodParameterDifferentDefaultArgument)
10559 << FirstMethodType << FirstName << (I + 1)
10560 << FirstInit->getSourceRange();
10561 ODRDiagNote(SecondMethod->getLocation(),
10562 SecondMethod->getSourceRange(),
10563 MethodParameterDifferentDefaultArgument)
10564 << SecondMethodType << SecondName << (I + 1)
10565 << SecondInit->getSourceRange();
10566 ParameterMismatch = true;
10572 if (ParameterMismatch) {
10577 const auto *FirstTemplateArgs =
10578 FirstMethod->getTemplateSpecializationArgs();
10579 const auto *SecondTemplateArgs =
10580 SecondMethod->getTemplateSpecializationArgs();
10582 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10583 (!FirstTemplateArgs && SecondTemplateArgs)) {
10584 ODRDiagError(FirstMethod->getLocation(),
10585 FirstMethod->getSourceRange(), MethodNoTemplateArguments)
10586 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10587 ODRDiagNote(SecondMethod->getLocation(),
10588 SecondMethod->getSourceRange(), MethodNoTemplateArguments)
10589 << SecondMethodType << SecondName
10590 << (SecondTemplateArgs != nullptr);
10596 if (FirstTemplateArgs && SecondTemplateArgs) {
10597 // Remove pack expansions from argument list.
10598 auto ExpandTemplateArgumentList =
10599 [](const TemplateArgumentList *TAL) {
10600 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10601 for (const TemplateArgument &TA : TAL->asArray()) {
10602 if (TA.getKind() != TemplateArgument::Pack) {
10603 ExpandedList.push_back(&TA);
10606 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10607 ExpandedList.push_back(&PackTA);
10610 return ExpandedList;
10612 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10613 ExpandTemplateArgumentList(FirstTemplateArgs);
10614 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10615 ExpandTemplateArgumentList(SecondTemplateArgs);
10617 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10618 ODRDiagError(FirstMethod->getLocation(),
10619 FirstMethod->getSourceRange(),
10620 MethodDifferentNumberTemplateArguments)
10621 << FirstMethodType << FirstName
10622 << (unsigned)FirstExpandedList.size();
10623 ODRDiagNote(SecondMethod->getLocation(),
10624 SecondMethod->getSourceRange(),
10625 MethodDifferentNumberTemplateArguments)
10626 << SecondMethodType << SecondName
10627 << (unsigned)SecondExpandedList.size();
10633 bool TemplateArgumentMismatch = false;
10634 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10635 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10636 &SecondTA = *SecondExpandedList[i];
10637 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10638 ComputeTemplateArgumentODRHash(SecondTA)) {
10642 ODRDiagError(FirstMethod->getLocation(),
10643 FirstMethod->getSourceRange(),
10644 MethodDifferentTemplateArgument)
10645 << FirstMethodType << FirstName << FirstTA << i + 1;
10646 ODRDiagNote(SecondMethod->getLocation(),
10647 SecondMethod->getSourceRange(),
10648 MethodDifferentTemplateArgument)
10649 << SecondMethodType << SecondName << SecondTA << i + 1;
10651 TemplateArgumentMismatch = true;
10655 if (TemplateArgumentMismatch) {
10661 // Compute the hash of the method as if it has no body.
10662 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10664 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10665 return Hash.CalculateHash();
10668 // Compare the hash generated to the hash stored. A difference means
10669 // that a body was present in the original source. Due to merging,
10670 // the stardard way of detecting a body will not work.
10671 const bool HasFirstBody =
10672 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10673 const bool HasSecondBody =
10674 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10676 if (HasFirstBody != HasSecondBody) {
10677 ODRDiagError(FirstMethod->getLocation(),
10678 FirstMethod->getSourceRange(), MethodSingleBody)
10679 << FirstMethodType << FirstName << HasFirstBody;
10680 ODRDiagNote(SecondMethod->getLocation(),
10681 SecondMethod->getSourceRange(), MethodSingleBody)
10682 << SecondMethodType << SecondName << HasSecondBody;
10687 if (HasFirstBody && HasSecondBody) {
10688 ODRDiagError(FirstMethod->getLocation(),
10689 FirstMethod->getSourceRange(), MethodDifferentBody)
10690 << FirstMethodType << FirstName;
10691 ODRDiagNote(SecondMethod->getLocation(),
10692 SecondMethod->getSourceRange(), MethodDifferentBody)
10693 << SecondMethodType << SecondName;
10702 TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10703 TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10704 auto FirstName = FirstTD->getDeclName();
10705 auto SecondName = SecondTD->getDeclName();
10706 if (FirstName != SecondName) {
10707 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10709 << (FirstDiffType == TypeAlias) << FirstName;
10710 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10712 << (FirstDiffType == TypeAlias) << SecondName;
10717 QualType FirstType = FirstTD->getUnderlyingType();
10718 QualType SecondType = SecondTD->getUnderlyingType();
10719 if (ComputeQualTypeODRHash(FirstType) !=
10720 ComputeQualTypeODRHash(SecondType)) {
10721 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10723 << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10724 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10726 << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10733 VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10734 VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10735 auto FirstName = FirstVD->getDeclName();
10736 auto SecondName = SecondVD->getDeclName();
10737 if (FirstName != SecondName) {
10738 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10741 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10748 QualType FirstType = FirstVD->getType();
10749 QualType SecondType = SecondVD->getType();
10750 if (ComputeQualTypeODRHash(FirstType) !=
10751 ComputeQualTypeODRHash(SecondType)) {
10752 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10754 << FirstName << FirstType;
10755 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10757 << SecondName << SecondType;
10762 const Expr *FirstInit = FirstVD->getInit();
10763 const Expr *SecondInit = SecondVD->getInit();
10764 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10765 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10766 VarSingleInitializer)
10767 << FirstName << (FirstInit == nullptr)
10768 << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10769 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10770 VarSingleInitializer)
10771 << SecondName << (SecondInit == nullptr)
10772 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10777 if (FirstInit && SecondInit &&
10778 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10779 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10780 VarDifferentInitializer)
10781 << FirstName << FirstInit->getSourceRange();
10782 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10783 VarDifferentInitializer)
10784 << SecondName << SecondInit->getSourceRange();
10789 const bool FirstIsConstexpr = FirstVD->isConstexpr();
10790 const bool SecondIsConstexpr = SecondVD->isConstexpr();
10791 if (FirstIsConstexpr != SecondIsConstexpr) {
10792 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10794 << FirstName << FirstIsConstexpr;
10795 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10797 << SecondName << SecondIsConstexpr;
10804 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10805 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10807 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10808 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10810 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10811 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10813 if (FirstND && SecondND) {
10814 ODRDiagError(FirstFriend->getFriendLoc(),
10815 FirstFriend->getSourceRange(), FriendFunction)
10817 ODRDiagNote(SecondFriend->getFriendLoc(),
10818 SecondFriend->getSourceRange(), FriendFunction)
10825 if (FirstTSI && SecondTSI) {
10826 QualType FirstFriendType = FirstTSI->getType();
10827 QualType SecondFriendType = SecondTSI->getType();
10828 assert(ComputeQualTypeODRHash(FirstFriendType) !=
10829 ComputeQualTypeODRHash(SecondFriendType));
10830 ODRDiagError(FirstFriend->getFriendLoc(),
10831 FirstFriend->getSourceRange(), FriendType)
10832 << FirstFriendType;
10833 ODRDiagNote(SecondFriend->getFriendLoc(),
10834 SecondFriend->getSourceRange(), FriendType)
10835 << SecondFriendType;
10840 ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10841 FriendTypeFunction)
10842 << (FirstTSI == nullptr);
10843 ODRDiagNote(SecondFriend->getFriendLoc(),
10844 SecondFriend->getSourceRange(), FriendTypeFunction)
10845 << (SecondTSI == nullptr);
10850 case FunctionTemplate: {
10851 FunctionTemplateDecl *FirstTemplate =
10852 cast<FunctionTemplateDecl>(FirstDecl);
10853 FunctionTemplateDecl *SecondTemplate =
10854 cast<FunctionTemplateDecl>(SecondDecl);
10856 TemplateParameterList *FirstTPL =
10857 FirstTemplate->getTemplateParameters();
10858 TemplateParameterList *SecondTPL =
10859 SecondTemplate->getTemplateParameters();
10861 if (FirstTPL->size() != SecondTPL->size()) {
10862 ODRDiagError(FirstTemplate->getLocation(),
10863 FirstTemplate->getSourceRange(),
10864 FunctionTemplateDifferentNumberParameters)
10865 << FirstTemplate << FirstTPL->size();
10866 ODRDiagNote(SecondTemplate->getLocation(),
10867 SecondTemplate->getSourceRange(),
10868 FunctionTemplateDifferentNumberParameters)
10869 << SecondTemplate << SecondTPL->size();
10875 bool ParameterMismatch = false;
10876 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10877 NamedDecl *FirstParam = FirstTPL->getParam(i);
10878 NamedDecl *SecondParam = SecondTPL->getParam(i);
10880 if (FirstParam->getKind() != SecondParam->getKind()) {
10882 TemplateTypeParameter,
10883 NonTypeTemplateParameter,
10884 TemplateTemplateParameter,
10886 auto GetParamType = [](NamedDecl *D) {
10887 switch (D->getKind()) {
10889 llvm_unreachable("Unexpected template parameter type");
10890 case Decl::TemplateTypeParm:
10891 return TemplateTypeParameter;
10892 case Decl::NonTypeTemplateParm:
10893 return NonTypeTemplateParameter;
10894 case Decl::TemplateTemplateParm:
10895 return TemplateTemplateParameter;
10899 ODRDiagError(FirstTemplate->getLocation(),
10900 FirstTemplate->getSourceRange(),
10901 FunctionTemplateParameterDifferentKind)
10902 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10903 ODRDiagNote(SecondTemplate->getLocation(),
10904 SecondTemplate->getSourceRange(),
10905 FunctionTemplateParameterDifferentKind)
10906 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10908 ParameterMismatch = true;
10912 if (FirstParam->getName() != SecondParam->getName()) {
10913 ODRDiagError(FirstTemplate->getLocation(),
10914 FirstTemplate->getSourceRange(),
10915 FunctionTemplateParameterName)
10916 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10918 ODRDiagNote(SecondTemplate->getLocation(),
10919 SecondTemplate->getSourceRange(),
10920 FunctionTemplateParameterName)
10921 << SecondTemplate << (i + 1)
10922 << (bool)SecondParam->getIdentifier() << SecondParam;
10923 ParameterMismatch = true;
10927 if (isa<TemplateTypeParmDecl>(FirstParam) &&
10928 isa<TemplateTypeParmDecl>(SecondParam)) {
10929 TemplateTypeParmDecl *FirstTTPD =
10930 cast<TemplateTypeParmDecl>(FirstParam);
10931 TemplateTypeParmDecl *SecondTTPD =
10932 cast<TemplateTypeParmDecl>(SecondParam);
10933 bool HasFirstDefaultArgument =
10934 FirstTTPD->hasDefaultArgument() &&
10935 !FirstTTPD->defaultArgumentWasInherited();
10936 bool HasSecondDefaultArgument =
10937 SecondTTPD->hasDefaultArgument() &&
10938 !SecondTTPD->defaultArgumentWasInherited();
10939 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10940 ODRDiagError(FirstTemplate->getLocation(),
10941 FirstTemplate->getSourceRange(),
10942 FunctionTemplateParameterSingleDefaultArgument)
10943 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10944 ODRDiagNote(SecondTemplate->getLocation(),
10945 SecondTemplate->getSourceRange(),
10946 FunctionTemplateParameterSingleDefaultArgument)
10947 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
10948 ParameterMismatch = true;
10952 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
10953 QualType FirstType = FirstTTPD->getDefaultArgument();
10954 QualType SecondType = SecondTTPD->getDefaultArgument();
10955 if (ComputeQualTypeODRHash(FirstType) !=
10956 ComputeQualTypeODRHash(SecondType)) {
10957 ODRDiagError(FirstTemplate->getLocation(),
10958 FirstTemplate->getSourceRange(),
10959 FunctionTemplateParameterDifferentDefaultArgument)
10960 << FirstTemplate << (i + 1) << FirstType;
10961 ODRDiagNote(SecondTemplate->getLocation(),
10962 SecondTemplate->getSourceRange(),
10963 FunctionTemplateParameterDifferentDefaultArgument)
10964 << SecondTemplate << (i + 1) << SecondType;
10965 ParameterMismatch = true;
10970 if (FirstTTPD->isParameterPack() !=
10971 SecondTTPD->isParameterPack()) {
10972 ODRDiagError(FirstTemplate->getLocation(),
10973 FirstTemplate->getSourceRange(),
10974 FunctionTemplatePackParameter)
10975 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
10976 ODRDiagNote(SecondTemplate->getLocation(),
10977 SecondTemplate->getSourceRange(),
10978 FunctionTemplatePackParameter)
10979 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
10980 ParameterMismatch = true;
10985 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
10986 isa<TemplateTemplateParmDecl>(SecondParam)) {
10987 TemplateTemplateParmDecl *FirstTTPD =
10988 cast<TemplateTemplateParmDecl>(FirstParam);
10989 TemplateTemplateParmDecl *SecondTTPD =
10990 cast<TemplateTemplateParmDecl>(SecondParam);
10992 TemplateParameterList *FirstTPL =
10993 FirstTTPD->getTemplateParameters();
10994 TemplateParameterList *SecondTPL =
10995 SecondTTPD->getTemplateParameters();
10997 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
10998 ComputeTemplateParameterListODRHash(SecondTPL)) {
10999 ODRDiagError(FirstTemplate->getLocation(),
11000 FirstTemplate->getSourceRange(),
11001 FunctionTemplateParameterDifferentType)
11002 << FirstTemplate << (i + 1);
11003 ODRDiagNote(SecondTemplate->getLocation(),
11004 SecondTemplate->getSourceRange(),
11005 FunctionTemplateParameterDifferentType)
11006 << SecondTemplate << (i + 1);
11007 ParameterMismatch = true;
11011 bool HasFirstDefaultArgument =
11012 FirstTTPD->hasDefaultArgument() &&
11013 !FirstTTPD->defaultArgumentWasInherited();
11014 bool HasSecondDefaultArgument =
11015 SecondTTPD->hasDefaultArgument() &&
11016 !SecondTTPD->defaultArgumentWasInherited();
11017 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11018 ODRDiagError(FirstTemplate->getLocation(),
11019 FirstTemplate->getSourceRange(),
11020 FunctionTemplateParameterSingleDefaultArgument)
11021 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11022 ODRDiagNote(SecondTemplate->getLocation(),
11023 SecondTemplate->getSourceRange(),
11024 FunctionTemplateParameterSingleDefaultArgument)
11025 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11026 ParameterMismatch = true;
11030 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11031 TemplateArgument FirstTA =
11032 FirstTTPD->getDefaultArgument().getArgument();
11033 TemplateArgument SecondTA =
11034 SecondTTPD->getDefaultArgument().getArgument();
11035 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11036 ComputeTemplateArgumentODRHash(SecondTA)) {
11037 ODRDiagError(FirstTemplate->getLocation(),
11038 FirstTemplate->getSourceRange(),
11039 FunctionTemplateParameterDifferentDefaultArgument)
11040 << FirstTemplate << (i + 1) << FirstTA;
11041 ODRDiagNote(SecondTemplate->getLocation(),
11042 SecondTemplate->getSourceRange(),
11043 FunctionTemplateParameterDifferentDefaultArgument)
11044 << SecondTemplate << (i + 1) << SecondTA;
11045 ParameterMismatch = true;
11050 if (FirstTTPD->isParameterPack() !=
11051 SecondTTPD->isParameterPack()) {
11052 ODRDiagError(FirstTemplate->getLocation(),
11053 FirstTemplate->getSourceRange(),
11054 FunctionTemplatePackParameter)
11055 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11056 ODRDiagNote(SecondTemplate->getLocation(),
11057 SecondTemplate->getSourceRange(),
11058 FunctionTemplatePackParameter)
11059 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11060 ParameterMismatch = true;
11065 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11066 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11067 NonTypeTemplateParmDecl *FirstNTTPD =
11068 cast<NonTypeTemplateParmDecl>(FirstParam);
11069 NonTypeTemplateParmDecl *SecondNTTPD =
11070 cast<NonTypeTemplateParmDecl>(SecondParam);
11072 QualType FirstType = FirstNTTPD->getType();
11073 QualType SecondType = SecondNTTPD->getType();
11074 if (ComputeQualTypeODRHash(FirstType) !=
11075 ComputeQualTypeODRHash(SecondType)) {
11076 ODRDiagError(FirstTemplate->getLocation(),
11077 FirstTemplate->getSourceRange(),
11078 FunctionTemplateParameterDifferentType)
11079 << FirstTemplate << (i + 1);
11080 ODRDiagNote(SecondTemplate->getLocation(),
11081 SecondTemplate->getSourceRange(),
11082 FunctionTemplateParameterDifferentType)
11083 << SecondTemplate << (i + 1);
11084 ParameterMismatch = true;
11088 bool HasFirstDefaultArgument =
11089 FirstNTTPD->hasDefaultArgument() &&
11090 !FirstNTTPD->defaultArgumentWasInherited();
11091 bool HasSecondDefaultArgument =
11092 SecondNTTPD->hasDefaultArgument() &&
11093 !SecondNTTPD->defaultArgumentWasInherited();
11094 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11095 ODRDiagError(FirstTemplate->getLocation(),
11096 FirstTemplate->getSourceRange(),
11097 FunctionTemplateParameterSingleDefaultArgument)
11098 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11099 ODRDiagNote(SecondTemplate->getLocation(),
11100 SecondTemplate->getSourceRange(),
11101 FunctionTemplateParameterSingleDefaultArgument)
11102 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11103 ParameterMismatch = true;
11107 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11108 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11109 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11110 if (ComputeODRHash(FirstDefaultArgument) !=
11111 ComputeODRHash(SecondDefaultArgument)) {
11112 ODRDiagError(FirstTemplate->getLocation(),
11113 FirstTemplate->getSourceRange(),
11114 FunctionTemplateParameterDifferentDefaultArgument)
11115 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11116 ODRDiagNote(SecondTemplate->getLocation(),
11117 SecondTemplate->getSourceRange(),
11118 FunctionTemplateParameterDifferentDefaultArgument)
11119 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11120 ParameterMismatch = true;
11125 if (FirstNTTPD->isParameterPack() !=
11126 SecondNTTPD->isParameterPack()) {
11127 ODRDiagError(FirstTemplate->getLocation(),
11128 FirstTemplate->getSourceRange(),
11129 FunctionTemplatePackParameter)
11130 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11131 ODRDiagNote(SecondTemplate->getLocation(),
11132 SecondTemplate->getSourceRange(),
11133 FunctionTemplatePackParameter)
11134 << SecondTemplate << (i + 1)
11135 << SecondNTTPD->isParameterPack();
11136 ParameterMismatch = true;
11142 if (ParameterMismatch) {
11154 Diag(FirstDecl->getLocation(),
11155 diag::err_module_odr_violation_mismatch_decl_unknown)
11156 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11157 << FirstDecl->getSourceRange();
11158 Diag(SecondDecl->getLocation(),
11159 diag::note_module_odr_violation_mismatch_decl_unknown)
11160 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11165 // All definitions are updates to the same declaration. This happens if a
11166 // module instantiates the declaration of a class template specialization
11167 // and two or more other modules instantiate its definition.
11169 // FIXME: Indicate which modules had instantiations of this definition.
11170 // FIXME: How can this even happen?
11171 Diag(Merge.first->getLocation(),
11172 diag::err_module_odr_violation_different_instantiations)
11177 // Issue ODR failures diagnostics for functions.
11178 for (auto &Merge : FunctionOdrMergeFailures) {
11179 enum ODRFunctionDifference {
11183 ParameterSingleDefaultArgument,
11184 ParameterDifferentDefaultArgument,
11188 FunctionDecl *FirstFunction = Merge.first;
11189 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11191 bool Diagnosed = false;
11192 for (auto &SecondFunction : Merge.second) {
11194 if (FirstFunction == SecondFunction)
11197 std::string SecondModule =
11198 getOwningModuleNameForDiagnostic(SecondFunction);
11200 auto ODRDiagError = [FirstFunction, &FirstModule,
11201 this](SourceLocation Loc, SourceRange Range,
11202 ODRFunctionDifference DiffType) {
11203 return Diag(Loc, diag::err_module_odr_violation_function)
11204 << FirstFunction << FirstModule.empty() << FirstModule << Range
11207 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11209 ODRFunctionDifference DiffType) {
11210 return Diag(Loc, diag::note_module_odr_violation_function)
11211 << SecondModule << Range << DiffType;
11214 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11215 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11216 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11217 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11218 << FirstFunction->getReturnType();
11219 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11220 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11221 << SecondFunction->getReturnType();
11226 assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11227 "Merged functions with different number of parameters");
11229 auto ParamSize = FirstFunction->param_size();
11230 bool ParameterMismatch = false;
11231 for (unsigned I = 0; I < ParamSize; ++I) {
11232 auto *FirstParam = FirstFunction->getParamDecl(I);
11233 auto *SecondParam = SecondFunction->getParamDecl(I);
11235 assert(getContext().hasSameType(FirstParam->getType(),
11236 SecondParam->getType()) &&
11237 "Merged function has different parameter types.");
11239 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11240 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11242 << I + 1 << FirstParam->getDeclName();
11243 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11245 << I + 1 << SecondParam->getDeclName();
11246 ParameterMismatch = true;
11250 QualType FirstParamType = FirstParam->getType();
11251 QualType SecondParamType = SecondParam->getType();
11252 if (FirstParamType != SecondParamType &&
11253 ComputeQualTypeODRHash(FirstParamType) !=
11254 ComputeQualTypeODRHash(SecondParamType)) {
11255 if (const DecayedType *ParamDecayedType =
11256 FirstParamType->getAs<DecayedType>()) {
11257 ODRDiagError(FirstParam->getLocation(),
11258 FirstParam->getSourceRange(), ParameterType)
11259 << (I + 1) << FirstParamType << true
11260 << ParamDecayedType->getOriginalType();
11262 ODRDiagError(FirstParam->getLocation(),
11263 FirstParam->getSourceRange(), ParameterType)
11264 << (I + 1) << FirstParamType << false;
11267 if (const DecayedType *ParamDecayedType =
11268 SecondParamType->getAs<DecayedType>()) {
11269 ODRDiagNote(SecondParam->getLocation(),
11270 SecondParam->getSourceRange(), ParameterType)
11271 << (I + 1) << SecondParamType << true
11272 << ParamDecayedType->getOriginalType();
11274 ODRDiagNote(SecondParam->getLocation(),
11275 SecondParam->getSourceRange(), ParameterType)
11276 << (I + 1) << SecondParamType << false;
11278 ParameterMismatch = true;
11282 const Expr *FirstInit = FirstParam->getInit();
11283 const Expr *SecondInit = SecondParam->getInit();
11284 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11285 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11286 ParameterSingleDefaultArgument)
11287 << (I + 1) << (FirstInit == nullptr)
11288 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11289 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11290 ParameterSingleDefaultArgument)
11291 << (I + 1) << (SecondInit == nullptr)
11292 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11293 ParameterMismatch = true;
11297 if (FirstInit && SecondInit &&
11298 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11299 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11300 ParameterDifferentDefaultArgument)
11301 << (I + 1) << FirstInit->getSourceRange();
11302 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11303 ParameterDifferentDefaultArgument)
11304 << (I + 1) << SecondInit->getSourceRange();
11305 ParameterMismatch = true;
11309 assert(ComputeSubDeclODRHash(FirstParam) ==
11310 ComputeSubDeclODRHash(SecondParam) &&
11311 "Undiagnosed parameter difference.");
11314 if (ParameterMismatch) {
11319 // If no error has been generated before now, assume the problem is in
11320 // the body and generate a message.
11321 ODRDiagError(FirstFunction->getLocation(),
11322 FirstFunction->getSourceRange(), FunctionBody);
11323 ODRDiagNote(SecondFunction->getLocation(),
11324 SecondFunction->getSourceRange(), FunctionBody);
11329 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11332 // Issue ODR failures diagnostics for enums.
11333 for (auto &Merge : EnumOdrMergeFailures) {
11334 enum ODREnumDifference {
11336 EnumTagKeywordMismatch,
11337 SingleSpecifiedType,
11338 DifferentSpecifiedTypes,
11339 DifferentNumberEnumConstants,
11341 EnumConstantSingleInitilizer,
11342 EnumConstantDifferentInitilizer,
11345 // If we've already pointed out a specific problem with this enum, don't
11346 // bother issuing a general "something's different" diagnostic.
11347 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11350 EnumDecl *FirstEnum = Merge.first;
11351 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11354 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11355 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11356 DeclHashes &Hashes, EnumDecl *Enum) {
11357 for (auto *D : Enum->decls()) {
11358 // Due to decl merging, the first EnumDecl is the parent of
11359 // Decls in both records.
11360 if (!ODRHash::isWhitelistedDecl(D, FirstEnum))
11362 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11363 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11364 ComputeSubDeclODRHash(D));
11367 DeclHashes FirstHashes;
11368 PopulateHashes(FirstHashes, FirstEnum);
11369 bool Diagnosed = false;
11370 for (auto &SecondEnum : Merge.second) {
11372 if (FirstEnum == SecondEnum)
11375 std::string SecondModule =
11376 getOwningModuleNameForDiagnostic(SecondEnum);
11378 auto ODRDiagError = [FirstEnum, &FirstModule,
11379 this](SourceLocation Loc, SourceRange Range,
11380 ODREnumDifference DiffType) {
11381 return Diag(Loc, diag::err_module_odr_violation_enum)
11382 << FirstEnum << FirstModule.empty() << FirstModule << Range
11385 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11387 ODREnumDifference DiffType) {
11388 return Diag(Loc, diag::note_module_odr_violation_enum)
11389 << SecondModule << Range << DiffType;
11392 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11393 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11395 << FirstEnum->isScoped();
11396 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11398 << SecondEnum->isScoped();
11403 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11404 if (FirstEnum->isScopedUsingClassTag() !=
11405 SecondEnum->isScopedUsingClassTag()) {
11406 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11407 EnumTagKeywordMismatch)
11408 << FirstEnum->isScopedUsingClassTag();
11409 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11410 EnumTagKeywordMismatch)
11411 << SecondEnum->isScopedUsingClassTag();
11417 QualType FirstUnderlyingType =
11418 FirstEnum->getIntegerTypeSourceInfo()
11419 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11421 QualType SecondUnderlyingType =
11422 SecondEnum->getIntegerTypeSourceInfo()
11423 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11425 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11426 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11427 SingleSpecifiedType)
11428 << !FirstUnderlyingType.isNull();
11429 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11430 SingleSpecifiedType)
11431 << !SecondUnderlyingType.isNull();
11436 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11437 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11438 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11439 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11440 DifferentSpecifiedTypes)
11441 << FirstUnderlyingType;
11442 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11443 DifferentSpecifiedTypes)
11444 << SecondUnderlyingType;
11450 DeclHashes SecondHashes;
11451 PopulateHashes(SecondHashes, SecondEnum);
11453 if (FirstHashes.size() != SecondHashes.size()) {
11454 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11455 DifferentNumberEnumConstants)
11456 << (int)FirstHashes.size();
11457 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11458 DifferentNumberEnumConstants)
11459 << (int)SecondHashes.size();
11464 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11465 if (FirstHashes[I].second == SecondHashes[I].second)
11467 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11468 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11470 if (FirstEnumConstant->getDeclName() !=
11471 SecondEnumConstant->getDeclName()) {
11473 ODRDiagError(FirstEnumConstant->getLocation(),
11474 FirstEnumConstant->getSourceRange(), EnumConstantName)
11475 << I + 1 << FirstEnumConstant;
11476 ODRDiagNote(SecondEnumConstant->getLocation(),
11477 SecondEnumConstant->getSourceRange(), EnumConstantName)
11478 << I + 1 << SecondEnumConstant;
11483 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11484 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11485 if (!FirstInit && !SecondInit)
11488 if (!FirstInit || !SecondInit) {
11489 ODRDiagError(FirstEnumConstant->getLocation(),
11490 FirstEnumConstant->getSourceRange(),
11491 EnumConstantSingleInitilizer)
11492 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11493 ODRDiagNote(SecondEnumConstant->getLocation(),
11494 SecondEnumConstant->getSourceRange(),
11495 EnumConstantSingleInitilizer)
11496 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11501 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11502 ODRDiagError(FirstEnumConstant->getLocation(),
11503 FirstEnumConstant->getSourceRange(),
11504 EnumConstantDifferentInitilizer)
11505 << I + 1 << FirstEnumConstant;
11506 ODRDiagNote(SecondEnumConstant->getLocation(),
11507 SecondEnumConstant->getSourceRange(),
11508 EnumConstantDifferentInitilizer)
11509 << I + 1 << SecondEnumConstant;
11517 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11521 void ASTReader::StartedDeserializing() {
11522 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11523 ReadTimer->startTimer();
11526 void ASTReader::FinishedDeserializing() {
11527 assert(NumCurrentElementsDeserializing &&
11528 "FinishedDeserializing not paired with StartedDeserializing");
11529 if (NumCurrentElementsDeserializing == 1) {
11530 // We decrease NumCurrentElementsDeserializing only after pending actions
11531 // are finished, to avoid recursively re-calling finishPendingActions().
11532 finishPendingActions();
11534 --NumCurrentElementsDeserializing;
11536 if (NumCurrentElementsDeserializing == 0) {
11537 // Propagate exception specification and deduced type updates along
11538 // redeclaration chains.
11540 // We do this now rather than in finishPendingActions because we want to
11541 // be able to walk the complete redeclaration chains of the updated decls.
11542 while (!PendingExceptionSpecUpdates.empty() ||
11543 !PendingDeducedTypeUpdates.empty()) {
11544 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
11545 PendingExceptionSpecUpdates.clear();
11546 for (auto Update : ESUpdates) {
11547 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11548 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11549 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11550 if (auto *Listener = getContext().getASTMutationListener())
11551 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11552 for (auto *Redecl : Update.second->redecls())
11553 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11556 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
11557 PendingDeducedTypeUpdates.clear();
11558 for (auto Update : DTUpdates) {
11559 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11560 // FIXME: If the return type is already deduced, check that it matches.
11561 getContext().adjustDeducedFunctionResultType(Update.first,
11567 ReadTimer->stopTimer();
11569 diagnoseOdrViolations();
11571 // We are not in recursive loading, so it's safe to pass the "interesting"
11572 // decls to the consumer.
11574 PassInterestingDeclsToConsumer();
11578 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11579 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11580 // Remove any fake results before adding any real ones.
11581 auto It = PendingFakeLookupResults.find(II);
11582 if (It != PendingFakeLookupResults.end()) {
11583 for (auto *ND : It->second)
11584 SemaObj->IdResolver.RemoveDecl(ND);
11585 // FIXME: this works around module+PCH performance issue.
11586 // Rather than erase the result from the map, which is O(n), just clear
11587 // the vector of NamedDecls.
11588 It->second.clear();
11592 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11593 SemaObj->TUScope->AddDecl(D);
11594 } else if (SemaObj->TUScope) {
11595 // Adding the decl to IdResolver may have failed because it was already in
11596 // (even though it was not added in scope). If it is already in, make sure
11597 // it gets in the scope as well.
11598 if (std::find(SemaObj->IdResolver.begin(Name),
11599 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11600 SemaObj->TUScope->AddDecl(D);
11604 ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
11605 const PCHContainerReader &PCHContainerRdr,
11606 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11607 StringRef isysroot, bool DisableValidation,
11608 bool AllowASTWithCompilerErrors,
11609 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11610 bool UseGlobalIndex,
11611 std::unique_ptr<llvm::Timer> ReadTimer)
11612 : Listener(DisableValidation
11613 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11614 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11615 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11616 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11617 ContextObj(Context),
11618 ModuleMgr(PP.getFileManager(), PP.getPCMCache(), PCHContainerRdr,
11619 PP.getHeaderSearchInfo()),
11620 PCMCache(PP.getPCMCache()), DummyIdResolver(PP),
11621 ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11622 DisableValidation(DisableValidation),
11623 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11624 AllowConfigurationMismatch(AllowConfigurationMismatch),
11625 ValidateSystemInputs(ValidateSystemInputs),
11626 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11627 SourceMgr.setExternalSLocEntrySource(this);
11629 for (const auto &Ext : Extensions) {
11630 auto BlockName = Ext->getExtensionMetadata().BlockName;
11631 auto Known = ModuleFileExtensions.find(BlockName);
11632 if (Known != ModuleFileExtensions.end()) {
11633 Diags.Report(diag::warn_duplicate_module_file_extension)
11638 ModuleFileExtensions.insert({BlockName, Ext});
11642 ASTReader::~ASTReader() {
11643 if (OwnsDeserializationListener)
11644 delete DeserializationListener;
11647 IdentifierResolver &ASTReader::getIdResolver() {
11648 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11651 unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11652 unsigned AbbrevID) {
11655 return Cursor.readRecord(AbbrevID, Record);
11657 //===----------------------------------------------------------------------===//
11658 //// OMPClauseReader implementation
11659 ////===----------------------------------------------------------------------===//
11661 OMPClause *OMPClauseReader::readClause() {
11663 switch (Record.readInt()) {
11665 C = new (Context) OMPIfClause();
11668 C = new (Context) OMPFinalClause();
11670 case OMPC_num_threads:
11671 C = new (Context) OMPNumThreadsClause();
11674 C = new (Context) OMPSafelenClause();
11677 C = new (Context) OMPSimdlenClause();
11679 case OMPC_collapse:
11680 C = new (Context) OMPCollapseClause();
11683 C = new (Context) OMPDefaultClause();
11685 case OMPC_proc_bind:
11686 C = new (Context) OMPProcBindClause();
11688 case OMPC_schedule:
11689 C = new (Context) OMPScheduleClause();
11692 C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
11695 C = new (Context) OMPNowaitClause();
11698 C = new (Context) OMPUntiedClause();
11700 case OMPC_mergeable:
11701 C = new (Context) OMPMergeableClause();
11704 C = new (Context) OMPReadClause();
11707 C = new (Context) OMPWriteClause();
11710 C = new (Context) OMPUpdateClause();
11713 C = new (Context) OMPCaptureClause();
11716 C = new (Context) OMPSeqCstClause();
11719 C = new (Context) OMPThreadsClause();
11722 C = new (Context) OMPSIMDClause();
11725 C = new (Context) OMPNogroupClause();
11727 case OMPC_unified_address:
11728 C = new (Context) OMPUnifiedAddressClause();
11730 case OMPC_unified_shared_memory:
11731 C = new (Context) OMPUnifiedSharedMemoryClause();
11733 case OMPC_reverse_offload:
11734 C = new (Context) OMPReverseOffloadClause();
11736 case OMPC_dynamic_allocators:
11737 C = new (Context) OMPDynamicAllocatorsClause();
11739 case OMPC_atomic_default_mem_order:
11740 C = new (Context) OMPAtomicDefaultMemOrderClause();
11743 C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
11745 case OMPC_firstprivate:
11746 C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
11748 case OMPC_lastprivate:
11749 C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
11752 C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
11754 case OMPC_reduction:
11755 C = OMPReductionClause::CreateEmpty(Context, Record.readInt());
11757 case OMPC_task_reduction:
11758 C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
11760 case OMPC_in_reduction:
11761 C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
11764 C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
11767 C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
11770 C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
11772 case OMPC_copyprivate:
11773 C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
11776 C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
11778 case OMPC_depend: {
11779 unsigned NumVars = Record.readInt();
11780 unsigned NumLoops = Record.readInt();
11781 C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
11785 C = new (Context) OMPDeviceClause();
11788 unsigned NumVars = Record.readInt();
11789 unsigned NumDeclarations = Record.readInt();
11790 unsigned NumLists = Record.readInt();
11791 unsigned NumComponents = Record.readInt();
11792 C = OMPMapClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
11796 case OMPC_num_teams:
11797 C = new (Context) OMPNumTeamsClause();
11799 case OMPC_thread_limit:
11800 C = new (Context) OMPThreadLimitClause();
11802 case OMPC_priority:
11803 C = new (Context) OMPPriorityClause();
11805 case OMPC_grainsize:
11806 C = new (Context) OMPGrainsizeClause();
11808 case OMPC_num_tasks:
11809 C = new (Context) OMPNumTasksClause();
11812 C = new (Context) OMPHintClause();
11814 case OMPC_dist_schedule:
11815 C = new (Context) OMPDistScheduleClause();
11817 case OMPC_defaultmap:
11818 C = new (Context) OMPDefaultmapClause();
11821 unsigned NumVars = Record.readInt();
11822 unsigned NumDeclarations = Record.readInt();
11823 unsigned NumLists = Record.readInt();
11824 unsigned NumComponents = Record.readInt();
11825 C = OMPToClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
11830 unsigned NumVars = Record.readInt();
11831 unsigned NumDeclarations = Record.readInt();
11832 unsigned NumLists = Record.readInt();
11833 unsigned NumComponents = Record.readInt();
11834 C = OMPFromClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
11838 case OMPC_use_device_ptr: {
11839 unsigned NumVars = Record.readInt();
11840 unsigned NumDeclarations = Record.readInt();
11841 unsigned NumLists = Record.readInt();
11842 unsigned NumComponents = Record.readInt();
11843 C = OMPUseDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
11844 NumLists, NumComponents);
11847 case OMPC_is_device_ptr: {
11848 unsigned NumVars = Record.readInt();
11849 unsigned NumDeclarations = Record.readInt();
11850 unsigned NumLists = Record.readInt();
11851 unsigned NumComponents = Record.readInt();
11852 C = OMPIsDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
11853 NumLists, NumComponents);
11858 C->setLocStart(Record.readSourceLocation());
11859 C->setLocEnd(Record.readSourceLocation());
11864 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
11865 C->setPreInitStmt(Record.readSubStmt(),
11866 static_cast<OpenMPDirectiveKind>(Record.readInt()));
11869 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
11870 VisitOMPClauseWithPreInit(C);
11871 C->setPostUpdateExpr(Record.readSubExpr());
11874 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
11875 VisitOMPClauseWithPreInit(C);
11876 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
11877 C->setNameModifierLoc(Record.readSourceLocation());
11878 C->setColonLoc(Record.readSourceLocation());
11879 C->setCondition(Record.readSubExpr());
11880 C->setLParenLoc(Record.readSourceLocation());
11883 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
11884 C->setCondition(Record.readSubExpr());
11885 C->setLParenLoc(Record.readSourceLocation());
11888 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
11889 VisitOMPClauseWithPreInit(C);
11890 C->setNumThreads(Record.readSubExpr());
11891 C->setLParenLoc(Record.readSourceLocation());
11894 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
11895 C->setSafelen(Record.readSubExpr());
11896 C->setLParenLoc(Record.readSourceLocation());
11899 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
11900 C->setSimdlen(Record.readSubExpr());
11901 C->setLParenLoc(Record.readSourceLocation());
11904 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
11905 C->setNumForLoops(Record.readSubExpr());
11906 C->setLParenLoc(Record.readSourceLocation());
11909 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
11911 static_cast<OpenMPDefaultClauseKind>(Record.readInt()));
11912 C->setLParenLoc(Record.readSourceLocation());
11913 C->setDefaultKindKwLoc(Record.readSourceLocation());
11916 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
11917 C->setProcBindKind(
11918 static_cast<OpenMPProcBindClauseKind>(Record.readInt()));
11919 C->setLParenLoc(Record.readSourceLocation());
11920 C->setProcBindKindKwLoc(Record.readSourceLocation());
11923 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
11924 VisitOMPClauseWithPreInit(C);
11925 C->setScheduleKind(
11926 static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
11927 C->setFirstScheduleModifier(
11928 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
11929 C->setSecondScheduleModifier(
11930 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
11931 C->setChunkSize(Record.readSubExpr());
11932 C->setLParenLoc(Record.readSourceLocation());
11933 C->setFirstScheduleModifierLoc(Record.readSourceLocation());
11934 C->setSecondScheduleModifierLoc(Record.readSourceLocation());
11935 C->setScheduleKindLoc(Record.readSourceLocation());
11936 C->setCommaLoc(Record.readSourceLocation());
11939 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
11940 C->setNumForLoops(Record.readSubExpr());
11941 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
11942 C->setLoopNumIterations(I, Record.readSubExpr());
11943 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
11944 C->setLoopCounter(I, Record.readSubExpr());
11945 C->setLParenLoc(Record.readSourceLocation());
11948 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
11950 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
11952 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
11954 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
11956 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
11958 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
11960 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
11962 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
11964 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
11966 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
11968 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
11970 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
11972 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
11973 OMPUnifiedSharedMemoryClause *) {}
11975 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
11978 OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
11981 void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
11982 OMPAtomicDefaultMemOrderClause *C) {
11983 C->setAtomicDefaultMemOrderKind(
11984 static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
11985 C->setLParenLoc(Record.readSourceLocation());
11986 C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
11989 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
11990 C->setLParenLoc(Record.readSourceLocation());
11991 unsigned NumVars = C->varlist_size();
11992 SmallVector<Expr *, 16> Vars;
11993 Vars.reserve(NumVars);
11994 for (unsigned i = 0; i != NumVars; ++i)
11995 Vars.push_back(Record.readSubExpr());
11996 C->setVarRefs(Vars);
11998 for (unsigned i = 0; i != NumVars; ++i)
11999 Vars.push_back(Record.readSubExpr());
12000 C->setPrivateCopies(Vars);
12003 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
12004 VisitOMPClauseWithPreInit(C);
12005 C->setLParenLoc(Record.readSourceLocation());
12006 unsigned NumVars = C->varlist_size();
12007 SmallVector<Expr *, 16> Vars;
12008 Vars.reserve(NumVars);
12009 for (unsigned i = 0; i != NumVars; ++i)
12010 Vars.push_back(Record.readSubExpr());
12011 C->setVarRefs(Vars);
12013 for (unsigned i = 0; i != NumVars; ++i)
12014 Vars.push_back(Record.readSubExpr());
12015 C->setPrivateCopies(Vars);
12017 for (unsigned i = 0; i != NumVars; ++i)
12018 Vars.push_back(Record.readSubExpr());
12022 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
12023 VisitOMPClauseWithPostUpdate(C);
12024 C->setLParenLoc(Record.readSourceLocation());
12025 unsigned NumVars = C->varlist_size();
12026 SmallVector<Expr *, 16> Vars;
12027 Vars.reserve(NumVars);
12028 for (unsigned i = 0; i != NumVars; ++i)
12029 Vars.push_back(Record.readSubExpr());
12030 C->setVarRefs(Vars);
12032 for (unsigned i = 0; i != NumVars; ++i)
12033 Vars.push_back(Record.readSubExpr());
12034 C->setPrivateCopies(Vars);
12036 for (unsigned i = 0; i != NumVars; ++i)
12037 Vars.push_back(Record.readSubExpr());
12038 C->setSourceExprs(Vars);
12040 for (unsigned i = 0; i != NumVars; ++i)
12041 Vars.push_back(Record.readSubExpr());
12042 C->setDestinationExprs(Vars);
12044 for (unsigned i = 0; i != NumVars; ++i)
12045 Vars.push_back(Record.readSubExpr());
12046 C->setAssignmentOps(Vars);
12049 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
12050 C->setLParenLoc(Record.readSourceLocation());
12051 unsigned NumVars = C->varlist_size();
12052 SmallVector<Expr *, 16> Vars;
12053 Vars.reserve(NumVars);
12054 for (unsigned i = 0; i != NumVars; ++i)
12055 Vars.push_back(Record.readSubExpr());
12056 C->setVarRefs(Vars);
12059 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
12060 VisitOMPClauseWithPostUpdate(C);
12061 C->setLParenLoc(Record.readSourceLocation());
12062 C->setColonLoc(Record.readSourceLocation());
12063 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12064 DeclarationNameInfo DNI;
12065 Record.readDeclarationNameInfo(DNI);
12066 C->setQualifierLoc(NNSL);
12067 C->setNameInfo(DNI);
12069 unsigned NumVars = C->varlist_size();
12070 SmallVector<Expr *, 16> Vars;
12071 Vars.reserve(NumVars);
12072 for (unsigned i = 0; i != NumVars; ++i)
12073 Vars.push_back(Record.readSubExpr());
12074 C->setVarRefs(Vars);
12076 for (unsigned i = 0; i != NumVars; ++i)
12077 Vars.push_back(Record.readSubExpr());
12078 C->setPrivates(Vars);
12080 for (unsigned i = 0; i != NumVars; ++i)
12081 Vars.push_back(Record.readSubExpr());
12082 C->setLHSExprs(Vars);
12084 for (unsigned i = 0; i != NumVars; ++i)
12085 Vars.push_back(Record.readSubExpr());
12086 C->setRHSExprs(Vars);
12088 for (unsigned i = 0; i != NumVars; ++i)
12089 Vars.push_back(Record.readSubExpr());
12090 C->setReductionOps(Vars);
12093 void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
12094 VisitOMPClauseWithPostUpdate(C);
12095 C->setLParenLoc(Record.readSourceLocation());
12096 C->setColonLoc(Record.readSourceLocation());
12097 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12098 DeclarationNameInfo DNI;
12099 Record.readDeclarationNameInfo(DNI);
12100 C->setQualifierLoc(NNSL);
12101 C->setNameInfo(DNI);
12103 unsigned NumVars = C->varlist_size();
12104 SmallVector<Expr *, 16> Vars;
12105 Vars.reserve(NumVars);
12106 for (unsigned I = 0; I != NumVars; ++I)
12107 Vars.push_back(Record.readSubExpr());
12108 C->setVarRefs(Vars);
12110 for (unsigned I = 0; I != NumVars; ++I)
12111 Vars.push_back(Record.readSubExpr());
12112 C->setPrivates(Vars);
12114 for (unsigned I = 0; I != NumVars; ++I)
12115 Vars.push_back(Record.readSubExpr());
12116 C->setLHSExprs(Vars);
12118 for (unsigned I = 0; I != NumVars; ++I)
12119 Vars.push_back(Record.readSubExpr());
12120 C->setRHSExprs(Vars);
12122 for (unsigned I = 0; I != NumVars; ++I)
12123 Vars.push_back(Record.readSubExpr());
12124 C->setReductionOps(Vars);
12127 void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
12128 VisitOMPClauseWithPostUpdate(C);
12129 C->setLParenLoc(Record.readSourceLocation());
12130 C->setColonLoc(Record.readSourceLocation());
12131 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12132 DeclarationNameInfo DNI;
12133 Record.readDeclarationNameInfo(DNI);
12134 C->setQualifierLoc(NNSL);
12135 C->setNameInfo(DNI);
12137 unsigned NumVars = C->varlist_size();
12138 SmallVector<Expr *, 16> Vars;
12139 Vars.reserve(NumVars);
12140 for (unsigned I = 0; I != NumVars; ++I)
12141 Vars.push_back(Record.readSubExpr());
12142 C->setVarRefs(Vars);
12144 for (unsigned I = 0; I != NumVars; ++I)
12145 Vars.push_back(Record.readSubExpr());
12146 C->setPrivates(Vars);
12148 for (unsigned I = 0; I != NumVars; ++I)
12149 Vars.push_back(Record.readSubExpr());
12150 C->setLHSExprs(Vars);
12152 for (unsigned I = 0; I != NumVars; ++I)
12153 Vars.push_back(Record.readSubExpr());
12154 C->setRHSExprs(Vars);
12156 for (unsigned I = 0; I != NumVars; ++I)
12157 Vars.push_back(Record.readSubExpr());
12158 C->setReductionOps(Vars);
12160 for (unsigned I = 0; I != NumVars; ++I)
12161 Vars.push_back(Record.readSubExpr());
12162 C->setTaskgroupDescriptors(Vars);
12165 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
12166 VisitOMPClauseWithPostUpdate(C);
12167 C->setLParenLoc(Record.readSourceLocation());
12168 C->setColonLoc(Record.readSourceLocation());
12169 C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
12170 C->setModifierLoc(Record.readSourceLocation());
12171 unsigned NumVars = C->varlist_size();
12172 SmallVector<Expr *, 16> Vars;
12173 Vars.reserve(NumVars);
12174 for (unsigned i = 0; i != NumVars; ++i)
12175 Vars.push_back(Record.readSubExpr());
12176 C->setVarRefs(Vars);
12178 for (unsigned i = 0; i != NumVars; ++i)
12179 Vars.push_back(Record.readSubExpr());
12180 C->setPrivates(Vars);
12182 for (unsigned i = 0; i != NumVars; ++i)
12183 Vars.push_back(Record.readSubExpr());
12186 for (unsigned i = 0; i != NumVars; ++i)
12187 Vars.push_back(Record.readSubExpr());
12188 C->setUpdates(Vars);
12190 for (unsigned i = 0; i != NumVars; ++i)
12191 Vars.push_back(Record.readSubExpr());
12192 C->setFinals(Vars);
12193 C->setStep(Record.readSubExpr());
12194 C->setCalcStep(Record.readSubExpr());
12197 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
12198 C->setLParenLoc(Record.readSourceLocation());
12199 C->setColonLoc(Record.readSourceLocation());
12200 unsigned NumVars = C->varlist_size();
12201 SmallVector<Expr *, 16> Vars;
12202 Vars.reserve(NumVars);
12203 for (unsigned i = 0; i != NumVars; ++i)
12204 Vars.push_back(Record.readSubExpr());
12205 C->setVarRefs(Vars);
12206 C->setAlignment(Record.readSubExpr());
12209 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
12210 C->setLParenLoc(Record.readSourceLocation());
12211 unsigned NumVars = C->varlist_size();
12212 SmallVector<Expr *, 16> Exprs;
12213 Exprs.reserve(NumVars);
12214 for (unsigned i = 0; i != NumVars; ++i)
12215 Exprs.push_back(Record.readSubExpr());
12216 C->setVarRefs(Exprs);
12218 for (unsigned i = 0; i != NumVars; ++i)
12219 Exprs.push_back(Record.readSubExpr());
12220 C->setSourceExprs(Exprs);
12222 for (unsigned i = 0; i != NumVars; ++i)
12223 Exprs.push_back(Record.readSubExpr());
12224 C->setDestinationExprs(Exprs);
12226 for (unsigned i = 0; i != NumVars; ++i)
12227 Exprs.push_back(Record.readSubExpr());
12228 C->setAssignmentOps(Exprs);
12231 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
12232 C->setLParenLoc(Record.readSourceLocation());
12233 unsigned NumVars = C->varlist_size();
12234 SmallVector<Expr *, 16> Exprs;
12235 Exprs.reserve(NumVars);
12236 for (unsigned i = 0; i != NumVars; ++i)
12237 Exprs.push_back(Record.readSubExpr());
12238 C->setVarRefs(Exprs);
12240 for (unsigned i = 0; i != NumVars; ++i)
12241 Exprs.push_back(Record.readSubExpr());
12242 C->setSourceExprs(Exprs);
12244 for (unsigned i = 0; i != NumVars; ++i)
12245 Exprs.push_back(Record.readSubExpr());
12246 C->setDestinationExprs(Exprs);
12248 for (unsigned i = 0; i != NumVars; ++i)
12249 Exprs.push_back(Record.readSubExpr());
12250 C->setAssignmentOps(Exprs);
12253 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
12254 C->setLParenLoc(Record.readSourceLocation());
12255 unsigned NumVars = C->varlist_size();
12256 SmallVector<Expr *, 16> Vars;
12257 Vars.reserve(NumVars);
12258 for (unsigned i = 0; i != NumVars; ++i)
12259 Vars.push_back(Record.readSubExpr());
12260 C->setVarRefs(Vars);
12263 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
12264 C->setLParenLoc(Record.readSourceLocation());
12265 C->setDependencyKind(
12266 static_cast<OpenMPDependClauseKind>(Record.readInt()));
12267 C->setDependencyLoc(Record.readSourceLocation());
12268 C->setColonLoc(Record.readSourceLocation());
12269 unsigned NumVars = C->varlist_size();
12270 SmallVector<Expr *, 16> Vars;
12271 Vars.reserve(NumVars);
12272 for (unsigned I = 0; I != NumVars; ++I)
12273 Vars.push_back(Record.readSubExpr());
12274 C->setVarRefs(Vars);
12275 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
12276 C->setLoopData(I, Record.readSubExpr());
12279 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
12280 VisitOMPClauseWithPreInit(C);
12281 C->setDevice(Record.readSubExpr());
12282 C->setLParenLoc(Record.readSourceLocation());
12285 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
12286 C->setLParenLoc(Record.readSourceLocation());
12287 for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
12288 C->setMapTypeModifier(
12289 I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
12290 C->setMapTypeModifierLoc(I, Record.readSourceLocation());
12293 static_cast<OpenMPMapClauseKind>(Record.readInt()));
12294 C->setMapLoc(Record.readSourceLocation());
12295 C->setColonLoc(Record.readSourceLocation());
12296 auto NumVars = C->varlist_size();
12297 auto UniqueDecls = C->getUniqueDeclarationsNum();
12298 auto TotalLists = C->getTotalComponentListNum();
12299 auto TotalComponents = C->getTotalComponentsNum();
12301 SmallVector<Expr *, 16> Vars;
12302 Vars.reserve(NumVars);
12303 for (unsigned i = 0; i != NumVars; ++i)
12304 Vars.push_back(Record.readSubExpr());
12305 C->setVarRefs(Vars);
12307 SmallVector<ValueDecl *, 16> Decls;
12308 Decls.reserve(UniqueDecls);
12309 for (unsigned i = 0; i < UniqueDecls; ++i)
12310 Decls.push_back(Record.readDeclAs<ValueDecl>());
12311 C->setUniqueDecls(Decls);
12313 SmallVector<unsigned, 16> ListsPerDecl;
12314 ListsPerDecl.reserve(UniqueDecls);
12315 for (unsigned i = 0; i < UniqueDecls; ++i)
12316 ListsPerDecl.push_back(Record.readInt());
12317 C->setDeclNumLists(ListsPerDecl);
12319 SmallVector<unsigned, 32> ListSizes;
12320 ListSizes.reserve(TotalLists);
12321 for (unsigned i = 0; i < TotalLists; ++i)
12322 ListSizes.push_back(Record.readInt());
12323 C->setComponentListSizes(ListSizes);
12325 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12326 Components.reserve(TotalComponents);
12327 for (unsigned i = 0; i < TotalComponents; ++i) {
12328 Expr *AssociatedExpr = Record.readSubExpr();
12329 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12330 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12331 AssociatedExpr, AssociatedDecl));
12333 C->setComponents(Components, ListSizes);
12336 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
12337 VisitOMPClauseWithPreInit(C);
12338 C->setNumTeams(Record.readSubExpr());
12339 C->setLParenLoc(Record.readSourceLocation());
12342 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
12343 VisitOMPClauseWithPreInit(C);
12344 C->setThreadLimit(Record.readSubExpr());
12345 C->setLParenLoc(Record.readSourceLocation());
12348 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
12349 C->setPriority(Record.readSubExpr());
12350 C->setLParenLoc(Record.readSourceLocation());
12353 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
12354 C->setGrainsize(Record.readSubExpr());
12355 C->setLParenLoc(Record.readSourceLocation());
12358 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
12359 C->setNumTasks(Record.readSubExpr());
12360 C->setLParenLoc(Record.readSourceLocation());
12363 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
12364 C->setHint(Record.readSubExpr());
12365 C->setLParenLoc(Record.readSourceLocation());
12368 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
12369 VisitOMPClauseWithPreInit(C);
12370 C->setDistScheduleKind(
12371 static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
12372 C->setChunkSize(Record.readSubExpr());
12373 C->setLParenLoc(Record.readSourceLocation());
12374 C->setDistScheduleKindLoc(Record.readSourceLocation());
12375 C->setCommaLoc(Record.readSourceLocation());
12378 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
12379 C->setDefaultmapKind(
12380 static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
12381 C->setDefaultmapModifier(
12382 static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
12383 C->setLParenLoc(Record.readSourceLocation());
12384 C->setDefaultmapModifierLoc(Record.readSourceLocation());
12385 C->setDefaultmapKindLoc(Record.readSourceLocation());
12388 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
12389 C->setLParenLoc(Record.readSourceLocation());
12390 auto NumVars = C->varlist_size();
12391 auto UniqueDecls = C->getUniqueDeclarationsNum();
12392 auto TotalLists = C->getTotalComponentListNum();
12393 auto TotalComponents = C->getTotalComponentsNum();
12395 SmallVector<Expr *, 16> Vars;
12396 Vars.reserve(NumVars);
12397 for (unsigned i = 0; i != NumVars; ++i)
12398 Vars.push_back(Record.readSubExpr());
12399 C->setVarRefs(Vars);
12401 SmallVector<ValueDecl *, 16> Decls;
12402 Decls.reserve(UniqueDecls);
12403 for (unsigned i = 0; i < UniqueDecls; ++i)
12404 Decls.push_back(Record.readDeclAs<ValueDecl>());
12405 C->setUniqueDecls(Decls);
12407 SmallVector<unsigned, 16> ListsPerDecl;
12408 ListsPerDecl.reserve(UniqueDecls);
12409 for (unsigned i = 0; i < UniqueDecls; ++i)
12410 ListsPerDecl.push_back(Record.readInt());
12411 C->setDeclNumLists(ListsPerDecl);
12413 SmallVector<unsigned, 32> ListSizes;
12414 ListSizes.reserve(TotalLists);
12415 for (unsigned i = 0; i < TotalLists; ++i)
12416 ListSizes.push_back(Record.readInt());
12417 C->setComponentListSizes(ListSizes);
12419 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12420 Components.reserve(TotalComponents);
12421 for (unsigned i = 0; i < TotalComponents; ++i) {
12422 Expr *AssociatedExpr = Record.readSubExpr();
12423 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12424 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12425 AssociatedExpr, AssociatedDecl));
12427 C->setComponents(Components, ListSizes);
12430 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
12431 C->setLParenLoc(Record.readSourceLocation());
12432 auto NumVars = C->varlist_size();
12433 auto UniqueDecls = C->getUniqueDeclarationsNum();
12434 auto TotalLists = C->getTotalComponentListNum();
12435 auto TotalComponents = C->getTotalComponentsNum();
12437 SmallVector<Expr *, 16> Vars;
12438 Vars.reserve(NumVars);
12439 for (unsigned i = 0; i != NumVars; ++i)
12440 Vars.push_back(Record.readSubExpr());
12441 C->setVarRefs(Vars);
12443 SmallVector<ValueDecl *, 16> Decls;
12444 Decls.reserve(UniqueDecls);
12445 for (unsigned i = 0; i < UniqueDecls; ++i)
12446 Decls.push_back(Record.readDeclAs<ValueDecl>());
12447 C->setUniqueDecls(Decls);
12449 SmallVector<unsigned, 16> ListsPerDecl;
12450 ListsPerDecl.reserve(UniqueDecls);
12451 for (unsigned i = 0; i < UniqueDecls; ++i)
12452 ListsPerDecl.push_back(Record.readInt());
12453 C->setDeclNumLists(ListsPerDecl);
12455 SmallVector<unsigned, 32> ListSizes;
12456 ListSizes.reserve(TotalLists);
12457 for (unsigned i = 0; i < TotalLists; ++i)
12458 ListSizes.push_back(Record.readInt());
12459 C->setComponentListSizes(ListSizes);
12461 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12462 Components.reserve(TotalComponents);
12463 for (unsigned i = 0; i < TotalComponents; ++i) {
12464 Expr *AssociatedExpr = Record.readSubExpr();
12465 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12466 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12467 AssociatedExpr, AssociatedDecl));
12469 C->setComponents(Components, ListSizes);
12472 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
12473 C->setLParenLoc(Record.readSourceLocation());
12474 auto NumVars = C->varlist_size();
12475 auto UniqueDecls = C->getUniqueDeclarationsNum();
12476 auto TotalLists = C->getTotalComponentListNum();
12477 auto TotalComponents = C->getTotalComponentsNum();
12479 SmallVector<Expr *, 16> Vars;
12480 Vars.reserve(NumVars);
12481 for (unsigned i = 0; i != NumVars; ++i)
12482 Vars.push_back(Record.readSubExpr());
12483 C->setVarRefs(Vars);
12485 for (unsigned i = 0; i != NumVars; ++i)
12486 Vars.push_back(Record.readSubExpr());
12487 C->setPrivateCopies(Vars);
12489 for (unsigned i = 0; i != NumVars; ++i)
12490 Vars.push_back(Record.readSubExpr());
12493 SmallVector<ValueDecl *, 16> Decls;
12494 Decls.reserve(UniqueDecls);
12495 for (unsigned i = 0; i < UniqueDecls; ++i)
12496 Decls.push_back(Record.readDeclAs<ValueDecl>());
12497 C->setUniqueDecls(Decls);
12499 SmallVector<unsigned, 16> ListsPerDecl;
12500 ListsPerDecl.reserve(UniqueDecls);
12501 for (unsigned i = 0; i < UniqueDecls; ++i)
12502 ListsPerDecl.push_back(Record.readInt());
12503 C->setDeclNumLists(ListsPerDecl);
12505 SmallVector<unsigned, 32> ListSizes;
12506 ListSizes.reserve(TotalLists);
12507 for (unsigned i = 0; i < TotalLists; ++i)
12508 ListSizes.push_back(Record.readInt());
12509 C->setComponentListSizes(ListSizes);
12511 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12512 Components.reserve(TotalComponents);
12513 for (unsigned i = 0; i < TotalComponents; ++i) {
12514 Expr *AssociatedExpr = Record.readSubExpr();
12515 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12516 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12517 AssociatedExpr, AssociatedDecl));
12519 C->setComponents(Components, ListSizes);
12522 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12523 C->setLParenLoc(Record.readSourceLocation());
12524 auto NumVars = C->varlist_size();
12525 auto UniqueDecls = C->getUniqueDeclarationsNum();
12526 auto TotalLists = C->getTotalComponentListNum();
12527 auto TotalComponents = C->getTotalComponentsNum();
12529 SmallVector<Expr *, 16> Vars;
12530 Vars.reserve(NumVars);
12531 for (unsigned i = 0; i != NumVars; ++i)
12532 Vars.push_back(Record.readSubExpr());
12533 C->setVarRefs(Vars);
12536 SmallVector<ValueDecl *, 16> Decls;
12537 Decls.reserve(UniqueDecls);
12538 for (unsigned i = 0; i < UniqueDecls; ++i)
12539 Decls.push_back(Record.readDeclAs<ValueDecl>());
12540 C->setUniqueDecls(Decls);
12542 SmallVector<unsigned, 16> ListsPerDecl;
12543 ListsPerDecl.reserve(UniqueDecls);
12544 for (unsigned i = 0; i < UniqueDecls; ++i)
12545 ListsPerDecl.push_back(Record.readInt());
12546 C->setDeclNumLists(ListsPerDecl);
12548 SmallVector<unsigned, 32> ListSizes;
12549 ListSizes.reserve(TotalLists);
12550 for (unsigned i = 0; i < TotalLists; ++i)
12551 ListSizes.push_back(Record.readInt());
12552 C->setComponentListSizes(ListSizes);
12554 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12555 Components.reserve(TotalComponents);
12556 for (unsigned i = 0; i < TotalComponents; ++i) {
12557 Expr *AssociatedExpr = Record.readSubExpr();
12558 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12559 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12560 AssociatedExpr, AssociatedDecl));
12562 C->setComponents(Components, ListSizes);