1 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file defines the ASTReader class, which reads AST files.
11 //===----------------------------------------------------------------------===//
13 #include "clang/Basic/OpenMPKinds.h"
14 #include "clang/Serialization/ASTRecordReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/AbstractTypeReader.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/ASTMutationListener.h"
21 #include "clang/AST/ASTUnresolvedSet.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclBase.h"
24 #include "clang/AST/DeclCXX.h"
25 #include "clang/AST/DeclFriend.h"
26 #include "clang/AST/DeclGroup.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExternalASTSource.h"
33 #include "clang/AST/NestedNameSpecifier.h"
34 #include "clang/AST/OpenMPClause.h"
35 #include "clang/AST/ODRHash.h"
36 #include "clang/AST/RawCommentList.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/TemplateName.h"
39 #include "clang/AST/Type.h"
40 #include "clang/AST/TypeLoc.h"
41 #include "clang/AST/TypeLocVisitor.h"
42 #include "clang/AST/UnresolvedSet.h"
43 #include "clang/Basic/CommentOptions.h"
44 #include "clang/Basic/Diagnostic.h"
45 #include "clang/Basic/DiagnosticOptions.h"
46 #include "clang/Basic/ExceptionSpecificationType.h"
47 #include "clang/Basic/FileManager.h"
48 #include "clang/Basic/FileSystemOptions.h"
49 #include "clang/Basic/IdentifierTable.h"
50 #include "clang/Basic/LLVM.h"
51 #include "clang/Basic/LangOptions.h"
52 #include "clang/Basic/Module.h"
53 #include "clang/Basic/ObjCRuntime.h"
54 #include "clang/Basic/OperatorKinds.h"
55 #include "clang/Basic/PragmaKinds.h"
56 #include "clang/Basic/Sanitizers.h"
57 #include "clang/Basic/SourceLocation.h"
58 #include "clang/Basic/SourceManager.h"
59 #include "clang/Basic/SourceManagerInternals.h"
60 #include "clang/Basic/Specifiers.h"
61 #include "clang/Basic/TargetInfo.h"
62 #include "clang/Basic/TargetOptions.h"
63 #include "clang/Basic/TokenKinds.h"
64 #include "clang/Basic/Version.h"
65 #include "clang/Lex/HeaderSearch.h"
66 #include "clang/Lex/HeaderSearchOptions.h"
67 #include "clang/Lex/MacroInfo.h"
68 #include "clang/Lex/ModuleMap.h"
69 #include "clang/Lex/PreprocessingRecord.h"
70 #include "clang/Lex/Preprocessor.h"
71 #include "clang/Lex/PreprocessorOptions.h"
72 #include "clang/Lex/Token.h"
73 #include "clang/Sema/ObjCMethodList.h"
74 #include "clang/Sema/Scope.h"
75 #include "clang/Sema/Sema.h"
76 #include "clang/Sema/Weak.h"
77 #include "clang/Serialization/ASTBitCodes.h"
78 #include "clang/Serialization/ASTDeserializationListener.h"
79 #include "clang/Serialization/ContinuousRangeMap.h"
80 #include "clang/Serialization/GlobalModuleIndex.h"
81 #include "clang/Serialization/InMemoryModuleCache.h"
82 #include "clang/Serialization/ModuleFile.h"
83 #include "clang/Serialization/ModuleFileExtension.h"
84 #include "clang/Serialization/ModuleManager.h"
85 #include "clang/Serialization/PCHContainerOperations.h"
86 #include "clang/Serialization/SerializationDiagnostic.h"
87 #include "llvm/ADT/APFloat.h"
88 #include "llvm/ADT/APInt.h"
89 #include "llvm/ADT/APSInt.h"
90 #include "llvm/ADT/ArrayRef.h"
91 #include "llvm/ADT/DenseMap.h"
92 #include "llvm/ADT/FloatingPointMode.h"
93 #include "llvm/ADT/FoldingSet.h"
94 #include "llvm/ADT/Hashing.h"
95 #include "llvm/ADT/IntrusiveRefCntPtr.h"
96 #include "llvm/ADT/None.h"
97 #include "llvm/ADT/Optional.h"
98 #include "llvm/ADT/STLExtras.h"
99 #include "llvm/ADT/ScopeExit.h"
100 #include "llvm/ADT/SmallPtrSet.h"
101 #include "llvm/ADT/SmallString.h"
102 #include "llvm/ADT/SmallVector.h"
103 #include "llvm/ADT/StringExtras.h"
104 #include "llvm/ADT/StringMap.h"
105 #include "llvm/ADT/StringRef.h"
106 #include "llvm/ADT/Triple.h"
107 #include "llvm/ADT/iterator_range.h"
108 #include "llvm/Bitstream/BitstreamReader.h"
109 #include "llvm/Support/Casting.h"
110 #include "llvm/Support/Compiler.h"
111 #include "llvm/Support/Compression.h"
112 #include "llvm/Support/DJB.h"
113 #include "llvm/Support/Endian.h"
114 #include "llvm/Support/Error.h"
115 #include "llvm/Support/ErrorHandling.h"
116 #include "llvm/Support/FileSystem.h"
117 #include "llvm/Support/LEB128.h"
118 #include "llvm/Support/MemoryBuffer.h"
119 #include "llvm/Support/Path.h"
120 #include "llvm/Support/SaveAndRestore.h"
121 #include "llvm/Support/Timer.h"
122 #include "llvm/Support/VersionTuple.h"
123 #include "llvm/Support/raw_ostream.h"
135 #include <system_error>
140 using namespace clang;
141 using namespace clang::serialization;
142 using namespace clang::serialization::reader;
143 using llvm::BitstreamCursor;
144 using llvm::RoundingMode;
146 //===----------------------------------------------------------------------===//
147 // ChainedASTReaderListener implementation
148 //===----------------------------------------------------------------------===//
151 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
152 return First->ReadFullVersionInformation(FullVersion) ||
153 Second->ReadFullVersionInformation(FullVersion);
156 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
157 First->ReadModuleName(ModuleName);
158 Second->ReadModuleName(ModuleName);
161 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
162 First->ReadModuleMapFile(ModuleMapPath);
163 Second->ReadModuleMapFile(ModuleMapPath);
167 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
169 bool AllowCompatibleDifferences) {
170 return First->ReadLanguageOptions(LangOpts, Complain,
171 AllowCompatibleDifferences) ||
172 Second->ReadLanguageOptions(LangOpts, Complain,
173 AllowCompatibleDifferences);
176 bool ChainedASTReaderListener::ReadTargetOptions(
177 const TargetOptions &TargetOpts, bool Complain,
178 bool AllowCompatibleDifferences) {
179 return First->ReadTargetOptions(TargetOpts, Complain,
180 AllowCompatibleDifferences) ||
181 Second->ReadTargetOptions(TargetOpts, Complain,
182 AllowCompatibleDifferences);
185 bool ChainedASTReaderListener::ReadDiagnosticOptions(
186 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
187 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
188 Second->ReadDiagnosticOptions(DiagOpts, Complain);
192 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
194 return First->ReadFileSystemOptions(FSOpts, Complain) ||
195 Second->ReadFileSystemOptions(FSOpts, Complain);
198 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
199 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
201 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
203 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
207 bool ChainedASTReaderListener::ReadPreprocessorOptions(
208 const PreprocessorOptions &PPOpts, bool Complain,
209 std::string &SuggestedPredefines) {
210 return First->ReadPreprocessorOptions(PPOpts, Complain,
211 SuggestedPredefines) ||
212 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
215 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
217 First->ReadCounter(M, Value);
218 Second->ReadCounter(M, Value);
221 bool ChainedASTReaderListener::needsInputFileVisitation() {
222 return First->needsInputFileVisitation() ||
223 Second->needsInputFileVisitation();
226 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
227 return First->needsSystemInputFileVisitation() ||
228 Second->needsSystemInputFileVisitation();
231 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
233 First->visitModuleFile(Filename, Kind);
234 Second->visitModuleFile(Filename, Kind);
237 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
240 bool isExplicitModule) {
241 bool Continue = false;
242 if (First->needsInputFileVisitation() &&
243 (!isSystem || First->needsSystemInputFileVisitation()))
244 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
246 if (Second->needsInputFileVisitation() &&
247 (!isSystem || Second->needsSystemInputFileVisitation()))
248 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
253 void ChainedASTReaderListener::readModuleFileExtension(
254 const ModuleFileExtensionMetadata &Metadata) {
255 First->readModuleFileExtension(Metadata);
256 Second->readModuleFileExtension(Metadata);
259 //===----------------------------------------------------------------------===//
260 // PCH validator implementation
261 //===----------------------------------------------------------------------===//
263 ASTReaderListener::~ASTReaderListener() = default;
265 /// Compare the given set of language options against an existing set of
266 /// language options.
268 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
269 /// \param AllowCompatibleDifferences If true, differences between compatible
270 /// language options will be permitted.
272 /// \returns true if the languagae options mis-match, false otherwise.
273 static bool checkLanguageOptions(const LangOptions &LangOpts,
274 const LangOptions &ExistingLangOpts,
275 DiagnosticsEngine *Diags,
276 bool AllowCompatibleDifferences = true) {
277 #define LANGOPT(Name, Bits, Default, Description) \
278 if (ExistingLangOpts.Name != LangOpts.Name) { \
280 Diags->Report(diag::err_pch_langopt_mismatch) \
281 << Description << LangOpts.Name << ExistingLangOpts.Name; \
285 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
286 if (ExistingLangOpts.Name != LangOpts.Name) { \
288 Diags->Report(diag::err_pch_langopt_value_mismatch) \
293 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
294 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
296 Diags->Report(diag::err_pch_langopt_value_mismatch) \
301 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
302 if (!AllowCompatibleDifferences) \
303 LANGOPT(Name, Bits, Default, Description)
305 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
306 if (!AllowCompatibleDifferences) \
307 ENUM_LANGOPT(Name, Bits, Default, Description)
309 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
310 if (!AllowCompatibleDifferences) \
311 VALUE_LANGOPT(Name, Bits, Default, Description)
313 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
314 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
315 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
316 #include "clang/Basic/LangOptions.def"
318 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
320 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
324 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
326 Diags->Report(diag::err_pch_langopt_value_mismatch)
327 << "target Objective-C runtime";
331 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
332 LangOpts.CommentOpts.BlockCommandNames) {
334 Diags->Report(diag::err_pch_langopt_value_mismatch)
335 << "block command names";
339 // Sanitizer feature mismatches are treated as compatible differences. If
340 // compatible differences aren't allowed, we still only want to check for
341 // mismatches of non-modular sanitizers (the only ones which can affect AST
343 if (!AllowCompatibleDifferences) {
344 SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
345 SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
346 SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
347 ExistingSanitizers.clear(ModularSanitizers);
348 ImportedSanitizers.clear(ModularSanitizers);
349 if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
350 const std::string Flag = "-fsanitize=";
352 #define SANITIZER(NAME, ID) \
354 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
355 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
356 if (InExistingModule != InImportedModule) \
357 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
358 << InExistingModule << (Flag + NAME); \
360 #include "clang/Basic/Sanitizers.def"
369 /// Compare the given set of target options against an existing set of
372 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
374 /// \returns true if the target options mis-match, false otherwise.
375 static bool checkTargetOptions(const TargetOptions &TargetOpts,
376 const TargetOptions &ExistingTargetOpts,
377 DiagnosticsEngine *Diags,
378 bool AllowCompatibleDifferences = true) {
379 #define CHECK_TARGET_OPT(Field, Name) \
380 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
382 Diags->Report(diag::err_pch_targetopt_mismatch) \
383 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
387 // The triple and ABI must match exactly.
388 CHECK_TARGET_OPT(Triple, "target");
389 CHECK_TARGET_OPT(ABI, "target ABI");
391 // We can tolerate different CPUs in many cases, notably when one CPU
392 // supports a strict superset of another. When allowing compatible
393 // differences skip this check.
394 if (!AllowCompatibleDifferences) {
395 CHECK_TARGET_OPT(CPU, "target CPU");
396 CHECK_TARGET_OPT(TuneCPU, "tune CPU");
399 #undef CHECK_TARGET_OPT
401 // Compare feature sets.
402 SmallVector<StringRef, 4> ExistingFeatures(
403 ExistingTargetOpts.FeaturesAsWritten.begin(),
404 ExistingTargetOpts.FeaturesAsWritten.end());
405 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
406 TargetOpts.FeaturesAsWritten.end());
407 llvm::sort(ExistingFeatures);
408 llvm::sort(ReadFeatures);
410 // We compute the set difference in both directions explicitly so that we can
411 // diagnose the differences differently.
412 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
414 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
415 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
416 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
417 ExistingFeatures.begin(), ExistingFeatures.end(),
418 std::back_inserter(UnmatchedReadFeatures));
420 // If we are allowing compatible differences and the read feature set is
421 // a strict subset of the existing feature set, there is nothing to diagnose.
422 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
426 for (StringRef Feature : UnmatchedReadFeatures)
427 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
428 << /* is-existing-feature */ false << Feature;
429 for (StringRef Feature : UnmatchedExistingFeatures)
430 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
431 << /* is-existing-feature */ true << Feature;
434 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
438 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
440 bool AllowCompatibleDifferences) {
441 const LangOptions &ExistingLangOpts = PP.getLangOpts();
442 return checkLanguageOptions(LangOpts, ExistingLangOpts,
443 Complain ? &Reader.Diags : nullptr,
444 AllowCompatibleDifferences);
447 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
449 bool AllowCompatibleDifferences) {
450 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
451 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
452 Complain ? &Reader.Diags : nullptr,
453 AllowCompatibleDifferences);
458 using MacroDefinitionsMap =
459 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
460 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
464 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
465 DiagnosticsEngine &Diags,
467 using Level = DiagnosticsEngine::Level;
469 // Check current mappings for new -Werror mappings, and the stored mappings
470 // for cases that were explicitly mapped to *not* be errors that are now
471 // errors because of options like -Werror.
472 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
474 for (DiagnosticsEngine *MappingSource : MappingSources) {
475 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
476 diag::kind DiagID = DiagIDMappingPair.first;
477 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
478 if (CurLevel < DiagnosticsEngine::Error)
479 continue; // not significant
481 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
482 if (StoredLevel < DiagnosticsEngine::Error) {
484 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
485 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
494 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
495 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
496 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
498 return Ext >= diag::Severity::Error;
501 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
502 DiagnosticsEngine &Diags,
503 bool IsSystem, bool Complain) {
506 if (Diags.getSuppressSystemWarnings())
508 // If -Wsystem-headers was not enabled before, be conservative
509 if (StoredDiags.getSuppressSystemWarnings()) {
511 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
516 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
518 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
522 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
523 !StoredDiags.getEnableAllWarnings()) {
525 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
529 if (isExtHandlingFromDiagsError(Diags) &&
530 !isExtHandlingFromDiagsError(StoredDiags)) {
532 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
536 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
539 /// Return the top import module if it is implicit, nullptr otherwise.
540 static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
542 // If the original import came from a file explicitly generated by the user,
543 // don't check the diagnostic mappings.
544 // FIXME: currently this is approximated by checking whether this is not a
545 // module import of an implicitly-loaded module file.
546 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
547 // the transitive closure of its imports, since unrelated modules cannot be
548 // imported until after this module finishes validation.
549 ModuleFile *TopImport = &*ModuleMgr.rbegin();
550 while (!TopImport->ImportedBy.empty())
551 TopImport = TopImport->ImportedBy[0];
552 if (TopImport->Kind != MK_ImplicitModule)
555 StringRef ModuleName = TopImport->ModuleName;
556 assert(!ModuleName.empty() && "diagnostic options read before module name");
558 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
559 assert(M && "missing module");
563 bool PCHValidator::ReadDiagnosticOptions(
564 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
565 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
566 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
567 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
568 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
569 // This should never fail, because we would have processed these options
570 // before writing them to an ASTFile.
571 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
573 ModuleManager &ModuleMgr = Reader.getModuleManager();
574 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
576 Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
580 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
581 // contains the union of their flags.
582 return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
586 /// Collect the macro definitions provided by the given preprocessor
589 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
590 MacroDefinitionsMap &Macros,
591 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
592 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
593 StringRef Macro = PPOpts.Macros[I].first;
594 bool IsUndef = PPOpts.Macros[I].second;
596 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
597 StringRef MacroName = MacroPair.first;
598 StringRef MacroBody = MacroPair.second;
600 // For an #undef'd macro, we only care about the name.
602 if (MacroNames && !Macros.count(MacroName))
603 MacroNames->push_back(MacroName);
605 Macros[MacroName] = std::make_pair("", true);
609 // For a #define'd macro, figure out the actual definition.
610 if (MacroName.size() == Macro.size())
613 // Note: GCC drops anything following an end-of-line character.
614 StringRef::size_type End = MacroBody.find_first_of("\n\r");
615 MacroBody = MacroBody.substr(0, End);
618 if (MacroNames && !Macros.count(MacroName))
619 MacroNames->push_back(MacroName);
620 Macros[MacroName] = std::make_pair(MacroBody, false);
624 /// Check the preprocessor options deserialized from the control block
625 /// against the preprocessor options in an existing preprocessor.
627 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
628 /// \param Validate If true, validate preprocessor options. If false, allow
629 /// macros defined by \p ExistingPPOpts to override those defined by
630 /// \p PPOpts in SuggestedPredefines.
631 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
632 const PreprocessorOptions &ExistingPPOpts,
633 DiagnosticsEngine *Diags,
634 FileManager &FileMgr,
635 std::string &SuggestedPredefines,
636 const LangOptions &LangOpts,
637 bool Validate = true) {
638 // Check macro definitions.
639 MacroDefinitionsMap ASTFileMacros;
640 collectMacroDefinitions(PPOpts, ASTFileMacros);
641 MacroDefinitionsMap ExistingMacros;
642 SmallVector<StringRef, 4> ExistingMacroNames;
643 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
645 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
646 // Dig out the macro definition in the existing preprocessor options.
647 StringRef MacroName = ExistingMacroNames[I];
648 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
650 // Check whether we know anything about this macro name or not.
651 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
652 ASTFileMacros.find(MacroName);
653 if (!Validate || Known == ASTFileMacros.end()) {
654 // FIXME: Check whether this identifier was referenced anywhere in the
655 // AST file. If so, we should reject the AST file. Unfortunately, this
656 // information isn't in the control block. What shall we do about it?
658 if (Existing.second) {
659 SuggestedPredefines += "#undef ";
660 SuggestedPredefines += MacroName.str();
661 SuggestedPredefines += '\n';
663 SuggestedPredefines += "#define ";
664 SuggestedPredefines += MacroName.str();
665 SuggestedPredefines += ' ';
666 SuggestedPredefines += Existing.first.str();
667 SuggestedPredefines += '\n';
672 // If the macro was defined in one but undef'd in the other, we have a
674 if (Existing.second != Known->second.second) {
676 Diags->Report(diag::err_pch_macro_def_undef)
677 << MacroName << Known->second.second;
682 // If the macro was #undef'd in both, or if the macro bodies are identical,
684 if (Existing.second || Existing.first == Known->second.first)
687 // The macro bodies differ; complain.
689 Diags->Report(diag::err_pch_macro_def_conflict)
690 << MacroName << Known->second.first << Existing.first;
695 // Check whether we're using predefines.
696 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
698 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
703 // Detailed record is important since it is used for the module cache hash.
704 if (LangOpts.Modules &&
705 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
707 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
712 // Compute the #include and #include_macros lines we need.
713 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
714 StringRef File = ExistingPPOpts.Includes[I];
716 if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
717 !ExistingPPOpts.PCHThroughHeader.empty()) {
718 // In case the through header is an include, we must add all the includes
719 // to the predefines so the start point can be determined.
720 SuggestedPredefines += "#include \"";
721 SuggestedPredefines += File;
722 SuggestedPredefines += "\"\n";
726 if (File == ExistingPPOpts.ImplicitPCHInclude)
729 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
730 != PPOpts.Includes.end())
733 SuggestedPredefines += "#include \"";
734 SuggestedPredefines += File;
735 SuggestedPredefines += "\"\n";
738 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
739 StringRef File = ExistingPPOpts.MacroIncludes[I];
740 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
742 != PPOpts.MacroIncludes.end())
745 SuggestedPredefines += "#__include_macros \"";
746 SuggestedPredefines += File;
747 SuggestedPredefines += "\"\n##\n";
753 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
755 std::string &SuggestedPredefines) {
756 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
758 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
759 Complain? &Reader.Diags : nullptr,
765 bool SimpleASTReaderListener::ReadPreprocessorOptions(
766 const PreprocessorOptions &PPOpts,
768 std::string &SuggestedPredefines) {
769 return checkPreprocessorOptions(PPOpts,
770 PP.getPreprocessorOpts(),
778 /// Check the header search options deserialized from the control block
779 /// against the header search options in an existing preprocessor.
781 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
782 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
783 StringRef SpecificModuleCachePath,
784 StringRef ExistingModuleCachePath,
785 DiagnosticsEngine *Diags,
786 const LangOptions &LangOpts,
787 const PreprocessorOptions &PPOpts) {
788 if (LangOpts.Modules) {
789 if (SpecificModuleCachePath != ExistingModuleCachePath &&
790 !PPOpts.AllowPCHWithDifferentModulesCachePath) {
792 Diags->Report(diag::err_pch_modulecache_mismatch)
793 << SpecificModuleCachePath << ExistingModuleCachePath;
801 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
802 StringRef SpecificModuleCachePath,
804 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
805 PP.getHeaderSearchInfo().getModuleCachePath(),
806 Complain ? &Reader.Diags : nullptr,
807 PP.getLangOpts(), PP.getPreprocessorOpts());
810 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
811 PP.setCounterValue(Value);
814 //===----------------------------------------------------------------------===//
815 // AST reader implementation
816 //===----------------------------------------------------------------------===//
818 static uint64_t readULEB(const unsigned char *&P) {
820 const char *Error = nullptr;
822 uint64_t Val = llvm::decodeULEB128(P, &Length, nullptr, &Error);
824 llvm::report_fatal_error(Error);
829 /// Read ULEB-encoded key length and data length.
830 static std::pair<unsigned, unsigned>
831 readULEBKeyDataLength(const unsigned char *&P) {
832 unsigned KeyLen = readULEB(P);
833 if ((unsigned)KeyLen != KeyLen)
834 llvm::report_fatal_error("key too large");
836 unsigned DataLen = readULEB(P);
837 if ((unsigned)DataLen != DataLen)
838 llvm::report_fatal_error("data too large");
840 return std::make_pair(KeyLen, DataLen);
843 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
844 bool TakeOwnership) {
845 DeserializationListener = Listener;
846 OwnsDeserializationListener = TakeOwnership;
849 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
850 return serialization::ComputeHash(Sel);
853 std::pair<unsigned, unsigned>
854 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
855 return readULEBKeyDataLength(d);
858 ASTSelectorLookupTrait::internal_key_type
859 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
860 using namespace llvm::support;
862 SelectorTable &SelTable = Reader.getContext().Selectors;
863 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
864 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
865 F, endian::readNext<uint32_t, little, unaligned>(d));
867 return SelTable.getNullarySelector(FirstII);
869 return SelTable.getUnarySelector(FirstII);
871 SmallVector<IdentifierInfo *, 16> Args;
872 Args.push_back(FirstII);
873 for (unsigned I = 1; I != N; ++I)
874 Args.push_back(Reader.getLocalIdentifier(
875 F, endian::readNext<uint32_t, little, unaligned>(d)));
877 return SelTable.getSelector(N, Args.data());
880 ASTSelectorLookupTrait::data_type
881 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
883 using namespace llvm::support;
887 Result.ID = Reader.getGlobalSelectorID(
888 F, endian::readNext<uint32_t, little, unaligned>(d));
889 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
890 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
891 Result.InstanceBits = FullInstanceBits & 0x3;
892 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
893 Result.FactoryBits = FullFactoryBits & 0x3;
894 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
895 unsigned NumInstanceMethods = FullInstanceBits >> 3;
896 unsigned NumFactoryMethods = FullFactoryBits >> 3;
898 // Load instance methods
899 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
900 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
901 F, endian::readNext<uint32_t, little, unaligned>(d)))
902 Result.Instance.push_back(Method);
905 // Load factory methods
906 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
907 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
908 F, endian::readNext<uint32_t, little, unaligned>(d)))
909 Result.Factory.push_back(Method);
915 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
916 return llvm::djbHash(a);
919 std::pair<unsigned, unsigned>
920 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
921 return readULEBKeyDataLength(d);
924 ASTIdentifierLookupTraitBase::internal_key_type
925 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
926 assert(n >= 2 && d[n-1] == '\0');
927 return StringRef((const char*) d, n-1);
930 /// Whether the given identifier is "interesting".
931 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
933 return II.hadMacroDefinition() || II.isPoisoned() ||
934 (!IsModule && II.getObjCOrBuiltinID()) ||
935 II.hasRevertedTokenIDToIdentifier() ||
936 (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
937 II.getFETokenInfo());
940 static bool readBit(unsigned &Bits) {
941 bool Value = Bits & 0x1;
946 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
947 using namespace llvm::support;
949 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
950 return Reader.getGlobalIdentifierID(F, RawID >> 1);
953 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
954 if (!II.isFromAST()) {
956 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
957 if (isInterestingIdentifier(Reader, II, IsModule))
958 II.setChangedSinceDeserialization();
962 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
963 const unsigned char* d,
965 using namespace llvm::support;
967 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
968 bool IsInteresting = RawID & 0x01;
970 // Wipe out the "is interesting" bit.
973 // Build the IdentifierInfo and link the identifier ID with it.
974 IdentifierInfo *II = KnownII;
976 II = &Reader.getIdentifierTable().getOwn(k);
979 markIdentifierFromAST(Reader, *II);
980 Reader.markIdentifierUpToDate(II);
982 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
983 if (!IsInteresting) {
984 // For uninteresting identifiers, there's nothing else to do. Just notify
985 // the reader that we've finished loading this identifier.
986 Reader.SetIdentifierInfo(ID, II);
990 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
991 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
992 bool CPlusPlusOperatorKeyword = readBit(Bits);
993 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
994 bool Poisoned = readBit(Bits);
995 bool ExtensionToken = readBit(Bits);
996 bool HadMacroDefinition = readBit(Bits);
998 assert(Bits == 0 && "Extra bits in the identifier?");
1001 // Set or check the various bits in the IdentifierInfo structure.
1002 // Token IDs are read-only.
1003 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
1004 II->revertTokenIDToIdentifier();
1006 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
1007 assert(II->isExtensionToken() == ExtensionToken &&
1008 "Incorrect extension token flag");
1009 (void)ExtensionToken;
1011 II->setIsPoisoned(true);
1012 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
1013 "Incorrect C++ operator keyword flag");
1014 (void)CPlusPlusOperatorKeyword;
1016 // If this identifier is a macro, deserialize the macro
1018 if (HadMacroDefinition) {
1019 uint32_t MacroDirectivesOffset =
1020 endian::readNext<uint32_t, little, unaligned>(d);
1023 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1026 Reader.SetIdentifierInfo(ID, II);
1028 // Read all of the declarations visible at global scope with this
1031 SmallVector<uint32_t, 4> DeclIDs;
1032 for (; DataLen > 0; DataLen -= 4)
1033 DeclIDs.push_back(Reader.getGlobalDeclID(
1034 F, endian::readNext<uint32_t, little, unaligned>(d)));
1035 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1041 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1042 : Kind(Name.getNameKind()) {
1044 case DeclarationName::Identifier:
1045 Data = (uint64_t)Name.getAsIdentifierInfo();
1047 case DeclarationName::ObjCZeroArgSelector:
1048 case DeclarationName::ObjCOneArgSelector:
1049 case DeclarationName::ObjCMultiArgSelector:
1050 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1052 case DeclarationName::CXXOperatorName:
1053 Data = Name.getCXXOverloadedOperator();
1055 case DeclarationName::CXXLiteralOperatorName:
1056 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1058 case DeclarationName::CXXDeductionGuideName:
1059 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1060 ->getDeclName().getAsIdentifierInfo();
1062 case DeclarationName::CXXConstructorName:
1063 case DeclarationName::CXXDestructorName:
1064 case DeclarationName::CXXConversionFunctionName:
1065 case DeclarationName::CXXUsingDirective:
1071 unsigned DeclarationNameKey::getHash() const {
1072 llvm::FoldingSetNodeID ID;
1073 ID.AddInteger(Kind);
1076 case DeclarationName::Identifier:
1077 case DeclarationName::CXXLiteralOperatorName:
1078 case DeclarationName::CXXDeductionGuideName:
1079 ID.AddString(((IdentifierInfo*)Data)->getName());
1081 case DeclarationName::ObjCZeroArgSelector:
1082 case DeclarationName::ObjCOneArgSelector:
1083 case DeclarationName::ObjCMultiArgSelector:
1084 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1086 case DeclarationName::CXXOperatorName:
1087 ID.AddInteger((OverloadedOperatorKind)Data);
1089 case DeclarationName::CXXConstructorName:
1090 case DeclarationName::CXXDestructorName:
1091 case DeclarationName::CXXConversionFunctionName:
1092 case DeclarationName::CXXUsingDirective:
1096 return ID.ComputeHash();
1100 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1101 using namespace llvm::support;
1103 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1104 return Reader.getLocalModuleFile(F, ModuleFileID);
1107 std::pair<unsigned, unsigned>
1108 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1109 return readULEBKeyDataLength(d);
1112 ASTDeclContextNameLookupTrait::internal_key_type
1113 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1114 using namespace llvm::support;
1116 auto Kind = (DeclarationName::NameKind)*d++;
1119 case DeclarationName::Identifier:
1120 case DeclarationName::CXXLiteralOperatorName:
1121 case DeclarationName::CXXDeductionGuideName:
1122 Data = (uint64_t)Reader.getLocalIdentifier(
1123 F, endian::readNext<uint32_t, little, unaligned>(d));
1125 case DeclarationName::ObjCZeroArgSelector:
1126 case DeclarationName::ObjCOneArgSelector:
1127 case DeclarationName::ObjCMultiArgSelector:
1129 (uint64_t)Reader.getLocalSelector(
1130 F, endian::readNext<uint32_t, little, unaligned>(
1131 d)).getAsOpaquePtr();
1133 case DeclarationName::CXXOperatorName:
1134 Data = *d++; // OverloadedOperatorKind
1136 case DeclarationName::CXXConstructorName:
1137 case DeclarationName::CXXDestructorName:
1138 case DeclarationName::CXXConversionFunctionName:
1139 case DeclarationName::CXXUsingDirective:
1144 return DeclarationNameKey(Kind, Data);
1147 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1148 const unsigned char *d,
1150 data_type_builder &Val) {
1151 using namespace llvm::support;
1153 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1154 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1155 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1159 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1160 BitstreamCursor &Cursor,
1163 assert(Offset != 0);
1165 SavedStreamPosition SavedPosition(Cursor);
1166 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1167 Error(std::move(Err));
1173 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1175 Error(MaybeCode.takeError());
1178 unsigned Code = MaybeCode.get();
1180 Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1181 if (!MaybeRecCode) {
1182 Error(MaybeRecCode.takeError());
1185 unsigned RecCode = MaybeRecCode.get();
1186 if (RecCode != DECL_CONTEXT_LEXICAL) {
1187 Error("Expected lexical block");
1191 assert(!isa<TranslationUnitDecl>(DC) &&
1192 "expected a TU_UPDATE_LEXICAL record for TU");
1193 // If we are handling a C++ class template instantiation, we can see multiple
1194 // lexical updates for the same record. It's important that we select only one
1195 // of them, so that field numbering works properly. Just pick the first one we
1197 auto &Lex = LexicalDecls[DC];
1199 Lex = std::make_pair(
1200 &M, llvm::makeArrayRef(
1201 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1205 DC->setHasExternalLexicalStorage(true);
1209 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1210 BitstreamCursor &Cursor,
1213 assert(Offset != 0);
1215 SavedStreamPosition SavedPosition(Cursor);
1216 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1217 Error(std::move(Err));
1223 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1225 Error(MaybeCode.takeError());
1228 unsigned Code = MaybeCode.get();
1230 Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1231 if (!MaybeRecCode) {
1232 Error(MaybeRecCode.takeError());
1235 unsigned RecCode = MaybeRecCode.get();
1236 if (RecCode != DECL_CONTEXT_VISIBLE) {
1237 Error("Expected visible lookup table block");
1241 // We can't safely determine the primary context yet, so delay attaching the
1242 // lookup table until we're done with recursive deserialization.
1243 auto *Data = (const unsigned char*)Blob.data();
1244 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1248 void ASTReader::Error(StringRef Msg) const {
1249 Error(diag::err_fe_pch_malformed, Msg);
1250 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1251 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1252 Diag(diag::note_module_cache_path)
1253 << PP.getHeaderSearchInfo().getModuleCachePath();
1257 void ASTReader::Error(unsigned DiagID, StringRef Arg1, StringRef Arg2,
1258 StringRef Arg3) const {
1259 if (Diags.isDiagnosticInFlight())
1260 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1262 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1265 void ASTReader::Error(llvm::Error &&Err) const {
1266 Error(toString(std::move(Err)));
1269 //===----------------------------------------------------------------------===//
1270 // Source Manager Deserialization
1271 //===----------------------------------------------------------------------===//
1273 /// Read the line table in the source manager block.
1274 /// \returns true if there was an error.
1275 bool ASTReader::ParseLineTable(ModuleFile &F,
1276 const RecordData &Record) {
1278 LineTableInfo &LineTable = SourceMgr.getLineTable();
1280 // Parse the file names
1281 std::map<int, int> FileIDs;
1282 FileIDs[-1] = -1; // For unspecified filenames.
1283 for (unsigned I = 0; Record[Idx]; ++I) {
1284 // Extract the file name
1285 auto Filename = ReadPath(F, Record, Idx);
1286 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1290 // Parse the line entries
1291 std::vector<LineEntry> Entries;
1292 while (Idx < Record.size()) {
1293 int FID = Record[Idx++];
1294 assert(FID >= 0 && "Serialized line entries for non-local file.");
1295 // Remap FileID from 1-based old view.
1296 FID += F.SLocEntryBaseID - 1;
1298 // Extract the line entries
1299 unsigned NumEntries = Record[Idx++];
1300 assert(NumEntries && "no line entries for file ID");
1302 Entries.reserve(NumEntries);
1303 for (unsigned I = 0; I != NumEntries; ++I) {
1304 unsigned FileOffset = Record[Idx++];
1305 unsigned LineNo = Record[Idx++];
1306 int FilenameID = FileIDs[Record[Idx++]];
1307 SrcMgr::CharacteristicKind FileKind
1308 = (SrcMgr::CharacteristicKind)Record[Idx++];
1309 unsigned IncludeOffset = Record[Idx++];
1310 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1311 FileKind, IncludeOffset));
1313 LineTable.AddEntry(FileID::get(FID), Entries);
1319 /// Read a source manager block
1320 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1321 using namespace SrcMgr;
1323 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1325 // Set the source-location entry cursor to the current position in
1326 // the stream. This cursor will be used to read the contents of the
1327 // source manager block initially, and then lazily read
1328 // source-location entries as needed.
1329 SLocEntryCursor = F.Stream;
1331 // The stream itself is going to skip over the source manager block.
1332 if (llvm::Error Err = F.Stream.SkipBlock()) {
1333 Error(std::move(Err));
1337 // Enter the source manager block.
1338 if (llvm::Error Err =
1339 SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1340 Error(std::move(Err));
1343 F.SourceManagerBlockStartOffset = SLocEntryCursor.GetCurrentBitNo();
1347 Expected<llvm::BitstreamEntry> MaybeE =
1348 SLocEntryCursor.advanceSkippingSubblocks();
1350 Error(MaybeE.takeError());
1353 llvm::BitstreamEntry E = MaybeE.get();
1356 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1357 case llvm::BitstreamEntry::Error:
1358 Error("malformed block record in AST file");
1360 case llvm::BitstreamEntry::EndBlock:
1362 case llvm::BitstreamEntry::Record:
1363 // The interesting case.
1370 Expected<unsigned> MaybeRecord =
1371 SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1373 Error(MaybeRecord.takeError());
1376 switch (MaybeRecord.get()) {
1377 default: // Default behavior: ignore.
1380 case SM_SLOC_FILE_ENTRY:
1381 case SM_SLOC_BUFFER_ENTRY:
1382 case SM_SLOC_EXPANSION_ENTRY:
1383 // Once we hit one of the source location entries, we're done.
1389 /// If a header file is not found at the path that we expect it to be
1390 /// and the PCH file was moved from its original location, try to resolve the
1391 /// file by assuming that header+PCH were moved together and the header is in
1392 /// the same place relative to the PCH.
1394 resolveFileRelativeToOriginalDir(const std::string &Filename,
1395 const std::string &OriginalDir,
1396 const std::string &CurrDir) {
1397 assert(OriginalDir != CurrDir &&
1398 "No point trying to resolve the file if the PCH dir didn't change");
1400 using namespace llvm::sys;
1402 SmallString<128> filePath(Filename);
1403 fs::make_absolute(filePath);
1404 assert(path::is_absolute(OriginalDir));
1405 SmallString<128> currPCHPath(CurrDir);
1407 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1408 fileDirE = path::end(path::parent_path(filePath));
1409 path::const_iterator origDirI = path::begin(OriginalDir),
1410 origDirE = path::end(OriginalDir);
1411 // Skip the common path components from filePath and OriginalDir.
1412 while (fileDirI != fileDirE && origDirI != origDirE &&
1413 *fileDirI == *origDirI) {
1417 for (; origDirI != origDirE; ++origDirI)
1418 path::append(currPCHPath, "..");
1419 path::append(currPCHPath, fileDirI, fileDirE);
1420 path::append(currPCHPath, path::filename(Filename));
1421 return std::string(currPCHPath.str());
1424 bool ASTReader::ReadSLocEntry(int ID) {
1428 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1429 Error("source location entry ID out-of-range for AST file");
1433 // Local helper to read the (possibly-compressed) buffer data following the
1435 auto ReadBuffer = [this](
1436 BitstreamCursor &SLocEntryCursor,
1437 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1440 Expected<unsigned> MaybeCode = SLocEntryCursor.ReadCode();
1442 Error(MaybeCode.takeError());
1445 unsigned Code = MaybeCode.get();
1447 Expected<unsigned> MaybeRecCode =
1448 SLocEntryCursor.readRecord(Code, Record, &Blob);
1449 if (!MaybeRecCode) {
1450 Error(MaybeRecCode.takeError());
1453 unsigned RecCode = MaybeRecCode.get();
1455 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1456 if (!llvm::zlib::isAvailable()) {
1457 Error("zlib is not available");
1460 SmallString<0> Uncompressed;
1462 llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1463 Error("could not decompress embedded file contents: " +
1464 llvm::toString(std::move(E)));
1467 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1468 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1469 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1471 Error("AST record has invalid code");
1476 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1477 if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
1478 F->SLocEntryOffsetsBase +
1479 F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
1480 Error(std::move(Err));
1484 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1485 SourceLocation::UIntTy BaseOffset = F->SLocEntryBaseOffset;
1487 ++NumSLocEntriesRead;
1488 Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
1490 Error(MaybeEntry.takeError());
1493 llvm::BitstreamEntry Entry = MaybeEntry.get();
1495 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1496 Error("incorrectly-formatted source location entry in AST file");
1502 Expected<unsigned> MaybeSLOC =
1503 SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1505 Error(MaybeSLOC.takeError());
1508 switch (MaybeSLOC.get()) {
1510 Error("incorrectly-formatted source location entry in AST file");
1513 case SM_SLOC_FILE_ENTRY: {
1514 // We will detect whether a file changed and return 'Failure' for it, but
1515 // we will also try to fail gracefully by setting up the SLocEntry.
1516 unsigned InputID = Record[4];
1517 InputFile IF = getInputFile(*F, InputID);
1518 Optional<FileEntryRef> File = IF.getFile();
1519 bool OverriddenBuffer = IF.isOverridden();
1521 // Note that we only check if a File was returned. If it was out-of-date
1522 // we have complained but we will continue creating a FileID to recover
1527 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1528 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1529 // This is the module's main file.
1530 IncludeLoc = getImportLocation(F);
1532 SrcMgr::CharacteristicKind
1533 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1534 FileID FID = SourceMgr.createFileID(*File, IncludeLoc, FileCharacter, ID,
1535 BaseOffset + Record[0]);
1536 SrcMgr::FileInfo &FileInfo =
1537 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1538 FileInfo.NumCreatedFIDs = Record[5];
1540 FileInfo.setHasLineDirectives();
1542 unsigned NumFileDecls = Record[7];
1543 if (NumFileDecls && ContextObj) {
1544 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1545 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1546 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1550 const SrcMgr::ContentCache &ContentCache =
1551 SourceMgr.getOrCreateContentCache(*File, isSystem(FileCharacter));
1552 if (OverriddenBuffer && !ContentCache.BufferOverridden &&
1553 ContentCache.ContentsEntry == ContentCache.OrigEntry &&
1554 !ContentCache.getBufferIfLoaded()) {
1555 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1558 SourceMgr.overrideFileContents(*File, std::move(Buffer));
1564 case SM_SLOC_BUFFER_ENTRY: {
1565 const char *Name = Blob.data();
1566 unsigned Offset = Record[0];
1567 SrcMgr::CharacteristicKind
1568 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1569 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1570 if (IncludeLoc.isInvalid() && F->isModule()) {
1571 IncludeLoc = getImportLocation(F);
1574 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1577 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1578 BaseOffset + Offset, IncludeLoc);
1582 case SM_SLOC_EXPANSION_ENTRY: {
1583 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1584 SourceMgr.createExpansionLoc(SpellingLoc,
1585 ReadSourceLocation(*F, Record[2]),
1586 ReadSourceLocation(*F, Record[3]),
1590 BaseOffset + Record[0]);
1598 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1600 return std::make_pair(SourceLocation(), "");
1602 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1603 Error("source location entry ID out-of-range for AST file");
1604 return std::make_pair(SourceLocation(), "");
1607 // Find which module file this entry lands in.
1608 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1610 return std::make_pair(SourceLocation(), "");
1612 // FIXME: Can we map this down to a particular submodule? That would be
1614 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1617 /// Find the location where the module F is imported.
1618 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1619 if (F->ImportLoc.isValid())
1620 return F->ImportLoc;
1622 // Otherwise we have a PCH. It's considered to be "imported" at the first
1623 // location of its includer.
1624 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1625 // Main file is the importer.
1626 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1627 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1629 return F->ImportedBy[0]->FirstLoc;
1632 /// Enter a subblock of the specified BlockID with the specified cursor. Read
1633 /// the abbreviations that are at the top of the block and then leave the cursor
1634 /// pointing into the block.
1635 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID,
1636 uint64_t *StartOfBlockOffset) {
1637 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
1638 // FIXME this drops errors on the floor.
1639 consumeError(std::move(Err));
1643 if (StartOfBlockOffset)
1644 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1647 uint64_t Offset = Cursor.GetCurrentBitNo();
1648 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1650 // FIXME this drops errors on the floor.
1651 consumeError(MaybeCode.takeError());
1654 unsigned Code = MaybeCode.get();
1656 // We expect all abbrevs to be at the start of the block.
1657 if (Code != llvm::bitc::DEFINE_ABBREV) {
1658 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1659 // FIXME this drops errors on the floor.
1660 consumeError(std::move(Err));
1665 if (llvm::Error Err = Cursor.ReadAbbrevRecord()) {
1666 // FIXME this drops errors on the floor.
1667 consumeError(std::move(Err));
1673 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1677 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1678 Tok.setLength(Record[Idx++]);
1679 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1680 Tok.setIdentifierInfo(II);
1681 Tok.setKind((tok::TokenKind)Record[Idx++]);
1682 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1686 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1687 BitstreamCursor &Stream = F.MacroCursor;
1689 // Keep track of where we are in the stream, then jump back there
1690 // after reading this macro.
1691 SavedStreamPosition SavedPosition(Stream);
1693 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1694 // FIXME this drops errors on the floor.
1695 consumeError(std::move(Err));
1699 SmallVector<IdentifierInfo*, 16> MacroParams;
1700 MacroInfo *Macro = nullptr;
1703 // Advance to the next record, but if we get to the end of the block, don't
1704 // pop it (removing all the abbreviations from the cursor) since we want to
1705 // be able to reseek within the block and read entries.
1706 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1707 Expected<llvm::BitstreamEntry> MaybeEntry =
1708 Stream.advanceSkippingSubblocks(Flags);
1710 Error(MaybeEntry.takeError());
1713 llvm::BitstreamEntry Entry = MaybeEntry.get();
1715 switch (Entry.Kind) {
1716 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1717 case llvm::BitstreamEntry::Error:
1718 Error("malformed block record in AST file");
1720 case llvm::BitstreamEntry::EndBlock:
1722 case llvm::BitstreamEntry::Record:
1723 // The interesting case.
1729 PreprocessorRecordTypes RecType;
1730 if (Expected<unsigned> MaybeRecType = Stream.readRecord(Entry.ID, Record))
1731 RecType = (PreprocessorRecordTypes)MaybeRecType.get();
1733 Error(MaybeRecType.takeError());
1737 case PP_MODULE_MACRO:
1738 case PP_MACRO_DIRECTIVE_HISTORY:
1741 case PP_MACRO_OBJECT_LIKE:
1742 case PP_MACRO_FUNCTION_LIKE: {
1743 // If we already have a macro, that means that we've hit the end
1744 // of the definition of the macro we were looking for. We're
1749 unsigned NextIndex = 1; // Skip identifier ID.
1750 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1751 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1752 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1753 MI->setIsUsed(Record[NextIndex++]);
1754 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1756 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1757 // Decode function-like macro info.
1758 bool isC99VarArgs = Record[NextIndex++];
1759 bool isGNUVarArgs = Record[NextIndex++];
1760 bool hasCommaPasting = Record[NextIndex++];
1761 MacroParams.clear();
1762 unsigned NumArgs = Record[NextIndex++];
1763 for (unsigned i = 0; i != NumArgs; ++i)
1764 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1766 // Install function-like macro info.
1767 MI->setIsFunctionLike();
1768 if (isC99VarArgs) MI->setIsC99Varargs();
1769 if (isGNUVarArgs) MI->setIsGNUVarargs();
1770 if (hasCommaPasting) MI->setHasCommaPasting();
1771 MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1774 // Remember that we saw this macro last so that we add the tokens that
1775 // form its body to it.
1778 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1779 Record[NextIndex]) {
1780 // We have a macro definition. Register the association
1781 PreprocessedEntityID
1782 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1783 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1784 PreprocessingRecord::PPEntityID PPID =
1785 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1786 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1787 PPRec.getPreprocessedEntity(PPID));
1789 PPRec.RegisterMacroDefinition(Macro, PPDef);
1797 // If we see a TOKEN before a PP_MACRO_*, then the file is
1798 // erroneous, just pretend we didn't see this.
1802 Token Tok = ReadToken(F, Record, Idx);
1803 Macro->AddTokenToBody(Tok);
1810 PreprocessedEntityID
1811 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1812 unsigned LocalID) const {
1813 if (!M.ModuleOffsetMap.empty())
1814 ReadModuleOffsetMap(M);
1816 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1817 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1818 assert(I != M.PreprocessedEntityRemap.end()
1819 && "Invalid index into preprocessed entity index remap");
1821 return LocalID + I->second;
1824 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1825 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1828 HeaderFileInfoTrait::internal_key_type
1829 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1830 internal_key_type ikey = {FE->getSize(),
1831 M.HasTimestamps ? FE->getModificationTime() : 0,
1832 FE->getName(), /*Imported*/ false};
1836 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1837 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1840 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1843 // Determine whether the actual files are equivalent.
1844 FileManager &FileMgr = Reader.getFileManager();
1845 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1846 if (!Key.Imported) {
1847 if (auto File = FileMgr.getFile(Key.Filename))
1852 std::string Resolved = std::string(Key.Filename);
1853 Reader.ResolveImportedPath(M, Resolved);
1854 if (auto File = FileMgr.getFile(Resolved))
1859 const FileEntry *FEA = GetFile(a);
1860 const FileEntry *FEB = GetFile(b);
1861 return FEA && FEA == FEB;
1864 std::pair<unsigned, unsigned>
1865 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1866 return readULEBKeyDataLength(d);
1869 HeaderFileInfoTrait::internal_key_type
1870 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1871 using namespace llvm::support;
1873 internal_key_type ikey;
1874 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1875 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1876 ikey.Filename = (const char *)d;
1877 ikey.Imported = true;
1881 HeaderFileInfoTrait::data_type
1882 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1884 using namespace llvm::support;
1886 const unsigned char *End = d + DataLen;
1888 unsigned Flags = *d++;
1889 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1890 HFI.isImport |= (Flags >> 5) & 0x01;
1891 HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1892 HFI.DirInfo = (Flags >> 1) & 0x07;
1893 HFI.IndexHeaderMapHeader = Flags & 0x01;
1894 // FIXME: Find a better way to handle this. Maybe just store a
1895 // "has been included" flag?
1896 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1898 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1899 M, endian::readNext<uint32_t, little, unaligned>(d));
1900 if (unsigned FrameworkOffset =
1901 endian::readNext<uint32_t, little, unaligned>(d)) {
1902 // The framework offset is 1 greater than the actual offset,
1903 // since 0 is used as an indicator for "no framework name".
1904 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1905 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1908 assert((End - d) % 4 == 0 &&
1909 "Wrong data length in HeaderFileInfo deserialization");
1911 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1912 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1915 // This header is part of a module. Associate it with the module to enable
1916 // implicit module import.
1917 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1918 Module *Mod = Reader.getSubmodule(GlobalSMID);
1919 FileManager &FileMgr = Reader.getFileManager();
1921 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1923 std::string Filename = std::string(key.Filename);
1925 Reader.ResolveImportedPath(M, Filename);
1926 // FIXME: NameAsWritten
1927 Module::Header H = {std::string(key.Filename), "",
1928 *FileMgr.getFile(Filename)};
1929 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1930 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1933 // This HeaderFileInfo was externally loaded.
1934 HFI.External = true;
1939 void ASTReader::addPendingMacro(IdentifierInfo *II, ModuleFile *M,
1940 uint32_t MacroDirectivesOffset) {
1941 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1942 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1945 void ASTReader::ReadDefinedMacros() {
1946 // Note that we are loading defined macros.
1947 Deserializing Macros(this);
1949 for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1950 BitstreamCursor &MacroCursor = I.MacroCursor;
1952 // If there was no preprocessor block, skip this file.
1953 if (MacroCursor.getBitcodeBytes().empty())
1956 BitstreamCursor Cursor = MacroCursor;
1957 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
1958 Error(std::move(Err));
1964 Expected<llvm::BitstreamEntry> MaybeE = Cursor.advanceSkippingSubblocks();
1966 Error(MaybeE.takeError());
1969 llvm::BitstreamEntry E = MaybeE.get();
1972 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1973 case llvm::BitstreamEntry::Error:
1974 Error("malformed block record in AST file");
1976 case llvm::BitstreamEntry::EndBlock:
1979 case llvm::BitstreamEntry::Record: {
1981 Expected<unsigned> MaybeRecord = Cursor.readRecord(E.ID, Record);
1983 Error(MaybeRecord.takeError());
1986 switch (MaybeRecord.get()) {
1987 default: // Default behavior: ignore.
1990 case PP_MACRO_OBJECT_LIKE:
1991 case PP_MACRO_FUNCTION_LIKE: {
1992 IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1993 if (II->isOutOfDate())
1994 updateOutOfDateIdentifier(*II);
2012 /// Visitor class used to look up identifirs in an AST file.
2013 class IdentifierLookupVisitor {
2016 unsigned PriorGeneration;
2017 unsigned &NumIdentifierLookups;
2018 unsigned &NumIdentifierLookupHits;
2019 IdentifierInfo *Found = nullptr;
2022 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
2023 unsigned &NumIdentifierLookups,
2024 unsigned &NumIdentifierLookupHits)
2025 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
2026 PriorGeneration(PriorGeneration),
2027 NumIdentifierLookups(NumIdentifierLookups),
2028 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2030 bool operator()(ModuleFile &M) {
2031 // If we've already searched this module file, skip it now.
2032 if (M.Generation <= PriorGeneration)
2035 ASTIdentifierLookupTable *IdTable
2036 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2040 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
2042 ++NumIdentifierLookups;
2043 ASTIdentifierLookupTable::iterator Pos =
2044 IdTable->find_hashed(Name, NameHash, &Trait);
2045 if (Pos == IdTable->end())
2048 // Dereferencing the iterator has the effect of building the
2049 // IdentifierInfo node and populating it with the various
2050 // declarations it needs.
2051 ++NumIdentifierLookupHits;
2056 // Retrieve the identifier info found within the module
2058 IdentifierInfo *getIdentifierInfo() const { return Found; }
2063 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
2064 // Note that we are loading an identifier.
2065 Deserializing AnIdentifier(this);
2067 unsigned PriorGeneration = 0;
2068 if (getContext().getLangOpts().Modules)
2069 PriorGeneration = IdentifierGeneration[&II];
2071 // If there is a global index, look there first to determine which modules
2072 // provably do not have any results for this identifier.
2073 GlobalModuleIndex::HitSet Hits;
2074 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
2075 if (!loadGlobalIndex()) {
2076 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
2081 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
2082 NumIdentifierLookups,
2083 NumIdentifierLookupHits);
2084 ModuleMgr.visit(Visitor, HitsPtr);
2085 markIdentifierUpToDate(&II);
2088 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
2092 II->setOutOfDate(false);
2094 // Update the generation for this identifier.
2095 if (getContext().getLangOpts().Modules)
2096 IdentifierGeneration[II] = getGeneration();
2099 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
2100 const PendingMacroInfo &PMInfo) {
2101 ModuleFile &M = *PMInfo.M;
2103 BitstreamCursor &Cursor = M.MacroCursor;
2104 SavedStreamPosition SavedPosition(Cursor);
2105 if (llvm::Error Err =
2106 Cursor.JumpToBit(M.MacroOffsetsBase + PMInfo.MacroDirectivesOffset)) {
2107 Error(std::move(Err));
2111 struct ModuleMacroRecord {
2112 SubmoduleID SubModID;
2114 SmallVector<SubmoduleID, 8> Overrides;
2116 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
2118 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
2119 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
2123 Expected<llvm::BitstreamEntry> MaybeEntry =
2124 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2126 Error(MaybeEntry.takeError());
2129 llvm::BitstreamEntry Entry = MaybeEntry.get();
2131 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2132 Error("malformed block record in AST file");
2137 Expected<unsigned> MaybePP = Cursor.readRecord(Entry.ID, Record);
2139 Error(MaybePP.takeError());
2142 switch ((PreprocessorRecordTypes)MaybePP.get()) {
2143 case PP_MACRO_DIRECTIVE_HISTORY:
2146 case PP_MODULE_MACRO: {
2147 ModuleMacros.push_back(ModuleMacroRecord());
2148 auto &Info = ModuleMacros.back();
2149 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2150 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2151 for (int I = 2, N = Record.size(); I != N; ++I)
2152 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2157 Error("malformed block record in AST file");
2161 // We found the macro directive history; that's the last record
2166 // Module macros are listed in reverse dependency order.
2168 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2169 llvm::SmallVector<ModuleMacro*, 8> Overrides;
2170 for (auto &MMR : ModuleMacros) {
2172 for (unsigned ModID : MMR.Overrides) {
2173 Module *Mod = getSubmodule(ModID);
2174 auto *Macro = PP.getModuleMacro(Mod, II);
2175 assert(Macro && "missing definition for overridden macro");
2176 Overrides.push_back(Macro);
2179 bool Inserted = false;
2180 Module *Owner = getSubmodule(MMR.SubModID);
2181 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2185 // Don't read the directive history for a module; we don't have anywhere
2190 // Deserialize the macro directives history in reverse source-order.
2191 MacroDirective *Latest = nullptr, *Earliest = nullptr;
2192 unsigned Idx = 0, N = Record.size();
2194 MacroDirective *MD = nullptr;
2195 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2196 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2198 case MacroDirective::MD_Define: {
2199 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2200 MD = PP.AllocateDefMacroDirective(MI, Loc);
2203 case MacroDirective::MD_Undefine:
2204 MD = PP.AllocateUndefMacroDirective(Loc);
2206 case MacroDirective::MD_Visibility:
2207 bool isPublic = Record[Idx++];
2208 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2215 Earliest->setPrevious(MD);
2220 PP.setLoadedMacroDirective(II, Earliest, Latest);
2223 bool ASTReader::shouldDisableValidationForFile(
2224 const serialization::ModuleFile &M) const {
2225 if (DisableValidationKind == DisableValidationForModuleKind::None)
2228 // If a PCH is loaded and validation is disabled for PCH then disable
2229 // validation for the PCH and the modules it loads.
2230 ModuleKind K = CurrentDeserializingModuleKind.getValueOr(M.Kind);
2236 return bool(DisableValidationKind & DisableValidationForModuleKind::PCH);
2237 case MK_ImplicitModule:
2238 case MK_ExplicitModule:
2239 case MK_PrebuiltModule:
2240 return bool(DisableValidationKind & DisableValidationForModuleKind::Module);
2246 ASTReader::InputFileInfo
2247 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2248 // Go find this input file.
2249 BitstreamCursor &Cursor = F.InputFilesCursor;
2250 SavedStreamPosition SavedPosition(Cursor);
2251 if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2252 // FIXME this drops errors on the floor.
2253 consumeError(std::move(Err));
2256 Expected<unsigned> MaybeCode = Cursor.ReadCode();
2258 // FIXME this drops errors on the floor.
2259 consumeError(MaybeCode.takeError());
2261 unsigned Code = MaybeCode.get();
2265 if (Expected<unsigned> Maybe = Cursor.readRecord(Code, Record, &Blob))
2266 assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE &&
2267 "invalid record type for input file");
2269 // FIXME this drops errors on the floor.
2270 consumeError(Maybe.takeError());
2273 assert(Record[0] == ID && "Bogus stored ID or offset");
2275 R.StoredSize = static_cast<off_t>(Record[1]);
2276 R.StoredTime = static_cast<time_t>(Record[2]);
2277 R.Overridden = static_cast<bool>(Record[3]);
2278 R.Transient = static_cast<bool>(Record[4]);
2279 R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2280 R.Filename = std::string(Blob);
2281 ResolveImportedPath(F, R.Filename);
2283 Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
2284 if (!MaybeEntry) // FIXME this drops errors on the floor.
2285 consumeError(MaybeEntry.takeError());
2286 llvm::BitstreamEntry Entry = MaybeEntry.get();
2287 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2288 "expected record type for input file hash");
2291 if (Expected<unsigned> Maybe = Cursor.readRecord(Entry.ID, Record))
2292 assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE_HASH &&
2293 "invalid record type for input file hash");
2295 // FIXME this drops errors on the floor.
2296 consumeError(Maybe.takeError());
2298 R.ContentHash = (static_cast<uint64_t>(Record[1]) << 32) |
2299 static_cast<uint64_t>(Record[0]);
2303 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2304 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2305 // If this ID is bogus, just return an empty input file.
2306 if (ID == 0 || ID > F.InputFilesLoaded.size())
2309 // If we've already loaded this input file, return it.
2310 if (F.InputFilesLoaded[ID-1].getFile())
2311 return F.InputFilesLoaded[ID-1];
2313 if (F.InputFilesLoaded[ID-1].isNotFound())
2316 // Go find this input file.
2317 BitstreamCursor &Cursor = F.InputFilesCursor;
2318 SavedStreamPosition SavedPosition(Cursor);
2319 if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2320 // FIXME this drops errors on the floor.
2321 consumeError(std::move(Err));
2324 InputFileInfo FI = readInputFileInfo(F, ID);
2325 off_t StoredSize = FI.StoredSize;
2326 time_t StoredTime = FI.StoredTime;
2327 bool Overridden = FI.Overridden;
2328 bool Transient = FI.Transient;
2329 StringRef Filename = FI.Filename;
2330 uint64_t StoredContentHash = FI.ContentHash;
2332 OptionalFileEntryRefDegradesToFileEntryPtr File =
2333 expectedToOptional(FileMgr.getFileRef(Filename, /*OpenFile=*/false));
2335 // If we didn't find the file, resolve it relative to the
2336 // original directory from which this AST file was created.
2337 if (!File && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2338 F.OriginalDir != F.BaseDirectory) {
2339 std::string Resolved = resolveFileRelativeToOriginalDir(
2340 std::string(Filename), F.OriginalDir, F.BaseDirectory);
2341 if (!Resolved.empty())
2342 File = expectedToOptional(FileMgr.getFileRef(Resolved));
2345 // For an overridden file, create a virtual file with the stored
2347 if ((Overridden || Transient) && !File)
2348 File = FileMgr.getVirtualFileRef(Filename, StoredSize, StoredTime);
2352 std::string ErrorStr = "could not find file '";
2353 ErrorStr += Filename;
2354 ErrorStr += "' referenced by AST file '";
2355 ErrorStr += F.FileName;
2359 // Record that we didn't find the file.
2360 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2364 // Check if there was a request to override the contents of the file
2365 // that was part of the precompiled header. Overriding such a file
2366 // can lead to problems when lexing using the source locations from the
2368 SourceManager &SM = getSourceManager();
2369 // FIXME: Reject if the overrides are different.
2370 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2372 Error(diag::err_fe_pch_file_overridden, Filename);
2374 // After emitting the diagnostic, bypass the overriding file to recover
2375 // (this creates a separate FileEntry).
2376 File = SM.bypassFileContentsOverride(*File);
2378 F.InputFilesLoaded[ID - 1] = InputFile::getNotFound();
2383 enum ModificationType {
2389 auto HasInputFileChanged = [&]() {
2390 if (StoredSize != File->getSize())
2391 return ModificationType::Size;
2392 if (!shouldDisableValidationForFile(F) && StoredTime &&
2393 StoredTime != File->getModificationTime()) {
2394 // In case the modification time changes but not the content,
2395 // accept the cached file as legit.
2396 if (ValidateASTInputFilesContent &&
2397 StoredContentHash != static_cast<uint64_t>(llvm::hash_code(-1))) {
2398 auto MemBuffOrError = FileMgr.getBufferForFile(File);
2399 if (!MemBuffOrError) {
2401 return ModificationType::ModTime;
2402 std::string ErrorStr = "could not get buffer for file '";
2403 ErrorStr += File->getName();
2406 return ModificationType::ModTime;
2409 auto ContentHash = hash_value(MemBuffOrError.get()->getBuffer());
2410 if (StoredContentHash == static_cast<uint64_t>(ContentHash))
2411 return ModificationType::None;
2412 return ModificationType::Content;
2414 return ModificationType::ModTime;
2416 return ModificationType::None;
2419 bool IsOutOfDate = false;
2420 auto FileChange = HasInputFileChanged();
2421 // For an overridden file, there is nothing to validate.
2422 if (!Overridden && FileChange != ModificationType::None) {
2423 if (Complain && !Diags.isDiagnosticInFlight()) {
2424 // Build a list of the PCH imports that got us here (in reverse).
2425 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2426 while (!ImportStack.back()->ImportedBy.empty())
2427 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2429 // The top-level PCH is stale.
2430 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2431 Diag(diag::err_fe_ast_file_modified)
2432 << Filename << moduleKindForDiagnostic(ImportStack.back()->Kind)
2433 << TopLevelPCHName << FileChange;
2435 // Print the import stack.
2436 if (ImportStack.size() > 1) {
2437 Diag(diag::note_pch_required_by)
2438 << Filename << ImportStack[0]->FileName;
2439 for (unsigned I = 1; I < ImportStack.size(); ++I)
2440 Diag(diag::note_pch_required_by)
2441 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2444 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2449 // FIXME: If the file is overridden and we've already opened it,
2450 // issue an error (or split it into a separate FileEntry).
2452 InputFile IF = InputFile(*File, Overridden || Transient, IsOutOfDate);
2454 // Note that we've loaded this input file.
2455 F.InputFilesLoaded[ID-1] = IF;
2459 /// If we are loading a relocatable PCH or module file, and the filename
2460 /// is not an absolute path, add the system or module root to the beginning of
2462 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2463 // Resolve relative to the base directory, if we have one.
2464 if (!M.BaseDirectory.empty())
2465 return ResolveImportedPath(Filename, M.BaseDirectory);
2468 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2469 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2472 SmallString<128> Buffer;
2473 llvm::sys::path::append(Buffer, Prefix, Filename);
2474 Filename.assign(Buffer.begin(), Buffer.end());
2477 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2479 case ASTReader::Failure: return true;
2480 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2481 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2482 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2483 case ASTReader::ConfigurationMismatch:
2484 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2485 case ASTReader::HadErrors: return true;
2486 case ASTReader::Success: return false;
2489 llvm_unreachable("unknown ASTReadResult");
2492 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2493 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2494 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2495 std::string &SuggestedPredefines) {
2496 if (llvm::Error Err = Stream.EnterSubBlock(OPTIONS_BLOCK_ID)) {
2497 // FIXME this drops errors on the floor.
2498 consumeError(std::move(Err));
2502 // Read all of the records in the options block.
2504 ASTReadResult Result = Success;
2506 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2508 // FIXME this drops errors on the floor.
2509 consumeError(MaybeEntry.takeError());
2512 llvm::BitstreamEntry Entry = MaybeEntry.get();
2514 switch (Entry.Kind) {
2515 case llvm::BitstreamEntry::Error:
2516 case llvm::BitstreamEntry::SubBlock:
2519 case llvm::BitstreamEntry::EndBlock:
2522 case llvm::BitstreamEntry::Record:
2523 // The interesting case.
2527 // Read and process a record.
2529 Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
2530 if (!MaybeRecordType) {
2531 // FIXME this drops errors on the floor.
2532 consumeError(MaybeRecordType.takeError());
2535 switch ((OptionsRecordTypes)MaybeRecordType.get()) {
2536 case LANGUAGE_OPTIONS: {
2537 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2538 if (ParseLanguageOptions(Record, Complain, Listener,
2539 AllowCompatibleConfigurationMismatch))
2540 Result = ConfigurationMismatch;
2544 case TARGET_OPTIONS: {
2545 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2546 if (ParseTargetOptions(Record, Complain, Listener,
2547 AllowCompatibleConfigurationMismatch))
2548 Result = ConfigurationMismatch;
2552 case FILE_SYSTEM_OPTIONS: {
2553 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2554 if (!AllowCompatibleConfigurationMismatch &&
2555 ParseFileSystemOptions(Record, Complain, Listener))
2556 Result = ConfigurationMismatch;
2560 case HEADER_SEARCH_OPTIONS: {
2561 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2562 if (!AllowCompatibleConfigurationMismatch &&
2563 ParseHeaderSearchOptions(Record, Complain, Listener))
2564 Result = ConfigurationMismatch;
2568 case PREPROCESSOR_OPTIONS:
2569 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2570 if (!AllowCompatibleConfigurationMismatch &&
2571 ParsePreprocessorOptions(Record, Complain, Listener,
2572 SuggestedPredefines))
2573 Result = ConfigurationMismatch;
2579 ASTReader::ASTReadResult
2580 ASTReader::ReadControlBlock(ModuleFile &F,
2581 SmallVectorImpl<ImportedModule> &Loaded,
2582 const ModuleFile *ImportedBy,
2583 unsigned ClientLoadCapabilities) {
2584 BitstreamCursor &Stream = F.Stream;
2586 if (llvm::Error Err = Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2587 Error(std::move(Err));
2591 // Lambda to read the unhashed control block the first time it's called.
2593 // For PCM files, the unhashed control block cannot be read until after the
2594 // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2595 // need to look ahead before reading the IMPORTS record. For consistency,
2596 // this block is always read somehow (see BitstreamEntry::EndBlock).
2597 bool HasReadUnhashedControlBlock = false;
2598 auto readUnhashedControlBlockOnce = [&]() {
2599 if (!HasReadUnhashedControlBlock) {
2600 HasReadUnhashedControlBlock = true;
2601 if (ASTReadResult Result =
2602 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2608 bool DisableValidation = shouldDisableValidationForFile(F);
2610 // Read all of the records and blocks in the control block.
2612 unsigned NumInputs = 0;
2613 unsigned NumUserInputs = 0;
2614 StringRef BaseDirectoryAsWritten;
2616 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2618 Error(MaybeEntry.takeError());
2621 llvm::BitstreamEntry Entry = MaybeEntry.get();
2623 switch (Entry.Kind) {
2624 case llvm::BitstreamEntry::Error:
2625 Error("malformed block record in AST file");
2627 case llvm::BitstreamEntry::EndBlock: {
2628 // Validate the module before returning. This call catches an AST with
2629 // no module name and no imports.
2630 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2633 // Validate input files.
2634 const HeaderSearchOptions &HSOpts =
2635 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2637 // All user input files reside at the index range [0, NumUserInputs), and
2638 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2639 // loaded module files, ignore missing inputs.
2640 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2641 F.Kind != MK_PrebuiltModule) {
2642 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2644 // If we are reading a module, we will create a verification timestamp,
2645 // so we verify all input files. Otherwise, verify only user input
2648 unsigned N = NumUserInputs;
2649 if (ValidateSystemInputs ||
2650 (HSOpts.ModulesValidateOncePerBuildSession &&
2651 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2652 F.Kind == MK_ImplicitModule))
2655 for (unsigned I = 0; I < N; ++I) {
2656 InputFile IF = getInputFile(F, I+1, Complain);
2657 if (!IF.getFile() || IF.isOutOfDate())
2663 Listener->visitModuleFile(F.FileName, F.Kind);
2665 if (Listener && Listener->needsInputFileVisitation()) {
2666 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2668 for (unsigned I = 0; I < N; ++I) {
2669 bool IsSystem = I >= NumUserInputs;
2670 InputFileInfo FI = readInputFileInfo(F, I+1);
2671 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2672 F.Kind == MK_ExplicitModule ||
2673 F.Kind == MK_PrebuiltModule);
2680 case llvm::BitstreamEntry::SubBlock:
2682 case INPUT_FILES_BLOCK_ID:
2683 F.InputFilesCursor = Stream;
2684 if (llvm::Error Err = Stream.SkipBlock()) {
2685 Error(std::move(Err));
2688 if (ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2689 Error("malformed block record in AST file");
2694 case OPTIONS_BLOCK_ID:
2695 // If we're reading the first module for this group, check its options
2696 // are compatible with ours. For modules it imports, no further checking
2697 // is required, because we checked them when we built it.
2698 if (Listener && !ImportedBy) {
2699 // Should we allow the configuration of the module file to differ from
2700 // the configuration of the current translation unit in a compatible
2703 // FIXME: Allow this for files explicitly specified with -include-pch.
2704 bool AllowCompatibleConfigurationMismatch =
2705 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2707 ASTReadResult Result =
2708 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2709 AllowCompatibleConfigurationMismatch, *Listener,
2710 SuggestedPredefines);
2711 if (Result == Failure) {
2712 Error("malformed block record in AST file");
2716 if (DisableValidation ||
2717 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2720 // If we can't load the module, exit early since we likely
2721 // will rebuild the module anyway. The stream may be in the
2722 // middle of a block.
2723 if (Result != Success)
2725 } else if (llvm::Error Err = Stream.SkipBlock()) {
2726 Error(std::move(Err));
2732 if (llvm::Error Err = Stream.SkipBlock()) {
2733 Error(std::move(Err));
2739 case llvm::BitstreamEntry::Record:
2740 // The interesting case.
2744 // Read and process a record.
2747 Expected<unsigned> MaybeRecordType =
2748 Stream.readRecord(Entry.ID, Record, &Blob);
2749 if (!MaybeRecordType) {
2750 Error(MaybeRecordType.takeError());
2753 switch ((ControlRecordTypes)MaybeRecordType.get()) {
2755 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2756 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2757 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2758 : diag::err_pch_version_too_new);
2759 return VersionMismatch;
2762 bool hasErrors = Record[6];
2763 if (hasErrors && !DisableValidation) {
2764 // If requested by the caller and the module hasn't already been read
2765 // or compiled, mark modules on error as out-of-date.
2766 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2767 canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
2770 if (!AllowASTWithCompilerErrors) {
2771 Diag(diag::err_pch_with_compiler_errors);
2776 Diags.ErrorOccurred = true;
2777 Diags.UncompilableErrorOccurred = true;
2778 Diags.UnrecoverableErrorOccurred = true;
2781 F.RelocatablePCH = Record[4];
2782 // Relative paths in a relocatable PCH are relative to our sysroot.
2783 if (F.RelocatablePCH)
2784 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2786 F.HasTimestamps = Record[5];
2788 const std::string &CurBranch = getClangFullRepositoryVersion();
2789 StringRef ASTBranch = Blob;
2790 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2791 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2792 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2793 return VersionMismatch;
2799 // Validate the AST before processing any imports (otherwise, untangling
2800 // them can be error-prone and expensive). A module will have a name and
2801 // will already have been validated, but this catches the PCH case.
2802 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2805 // Load each of the imported PCH files.
2806 unsigned Idx = 0, N = Record.size();
2808 // Read information about the AST file.
2809 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2810 // The import location will be the local one for now; we will adjust
2811 // all import locations of module imports after the global source
2812 // location info are setup, in ReadAST.
2813 SourceLocation ImportLoc =
2814 ReadUntranslatedSourceLocation(Record[Idx++]);
2815 off_t StoredSize = (off_t)Record[Idx++];
2816 time_t StoredModTime = (time_t)Record[Idx++];
2817 auto FirstSignatureByte = Record.begin() + Idx;
2818 ASTFileSignature StoredSignature = ASTFileSignature::create(
2819 FirstSignatureByte, FirstSignatureByte + ASTFileSignature::size);
2820 Idx += ASTFileSignature::size;
2822 std::string ImportedName = ReadString(Record, Idx);
2823 std::string ImportedFile;
2825 // For prebuilt and explicit modules first consult the file map for
2826 // an override. Note that here we don't search prebuilt module
2827 // directories, only the explicit name to file mappings. Also, we will
2828 // still verify the size/signature making sure it is essentially the
2829 // same file but perhaps in a different location.
2830 if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2831 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2832 ImportedName, /*FileMapOnly*/ true);
2834 if (ImportedFile.empty())
2835 // Use BaseDirectoryAsWritten to ensure we use the same path in the
2836 // ModuleCache as when writing.
2837 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2839 SkipPath(Record, Idx);
2841 // If our client can't cope with us being out of date, we can't cope with
2842 // our dependency being missing.
2843 unsigned Capabilities = ClientLoadCapabilities;
2844 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2845 Capabilities &= ~ARR_Missing;
2847 // Load the AST file.
2848 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2849 Loaded, StoredSize, StoredModTime,
2850 StoredSignature, Capabilities);
2852 // If we diagnosed a problem, produce a backtrace.
2853 bool recompilingFinalized =
2854 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
2855 getModuleManager().getModuleCache().isPCMFinal(F.FileName);
2856 if (isDiagnosedResult(Result, Capabilities) || recompilingFinalized)
2857 Diag(diag::note_module_file_imported_by)
2858 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2859 if (recompilingFinalized)
2860 Diag(diag::note_module_file_conflict);
2863 case Failure: return Failure;
2864 // If we have to ignore the dependency, we'll have to ignore this too.
2866 case OutOfDate: return OutOfDate;
2867 case VersionMismatch: return VersionMismatch;
2868 case ConfigurationMismatch: return ConfigurationMismatch;
2869 case HadErrors: return HadErrors;
2870 case Success: break;
2877 F.OriginalSourceFileID = FileID::get(Record[0]);
2878 F.ActualOriginalSourceFileName = std::string(Blob);
2879 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2880 ResolveImportedPath(F, F.OriginalSourceFileName);
2883 case ORIGINAL_FILE_ID:
2884 F.OriginalSourceFileID = FileID::get(Record[0]);
2887 case ORIGINAL_PCH_DIR:
2888 F.OriginalDir = std::string(Blob);
2892 F.ModuleName = std::string(Blob);
2893 Diag(diag::remark_module_import)
2894 << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2895 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2897 Listener->ReadModuleName(F.ModuleName);
2899 // Validate the AST as soon as we have a name so we can exit early on
2901 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2906 case MODULE_DIRECTORY: {
2907 // Save the BaseDirectory as written in the PCM for computing the module
2908 // filename for the ModuleCache.
2909 BaseDirectoryAsWritten = Blob;
2910 assert(!F.ModuleName.empty() &&
2911 "MODULE_DIRECTORY found before MODULE_NAME");
2912 // If we've already loaded a module map file covering this module, we may
2913 // have a better path for it (relative to the current build).
2914 Module *M = PP.getHeaderSearchInfo().lookupModule(
2915 F.ModuleName, /*AllowSearch*/ true,
2916 /*AllowExtraModuleMapSearch*/ true);
2917 if (M && M->Directory) {
2918 // If we're implicitly loading a module, the base directory can't
2919 // change between the build and use.
2920 // Don't emit module relocation error if we have -fno-validate-pch
2921 if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
2922 DisableValidationForModuleKind::Module) &&
2923 F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2924 auto BuildDir = PP.getFileManager().getDirectory(Blob);
2925 if (!BuildDir || *BuildDir != M->Directory) {
2926 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
2927 Diag(diag::err_imported_module_relocated)
2928 << F.ModuleName << Blob << M->Directory->getName();
2932 F.BaseDirectory = std::string(M->Directory->getName());
2934 F.BaseDirectory = std::string(Blob);
2939 case MODULE_MAP_FILE:
2940 if (ASTReadResult Result =
2941 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2945 case INPUT_FILE_OFFSETS:
2946 NumInputs = Record[0];
2947 NumUserInputs = Record[1];
2948 F.InputFileOffsets =
2949 (const llvm::support::unaligned_uint64_t *)Blob.data();
2950 F.InputFilesLoaded.resize(NumInputs);
2951 F.NumUserInputFiles = NumUserInputs;
2957 ASTReader::ASTReadResult
2958 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2959 BitstreamCursor &Stream = F.Stream;
2961 if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID)) {
2962 Error(std::move(Err));
2965 F.ASTBlockStartOffset = Stream.GetCurrentBitNo();
2967 // Read all of the records and blocks for the AST file.
2970 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2972 Error(MaybeEntry.takeError());
2975 llvm::BitstreamEntry Entry = MaybeEntry.get();
2977 switch (Entry.Kind) {
2978 case llvm::BitstreamEntry::Error:
2979 Error("error at end of module block in AST file");
2981 case llvm::BitstreamEntry::EndBlock:
2982 // Outside of C++, we do not store a lookup map for the translation unit.
2983 // Instead, mark it as needing a lookup map to be built if this module
2984 // contains any declarations lexically within it (which it always does!).
2985 // This usually has no cost, since we very rarely need the lookup map for
2986 // the translation unit outside C++.
2987 if (ASTContext *Ctx = ContextObj) {
2988 DeclContext *DC = Ctx->getTranslationUnitDecl();
2989 if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2990 DC->setMustBuildLookupTable();
2994 case llvm::BitstreamEntry::SubBlock:
2996 case DECLTYPES_BLOCK_ID:
2997 // We lazily load the decls block, but we want to set up the
2998 // DeclsCursor cursor to point into it. Clone our current bitcode
2999 // cursor to it, enter the block and read the abbrevs in that block.
3000 // With the main cursor, we just skip over it.
3001 F.DeclsCursor = Stream;
3002 if (llvm::Error Err = Stream.SkipBlock()) {
3003 Error(std::move(Err));
3006 if (ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID,
3007 &F.DeclsBlockStartOffset)) {
3008 Error("malformed block record in AST file");
3013 case PREPROCESSOR_BLOCK_ID:
3014 F.MacroCursor = Stream;
3015 if (!PP.getExternalSource())
3016 PP.setExternalSource(this);
3018 if (llvm::Error Err = Stream.SkipBlock()) {
3019 Error(std::move(Err));
3022 if (ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
3023 Error("malformed block record in AST file");
3026 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
3029 case PREPROCESSOR_DETAIL_BLOCK_ID:
3030 F.PreprocessorDetailCursor = Stream;
3032 if (llvm::Error Err = Stream.SkipBlock()) {
3033 Error(std::move(Err));
3036 if (ReadBlockAbbrevs(F.PreprocessorDetailCursor,
3037 PREPROCESSOR_DETAIL_BLOCK_ID)) {
3038 Error("malformed preprocessor detail record in AST file");
3041 F.PreprocessorDetailStartOffset
3042 = F.PreprocessorDetailCursor.GetCurrentBitNo();
3044 if (!PP.getPreprocessingRecord())
3045 PP.createPreprocessingRecord();
3046 if (!PP.getPreprocessingRecord()->getExternalSource())
3047 PP.getPreprocessingRecord()->SetExternalSource(*this);
3050 case SOURCE_MANAGER_BLOCK_ID:
3051 if (ReadSourceManagerBlock(F))
3055 case SUBMODULE_BLOCK_ID:
3056 if (ASTReadResult Result =
3057 ReadSubmoduleBlock(F, ClientLoadCapabilities))
3061 case COMMENTS_BLOCK_ID: {
3062 BitstreamCursor C = Stream;
3064 if (llvm::Error Err = Stream.SkipBlock()) {
3065 Error(std::move(Err));
3068 if (ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
3069 Error("malformed comments block in AST file");
3072 CommentsCursors.push_back(std::make_pair(C, &F));
3077 if (llvm::Error Err = Stream.SkipBlock()) {
3078 Error(std::move(Err));
3085 case llvm::BitstreamEntry::Record:
3086 // The interesting case.
3090 // Read and process a record.
3093 Expected<unsigned> MaybeRecordType =
3094 Stream.readRecord(Entry.ID, Record, &Blob);
3095 if (!MaybeRecordType) {
3096 Error(MaybeRecordType.takeError());
3099 ASTRecordTypes RecordType = (ASTRecordTypes)MaybeRecordType.get();
3101 // If we're not loading an AST context, we don't care about most records.
3103 switch (RecordType) {
3104 case IDENTIFIER_TABLE:
3105 case IDENTIFIER_OFFSET:
3106 case INTERESTING_IDENTIFIERS:
3108 case PP_CONDITIONAL_STACK:
3109 case PP_COUNTER_VALUE:
3110 case SOURCE_LOCATION_OFFSETS:
3111 case MODULE_OFFSET_MAP:
3112 case SOURCE_MANAGER_LINE_TABLE:
3113 case SOURCE_LOCATION_PRELOADS:
3114 case PPD_ENTITIES_OFFSETS:
3115 case HEADER_SEARCH_TABLE:
3116 case IMPORTED_MODULES:
3124 switch (RecordType) {
3125 default: // Default behavior: ignore.
3129 if (F.LocalNumTypes != 0) {
3130 Error("duplicate TYPE_OFFSET record in AST file");
3133 F.TypeOffsets = reinterpret_cast<const UnderalignedInt64 *>(Blob.data());
3134 F.LocalNumTypes = Record[0];
3135 unsigned LocalBaseTypeIndex = Record[1];
3136 F.BaseTypeIndex = getTotalNumTypes();
3138 if (F.LocalNumTypes > 0) {
3139 // Introduce the global -> local mapping for types within this module.
3140 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3142 // Introduce the local -> global mapping for types within this module.
3143 F.TypeRemap.insertOrReplace(
3144 std::make_pair(LocalBaseTypeIndex,
3145 F.BaseTypeIndex - LocalBaseTypeIndex));
3147 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
3153 if (F.LocalNumDecls != 0) {
3154 Error("duplicate DECL_OFFSET record in AST file");
3157 F.DeclOffsets = (const DeclOffset *)Blob.data();
3158 F.LocalNumDecls = Record[0];
3159 unsigned LocalBaseDeclID = Record[1];
3160 F.BaseDeclID = getTotalNumDecls();
3162 if (F.LocalNumDecls > 0) {
3163 // Introduce the global -> local mapping for declarations within this
3165 GlobalDeclMap.insert(
3166 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
3168 // Introduce the local -> global mapping for declarations within this
3170 F.DeclRemap.insertOrReplace(
3171 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
3173 // Introduce the global -> local mapping for declarations within this
3175 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
3177 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
3182 case TU_UPDATE_LEXICAL: {
3183 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3184 LexicalContents Contents(
3185 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
3187 static_cast<unsigned int>(Blob.size() / 4));
3188 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3189 TU->setHasExternalLexicalStorage(true);
3193 case UPDATE_VISIBLE: {
3195 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
3196 auto *Data = (const unsigned char*)Blob.data();
3197 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3198 // If we've already loaded the decl, perform the updates when we finish
3199 // loading this block.
3200 if (Decl *D = GetExistingDecl(ID))
3201 PendingUpdateRecords.push_back(
3202 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3206 case IDENTIFIER_TABLE:
3207 F.IdentifierTableData =
3208 reinterpret_cast<const unsigned char *>(Blob.data());
3210 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
3211 F.IdentifierTableData + Record[0],
3212 F.IdentifierTableData + sizeof(uint32_t),
3213 F.IdentifierTableData,
3214 ASTIdentifierLookupTrait(*this, F));
3216 PP.getIdentifierTable().setExternalIdentifierLookup(this);
3220 case IDENTIFIER_OFFSET: {
3221 if (F.LocalNumIdentifiers != 0) {
3222 Error("duplicate IDENTIFIER_OFFSET record in AST file");
3225 F.IdentifierOffsets = (const uint32_t *)Blob.data();
3226 F.LocalNumIdentifiers = Record[0];
3227 unsigned LocalBaseIdentifierID = Record[1];
3228 F.BaseIdentifierID = getTotalNumIdentifiers();
3230 if (F.LocalNumIdentifiers > 0) {
3231 // Introduce the global -> local mapping for identifiers within this
3233 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3236 // Introduce the local -> global mapping for identifiers within this
3238 F.IdentifierRemap.insertOrReplace(
3239 std::make_pair(LocalBaseIdentifierID,
3240 F.BaseIdentifierID - LocalBaseIdentifierID));
3242 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3243 + F.LocalNumIdentifiers);
3248 case INTERESTING_IDENTIFIERS:
3249 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
3252 case EAGERLY_DESERIALIZED_DECLS:
3253 // FIXME: Skip reading this record if our ASTConsumer doesn't care
3254 // about "interesting" decls (for instance, if we're building a module).
3255 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3256 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3259 case MODULAR_CODEGEN_DECLS:
3260 // FIXME: Skip reading this record if our ASTConsumer doesn't care about
3261 // them (ie: if we're not codegenerating this module).
3262 if (F.Kind == MK_MainFile ||
3263 getContext().getLangOpts().BuildingPCHWithObjectFile)
3264 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3265 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3269 if (SpecialTypes.empty()) {
3270 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3271 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3275 if (SpecialTypes.size() != Record.size()) {
3276 Error("invalid special-types record");
3280 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3281 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
3282 if (!SpecialTypes[I])
3283 SpecialTypes[I] = ID;
3284 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
3290 TotalNumStatements += Record[0];
3291 TotalNumMacros += Record[1];
3292 TotalLexicalDeclContexts += Record[2];
3293 TotalVisibleDeclContexts += Record[3];
3296 case UNUSED_FILESCOPED_DECLS:
3297 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3298 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3301 case DELEGATING_CTORS:
3302 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3303 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3306 case WEAK_UNDECLARED_IDENTIFIERS:
3307 if (Record.size() % 4 != 0) {
3308 Error("invalid weak identifiers record");
3312 // FIXME: Ignore weak undeclared identifiers from non-original PCH
3313 // files. This isn't the way to do it :)
3314 WeakUndeclaredIdentifiers.clear();
3316 // Translate the weak, undeclared identifiers into global IDs.
3317 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3318 WeakUndeclaredIdentifiers.push_back(
3319 getGlobalIdentifierID(F, Record[I++]));
3320 WeakUndeclaredIdentifiers.push_back(
3321 getGlobalIdentifierID(F, Record[I++]));
3322 WeakUndeclaredIdentifiers.push_back(
3323 ReadSourceLocation(F, Record, I).getRawEncoding());
3324 WeakUndeclaredIdentifiers.push_back(Record[I++]);
3328 case SELECTOR_OFFSETS: {
3329 F.SelectorOffsets = (const uint32_t *)Blob.data();
3330 F.LocalNumSelectors = Record[0];
3331 unsigned LocalBaseSelectorID = Record[1];
3332 F.BaseSelectorID = getTotalNumSelectors();
3334 if (F.LocalNumSelectors > 0) {
3335 // Introduce the global -> local mapping for selectors within this
3337 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3339 // Introduce the local -> global mapping for selectors within this
3341 F.SelectorRemap.insertOrReplace(
3342 std::make_pair(LocalBaseSelectorID,
3343 F.BaseSelectorID - LocalBaseSelectorID));
3345 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3351 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3353 F.SelectorLookupTable
3354 = ASTSelectorLookupTable::Create(
3355 F.SelectorLookupTableData + Record[0],
3356 F.SelectorLookupTableData,
3357 ASTSelectorLookupTrait(*this, F));
3358 TotalNumMethodPoolEntries += Record[1];
3361 case REFERENCED_SELECTOR_POOL:
3362 if (!Record.empty()) {
3363 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3364 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3366 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3372 case PP_CONDITIONAL_STACK:
3373 if (!Record.empty()) {
3374 unsigned Idx = 0, End = Record.size() - 1;
3375 bool ReachedEOFWhileSkipping = Record[Idx++];
3376 llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3377 if (ReachedEOFWhileSkipping) {
3378 SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3379 SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3380 bool FoundNonSkipPortion = Record[Idx++];
3381 bool FoundElse = Record[Idx++];
3382 SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3383 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3384 FoundElse, ElseLoc);
3386 SmallVector<PPConditionalInfo, 4> ConditionalStack;
3388 auto Loc = ReadSourceLocation(F, Record, Idx);
3389 bool WasSkipping = Record[Idx++];
3390 bool FoundNonSkip = Record[Idx++];
3391 bool FoundElse = Record[Idx++];
3392 ConditionalStack.push_back(
3393 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3395 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3399 case PP_COUNTER_VALUE:
3400 if (!Record.empty() && Listener)
3401 Listener->ReadCounter(F, Record[0]);
3404 case FILE_SORTED_DECLS:
3405 F.FileSortedDecls = (const DeclID *)Blob.data();
3406 F.NumFileSortedDecls = Record[0];
3409 case SOURCE_LOCATION_OFFSETS: {
3410 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3411 F.LocalNumSLocEntries = Record[0];
3412 SourceLocation::UIntTy SLocSpaceSize = Record[1];
3413 F.SLocEntryOffsetsBase = Record[2] + F.SourceManagerBlockStartOffset;
3414 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3415 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3417 if (!F.SLocEntryBaseID) {
3418 Error("ran out of source locations");
3421 // Make our entry in the range map. BaseID is negative and growing, so
3422 // we invert it. Because we invert it, though, we need the other end of
3424 unsigned RangeStart =
3425 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3426 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3427 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3429 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3430 assert((F.SLocEntryBaseOffset & SourceLocation::MacroIDBit) == 0);
3431 GlobalSLocOffsetMap.insert(
3432 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3433 - SLocSpaceSize,&F));
3435 // Initialize the remapping table.
3436 // Invalid stays invalid.
3437 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3438 // This module. Base was 2 when being compiled.
3439 F.SLocRemap.insertOrReplace(std::make_pair(
3440 2U, static_cast<SourceLocation::IntTy>(F.SLocEntryBaseOffset - 2)));
3442 TotalNumSLocEntries += F.LocalNumSLocEntries;
3446 case MODULE_OFFSET_MAP:
3447 F.ModuleOffsetMap = Blob;
3450 case SOURCE_MANAGER_LINE_TABLE:
3451 if (ParseLineTable(F, Record)) {
3452 Error("malformed SOURCE_MANAGER_LINE_TABLE in AST file");
3457 case SOURCE_LOCATION_PRELOADS: {
3458 // Need to transform from the local view (1-based IDs) to the global view,
3459 // which is based off F.SLocEntryBaseID.
3460 if (!F.PreloadSLocEntries.empty()) {
3461 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3465 F.PreloadSLocEntries.swap(Record);
3469 case EXT_VECTOR_DECLS:
3470 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3471 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3475 if (Record.size() % 3 != 0) {
3476 Error("Invalid VTABLE_USES record");
3480 // Later tables overwrite earlier ones.
3481 // FIXME: Modules will have some trouble with this. This is clearly not
3482 // the right way to do this.
3485 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3486 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3487 VTableUses.push_back(
3488 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3489 VTableUses.push_back(Record[Idx++]);
3493 case PENDING_IMPLICIT_INSTANTIATIONS:
3494 if (PendingInstantiations.size() % 2 != 0) {
3495 Error("Invalid existing PendingInstantiations");
3499 if (Record.size() % 2 != 0) {
3500 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3504 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3505 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3506 PendingInstantiations.push_back(
3507 ReadSourceLocation(F, Record, I).getRawEncoding());
3511 case SEMA_DECL_REFS:
3512 if (Record.size() != 3) {
3513 Error("Invalid SEMA_DECL_REFS block");
3516 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3517 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3520 case PPD_ENTITIES_OFFSETS: {
3521 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3522 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3523 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3525 unsigned LocalBasePreprocessedEntityID = Record[0];
3527 unsigned StartingID;
3528 if (!PP.getPreprocessingRecord())
3529 PP.createPreprocessingRecord();
3530 if (!PP.getPreprocessingRecord()->getExternalSource())
3531 PP.getPreprocessingRecord()->SetExternalSource(*this);
3533 = PP.getPreprocessingRecord()
3534 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3535 F.BasePreprocessedEntityID = StartingID;
3537 if (F.NumPreprocessedEntities > 0) {
3538 // Introduce the global -> local mapping for preprocessed entities in
3540 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3542 // Introduce the local -> global mapping for preprocessed entities in
3544 F.PreprocessedEntityRemap.insertOrReplace(
3545 std::make_pair(LocalBasePreprocessedEntityID,
3546 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3552 case PPD_SKIPPED_RANGES: {
3553 F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3554 assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3555 F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3557 if (!PP.getPreprocessingRecord())
3558 PP.createPreprocessingRecord();
3559 if (!PP.getPreprocessingRecord()->getExternalSource())
3560 PP.getPreprocessingRecord()->SetExternalSource(*this);
3561 F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3562 ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3564 if (F.NumPreprocessedSkippedRanges > 0)
3565 GlobalSkippedRangeMap.insert(
3566 std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3570 case DECL_UPDATE_OFFSETS:
3571 if (Record.size() % 2 != 0) {
3572 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3575 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3576 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3577 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3579 // If we've already loaded the decl, perform the updates when we finish
3580 // loading this block.
3581 if (Decl *D = GetExistingDecl(ID))
3582 PendingUpdateRecords.push_back(
3583 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3587 case OBJC_CATEGORIES_MAP:
3588 if (F.LocalNumObjCCategoriesInMap != 0) {
3589 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3593 F.LocalNumObjCCategoriesInMap = Record[0];
3594 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3597 case OBJC_CATEGORIES:
3598 F.ObjCCategories.swap(Record);
3601 case CUDA_SPECIAL_DECL_REFS:
3602 // Later tables overwrite earlier ones.
3603 // FIXME: Modules will have trouble with this.
3604 CUDASpecialDeclRefs.clear();
3605 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3606 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3609 case HEADER_SEARCH_TABLE:
3610 F.HeaderFileInfoTableData = Blob.data();
3611 F.LocalNumHeaderFileInfos = Record[1];
3613 F.HeaderFileInfoTable
3614 = HeaderFileInfoLookupTable::Create(
3615 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3616 (const unsigned char *)F.HeaderFileInfoTableData,
3617 HeaderFileInfoTrait(*this, F,
3618 &PP.getHeaderSearchInfo(),
3619 Blob.data() + Record[2]));
3621 PP.getHeaderSearchInfo().SetExternalSource(this);
3622 if (!PP.getHeaderSearchInfo().getExternalLookup())
3623 PP.getHeaderSearchInfo().SetExternalLookup(this);
3627 case FP_PRAGMA_OPTIONS:
3628 // Later tables overwrite earlier ones.
3629 FPPragmaOptions.swap(Record);
3632 case OPENCL_EXTENSIONS:
3633 for (unsigned I = 0, E = Record.size(); I != E; ) {
3634 auto Name = ReadString(Record, I);
3635 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3636 OptInfo.Supported = Record[I++] != 0;
3637 OptInfo.Enabled = Record[I++] != 0;
3638 OptInfo.WithPragma = Record[I++] != 0;
3639 OptInfo.Avail = Record[I++];
3640 OptInfo.Core = Record[I++];
3641 OptInfo.Opt = Record[I++];
3645 case TENTATIVE_DEFINITIONS:
3646 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3647 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3650 case KNOWN_NAMESPACES:
3651 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3652 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3655 case UNDEFINED_BUT_USED:
3656 if (UndefinedButUsed.size() % 2 != 0) {
3657 Error("Invalid existing UndefinedButUsed");
3661 if (Record.size() % 2 != 0) {
3662 Error("invalid undefined-but-used record");
3665 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3666 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3667 UndefinedButUsed.push_back(
3668 ReadSourceLocation(F, Record, I).getRawEncoding());
3672 case DELETE_EXPRS_TO_ANALYZE:
3673 for (unsigned I = 0, N = Record.size(); I != N;) {
3674 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3675 const uint64_t Count = Record[I++];
3676 DelayedDeleteExprs.push_back(Count);
3677 for (uint64_t C = 0; C < Count; ++C) {
3678 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3679 bool IsArrayForm = Record[I++] == 1;
3680 DelayedDeleteExprs.push_back(IsArrayForm);
3685 case IMPORTED_MODULES:
3686 if (!F.isModule()) {
3687 // If we aren't loading a module (which has its own exports), make
3688 // all of the imported modules visible.
3689 // FIXME: Deal with macros-only imports.
3690 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3691 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3692 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3694 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3695 if (DeserializationListener)
3696 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3702 case MACRO_OFFSET: {
3703 if (F.LocalNumMacros != 0) {
3704 Error("duplicate MACRO_OFFSET record in AST file");
3707 F.MacroOffsets = (const uint32_t *)Blob.data();
3708 F.LocalNumMacros = Record[0];
3709 unsigned LocalBaseMacroID = Record[1];
3710 F.MacroOffsetsBase = Record[2] + F.ASTBlockStartOffset;
3711 F.BaseMacroID = getTotalNumMacros();
3713 if (F.LocalNumMacros > 0) {
3714 // Introduce the global -> local mapping for macros within this module.
3715 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3717 // Introduce the local -> global mapping for macros within this module.
3718 F.MacroRemap.insertOrReplace(
3719 std::make_pair(LocalBaseMacroID,
3720 F.BaseMacroID - LocalBaseMacroID));
3722 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3727 case LATE_PARSED_TEMPLATE:
3728 LateParsedTemplates.emplace_back(
3729 std::piecewise_construct, std::forward_as_tuple(&F),
3730 std::forward_as_tuple(Record.begin(), Record.end()));
3733 case OPTIMIZE_PRAGMA_OPTIONS:
3734 if (Record.size() != 1) {
3735 Error("invalid pragma optimize record");
3738 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3741 case MSSTRUCT_PRAGMA_OPTIONS:
3742 if (Record.size() != 1) {
3743 Error("invalid pragma ms_struct record");
3746 PragmaMSStructState = Record[0];
3749 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3750 if (Record.size() != 2) {
3751 Error("invalid pragma ms_struct record");
3754 PragmaMSPointersToMembersState = Record[0];
3755 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3758 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3759 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3760 UnusedLocalTypedefNameCandidates.push_back(
3761 getGlobalDeclID(F, Record[I]));
3764 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3765 if (Record.size() != 1) {
3766 Error("invalid cuda pragma options record");
3769 ForceCUDAHostDeviceDepth = Record[0];
3772 case ALIGN_PACK_PRAGMA_OPTIONS: {
3773 if (Record.size() < 3) {
3774 Error("invalid pragma pack record");
3777 PragmaAlignPackCurrentValue = ReadAlignPackInfo(Record[0]);
3778 PragmaAlignPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3779 unsigned NumStackEntries = Record[2];
3781 // Reset the stack when importing a new module.
3782 PragmaAlignPackStack.clear();
3783 for (unsigned I = 0; I < NumStackEntries; ++I) {
3784 PragmaAlignPackStackEntry Entry;
3785 Entry.Value = ReadAlignPackInfo(Record[Idx++]);
3786 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3787 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3788 PragmaAlignPackStrings.push_back(ReadString(Record, Idx));
3789 Entry.SlotLabel = PragmaAlignPackStrings.back();
3790 PragmaAlignPackStack.push_back(Entry);
3795 case FLOAT_CONTROL_PRAGMA_OPTIONS: {
3796 if (Record.size() < 3) {
3797 Error("invalid pragma pack record");
3800 FpPragmaCurrentValue = FPOptionsOverride::getFromOpaqueInt(Record[0]);
3801 FpPragmaCurrentLocation = ReadSourceLocation(F, Record[1]);
3802 unsigned NumStackEntries = Record[2];
3804 // Reset the stack when importing a new module.
3805 FpPragmaStack.clear();
3806 for (unsigned I = 0; I < NumStackEntries; ++I) {
3807 FpPragmaStackEntry Entry;
3808 Entry.Value = FPOptionsOverride::getFromOpaqueInt(Record[Idx++]);
3809 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3810 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3811 FpPragmaStrings.push_back(ReadString(Record, Idx));
3812 Entry.SlotLabel = FpPragmaStrings.back();
3813 FpPragmaStack.push_back(Entry);
3818 case DECLS_TO_CHECK_FOR_DEFERRED_DIAGS:
3819 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3820 DeclsToCheckForDeferredDiags.insert(getGlobalDeclID(F, Record[I]));
3826 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3827 assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3829 // Additional remapping information.
3830 const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3831 const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3832 F.ModuleOffsetMap = StringRef();
3834 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3835 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3836 F.SLocRemap.insert(std::make_pair(0U, 0));
3837 F.SLocRemap.insert(std::make_pair(2U, 1));
3840 // Continuous range maps we may be updating in our module.
3841 using SLocRemapBuilder =
3842 ContinuousRangeMap<SourceLocation::UIntTy, SourceLocation::IntTy,
3844 using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3845 SLocRemapBuilder SLocRemap(F.SLocRemap);
3846 RemapBuilder IdentifierRemap(F.IdentifierRemap);
3847 RemapBuilder MacroRemap(F.MacroRemap);
3848 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3849 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3850 RemapBuilder SelectorRemap(F.SelectorRemap);
3851 RemapBuilder DeclRemap(F.DeclRemap);
3852 RemapBuilder TypeRemap(F.TypeRemap);
3854 while (Data < DataEnd) {
3855 // FIXME: Looking up dependency modules by filename is horrible. Let's
3856 // start fixing this with prebuilt, explicit and implicit modules and see
3858 using namespace llvm::support;
3859 ModuleKind Kind = static_cast<ModuleKind>(
3860 endian::readNext<uint8_t, little, unaligned>(Data));
3861 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3862 StringRef Name = StringRef((const char*)Data, Len);
3864 ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule ||
3865 Kind == MK_ImplicitModule
3866 ? ModuleMgr.lookupByModuleName(Name)
3867 : ModuleMgr.lookupByFileName(Name));
3870 "SourceLocation remap refers to unknown module, cannot find ";
3871 Msg.append(std::string(Name));
3876 SourceLocation::UIntTy SLocOffset =
3877 endian::readNext<uint32_t, little, unaligned>(Data);
3878 uint32_t IdentifierIDOffset =
3879 endian::readNext<uint32_t, little, unaligned>(Data);
3880 uint32_t MacroIDOffset =
3881 endian::readNext<uint32_t, little, unaligned>(Data);
3882 uint32_t PreprocessedEntityIDOffset =
3883 endian::readNext<uint32_t, little, unaligned>(Data);
3884 uint32_t SubmoduleIDOffset =
3885 endian::readNext<uint32_t, little, unaligned>(Data);
3886 uint32_t SelectorIDOffset =
3887 endian::readNext<uint32_t, little, unaligned>(Data);
3888 uint32_t DeclIDOffset =
3889 endian::readNext<uint32_t, little, unaligned>(Data);
3890 uint32_t TypeIndexOffset =
3891 endian::readNext<uint32_t, little, unaligned>(Data);
3893 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3894 RemapBuilder &Remap) {
3895 constexpr uint32_t None = std::numeric_limits<uint32_t>::max();
3897 Remap.insert(std::make_pair(Offset,
3898 static_cast<int>(BaseOffset - Offset)));
3901 constexpr SourceLocation::UIntTy SLocNone =
3902 std::numeric_limits<SourceLocation::UIntTy>::max();
3903 if (SLocOffset != SLocNone)
3904 SLocRemap.insert(std::make_pair(
3905 SLocOffset, static_cast<SourceLocation::IntTy>(
3906 OM->SLocEntryBaseOffset - SLocOffset)));
3908 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3909 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3910 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3911 PreprocessedEntityRemap);
3912 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3913 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3914 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3915 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3917 // Global -> local mappings.
3918 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3922 ASTReader::ASTReadResult
3923 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3924 const ModuleFile *ImportedBy,
3925 unsigned ClientLoadCapabilities) {
3927 F.ModuleMapPath = ReadPath(F, Record, Idx);
3929 // Try to resolve ModuleName in the current header search context and
3930 // verify that it is found in the same module map file as we saved. If the
3931 // top-level AST file is a main file, skip this check because there is no
3932 // usable header search context.
3933 assert(!F.ModuleName.empty() &&
3934 "MODULE_NAME should come before MODULE_MAP_FILE");
3935 if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3936 // An implicitly-loaded module file should have its module listed in some
3937 // module map file that we've already loaded.
3938 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3939 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3940 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3941 // Don't emit module relocation error if we have -fno-validate-pch
3942 if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3943 DisableValidationForModuleKind::Module) &&
3945 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities)) {
3946 if (auto ASTFE = M ? M->getASTFile() : None) {
3947 // This module was defined by an imported (explicit) module.
3948 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3949 << ASTFE->getName();
3951 // This module was built with a different module map.
3952 Diag(diag::err_imported_module_not_found)
3953 << F.ModuleName << F.FileName
3954 << (ImportedBy ? ImportedBy->FileName : "") << F.ModuleMapPath
3956 // In case it was imported by a PCH, there's a chance the user is
3957 // just missing to include the search path to the directory containing
3959 if (ImportedBy && ImportedBy->Kind == MK_PCH)
3960 Diag(diag::note_imported_by_pch_module_not_found)
3961 << llvm::sys::path::parent_path(F.ModuleMapPath);
3967 assert(M && M->Name == F.ModuleName && "found module with different name");
3969 // Check the primary module map file.
3970 auto StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3971 if (!StoredModMap || *StoredModMap != ModMap) {
3972 assert(ModMap && "found module is missing module map file");
3973 assert((ImportedBy || F.Kind == MK_ImplicitModule) &&
3974 "top-level import should be verified");
3975 bool NotImported = F.Kind == MK_ImplicitModule && !ImportedBy;
3976 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
3977 Diag(diag::err_imported_module_modmap_changed)
3978 << F.ModuleName << (NotImported ? F.FileName : ImportedBy->FileName)
3979 << ModMap->getName() << F.ModuleMapPath << NotImported;
3983 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3984 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3985 // FIXME: we should use input files rather than storing names.
3986 std::string Filename = ReadPath(F, Record, Idx);
3987 auto SF = FileMgr.getFile(Filename, false, false);
3989 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
3990 Error("could not find file '" + Filename +"' referenced by AST file");
3993 AdditionalStoredMaps.insert(*SF);
3996 // Check any additional module map files (e.g. module.private.modulemap)
3997 // that are not in the pcm.
3998 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3999 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
4000 // Remove files that match
4001 // Note: SmallPtrSet::erase is really remove
4002 if (!AdditionalStoredMaps.erase(ModMap)) {
4003 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4004 Diag(diag::err_module_different_modmap)
4005 << F.ModuleName << /*new*/0 << ModMap->getName();
4011 // Check any additional module map files that are in the pcm, but not
4012 // found in header search. Cases that match are already removed.
4013 for (const FileEntry *ModMap : AdditionalStoredMaps) {
4014 if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4015 Diag(diag::err_module_different_modmap)
4016 << F.ModuleName << /*not new*/1 << ModMap->getName();
4022 Listener->ReadModuleMapFile(F.ModuleMapPath);
4026 /// Move the given method to the back of the global list of methods.
4027 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
4028 // Find the entry for this selector in the method pool.
4029 Sema::GlobalMethodPool::iterator Known
4030 = S.MethodPool.find(Method->getSelector());
4031 if (Known == S.MethodPool.end())
4034 // Retrieve the appropriate method list.
4035 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
4036 : Known->second.second;
4038 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
4040 if (List->getMethod() == Method) {
4048 if (List->getNext())
4049 List->setMethod(List->getNext()->getMethod());
4051 List->setMethod(Method);
4055 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
4056 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
4057 for (Decl *D : Names) {
4058 bool wasHidden = !D->isUnconditionallyVisible();
4059 D->setVisibleDespiteOwningModule();
4061 if (wasHidden && SemaObj) {
4062 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
4063 moveMethodToBackOfGlobalList(*SemaObj, Method);
4069 void ASTReader::makeModuleVisible(Module *Mod,
4070 Module::NameVisibilityKind NameVisibility,
4071 SourceLocation ImportLoc) {
4072 llvm::SmallPtrSet<Module *, 4> Visited;
4073 SmallVector<Module *, 4> Stack;
4074 Stack.push_back(Mod);
4075 while (!Stack.empty()) {
4076 Mod = Stack.pop_back_val();
4078 if (NameVisibility <= Mod->NameVisibility) {
4079 // This module already has this level of visibility (or greater), so
4080 // there is nothing more to do.
4084 if (Mod->isUnimportable()) {
4085 // Modules that aren't importable cannot be made visible.
4089 // Update the module's name visibility.
4090 Mod->NameVisibility = NameVisibility;
4092 // If we've already deserialized any names from this module,
4093 // mark them as visible.
4094 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4095 if (Hidden != HiddenNamesMap.end()) {
4096 auto HiddenNames = std::move(*Hidden);
4097 HiddenNamesMap.erase(Hidden);
4098 makeNamesVisible(HiddenNames.second, HiddenNames.first);
4099 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
4100 "making names visible added hidden names");
4103 // Push any exported modules onto the stack to be marked as visible.
4104 SmallVector<Module *, 16> Exports;
4105 Mod->getExportedModules(Exports);
4106 for (SmallVectorImpl<Module *>::iterator
4107 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4108 Module *Exported = *I;
4109 if (Visited.insert(Exported).second)
4110 Stack.push_back(Exported);
4115 /// We've merged the definition \p MergedDef into the existing definition
4116 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
4118 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
4119 NamedDecl *MergedDef) {
4120 if (!Def->isUnconditionallyVisible()) {
4121 // If MergedDef is visible or becomes visible, make the definition visible.
4122 if (MergedDef->isUnconditionallyVisible())
4123 Def->setVisibleDespiteOwningModule();
4125 getContext().mergeDefinitionIntoModule(
4126 Def, MergedDef->getImportedOwningModule(),
4127 /*NotifyListeners*/ false);
4128 PendingMergedDefinitionsToDeduplicate.insert(Def);
4133 bool ASTReader::loadGlobalIndex() {
4137 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4138 !PP.getLangOpts().Modules)
4141 // Try to load the global index.
4142 TriedLoadingGlobalIndex = true;
4143 StringRef ModuleCachePath
4144 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4145 std::pair<GlobalModuleIndex *, llvm::Error> Result =
4146 GlobalModuleIndex::readIndex(ModuleCachePath);
4147 if (llvm::Error Err = std::move(Result.second)) {
4148 assert(!Result.first);
4149 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
4153 GlobalIndex.reset(Result.first);
4154 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4158 bool ASTReader::isGlobalIndexUnavailable() const {
4159 return PP.getLangOpts().Modules && UseGlobalIndex &&
4160 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4163 static void updateModuleTimestamp(ModuleFile &MF) {
4164 // Overwrite the timestamp file contents so that file's mtime changes.
4165 std::string TimestampFilename = MF.getTimestampFilename();
4167 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4168 llvm::sys::fs::OF_TextWithCRLF);
4171 OS << "Timestamp file\n";
4173 OS.clear_error(); // Avoid triggering a fatal error.
4176 /// Given a cursor at the start of an AST file, scan ahead and drop the
4177 /// cursor into the start of the given block ID, returning false on success and
4178 /// true on failure.
4179 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4181 Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
4183 // FIXME this drops errors on the floor.
4184 consumeError(MaybeEntry.takeError());
4187 llvm::BitstreamEntry Entry = MaybeEntry.get();
4189 switch (Entry.Kind) {
4190 case llvm::BitstreamEntry::Error:
4191 case llvm::BitstreamEntry::EndBlock:
4194 case llvm::BitstreamEntry::Record:
4195 // Ignore top-level records.
4196 if (Expected<unsigned> Skipped = Cursor.skipRecord(Entry.ID))
4199 // FIXME this drops errors on the floor.
4200 consumeError(Skipped.takeError());
4204 case llvm::BitstreamEntry::SubBlock:
4205 if (Entry.ID == BlockID) {
4206 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4207 // FIXME this drops the error on the floor.
4208 consumeError(std::move(Err));
4215 if (llvm::Error Err = Cursor.SkipBlock()) {
4216 // FIXME this drops the error on the floor.
4217 consumeError(std::move(Err));
4224 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
4226 SourceLocation ImportLoc,
4227 unsigned ClientLoadCapabilities,
4228 SmallVectorImpl<ImportedSubmodule> *Imported) {
4229 llvm::SaveAndRestore<SourceLocation>
4230 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
4231 llvm::SaveAndRestore<Optional<ModuleKind>> SetCurModuleKindRAII(
4232 CurrentDeserializingModuleKind, Type);
4234 // Defer any pending actions until we get to the end of reading the AST file.
4235 Deserializing AnASTFile(this);
4237 // Bump the generation number.
4238 unsigned PreviousGeneration = 0;
4240 PreviousGeneration = incrementGeneration(*ContextObj);
4242 unsigned NumModules = ModuleMgr.size();
4243 auto removeModulesAndReturn = [&](ASTReadResult ReadResult) {
4244 assert(ReadResult && "expected to return error");
4245 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules,
4246 PP.getLangOpts().Modules
4247 ? &PP.getHeaderSearchInfo().getModuleMap()
4250 // If we find that any modules are unusable, the global index is going
4251 // to be out-of-date. Just remove it.
4252 GlobalIndex.reset();
4253 ModuleMgr.setGlobalIndex(nullptr);
4257 SmallVector<ImportedModule, 4> Loaded;
4258 switch (ASTReadResult ReadResult =
4259 ReadASTCore(FileName, Type, ImportLoc,
4260 /*ImportedBy=*/nullptr, Loaded, 0, 0,
4261 ASTFileSignature(), ClientLoadCapabilities)) {
4265 case VersionMismatch:
4266 case ConfigurationMismatch:
4268 return removeModulesAndReturn(ReadResult);
4273 // Here comes stuff that we only do once the entire chain is loaded.
4275 // Load the AST blocks of all of the modules that we loaded. We can still
4276 // hit errors parsing the ASTs at this point.
4277 for (ImportedModule &M : Loaded) {
4278 ModuleFile &F = *M.Mod;
4280 // Read the AST block.
4281 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
4282 return removeModulesAndReturn(Result);
4284 // The AST block should always have a definition for the main module.
4285 if (F.isModule() && !F.DidReadTopLevelSubmodule) {
4286 Error(diag::err_module_file_missing_top_level_submodule, F.FileName);
4287 return removeModulesAndReturn(Failure);
4290 // Read the extension blocks.
4291 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
4292 if (ASTReadResult Result = ReadExtensionBlock(F))
4293 return removeModulesAndReturn(Result);
4296 // Once read, set the ModuleFile bit base offset and update the size in
4297 // bits of all files we've seen.
4298 F.GlobalBitOffset = TotalModulesSizeInBits;
4299 TotalModulesSizeInBits += F.SizeInBits;
4300 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
4303 // Preload source locations and interesting indentifiers.
4304 for (ImportedModule &M : Loaded) {
4305 ModuleFile &F = *M.Mod;
4307 // Preload SLocEntries.
4308 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
4309 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
4310 // Load it through the SourceManager and don't call ReadSLocEntry()
4311 // directly because the entry may have already been loaded in which case
4312 // calling ReadSLocEntry() directly would trigger an assertion in
4314 SourceMgr.getLoadedSLocEntryByID(Index);
4317 // Map the original source file ID into the ID space of the current
4319 if (F.OriginalSourceFileID.isValid()) {
4320 F.OriginalSourceFileID = FileID::get(
4321 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
4324 // Preload all the pending interesting identifiers by marking them out of
4326 for (auto Offset : F.PreloadIdentifierOffsets) {
4327 const unsigned char *Data = F.IdentifierTableData + Offset;
4329 ASTIdentifierLookupTrait Trait(*this, F);
4330 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
4331 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
4332 auto &II = PP.getIdentifierTable().getOwn(Key);
4333 II.setOutOfDate(true);
4335 // Mark this identifier as being from an AST file so that we can track
4336 // whether we need to serialize it.
4337 markIdentifierFromAST(*this, II);
4339 // Associate the ID with the identifier so that the writer can reuse it.
4340 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
4341 SetIdentifierInfo(ID, &II);
4345 // Setup the import locations and notify the module manager that we've
4346 // committed to these module files.
4347 for (ImportedModule &M : Loaded) {
4348 ModuleFile &F = *M.Mod;
4350 ModuleMgr.moduleFileAccepted(&F);
4352 // Set the import location.
4353 F.DirectImportLoc = ImportLoc;
4354 // FIXME: We assume that locations from PCH / preamble do not need
4357 F.ImportLoc = M.ImportLoc;
4359 F.ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4362 if (!PP.getLangOpts().CPlusPlus ||
4363 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4364 Type != MK_PrebuiltModule)) {
4365 // Mark all of the identifiers in the identifier table as being out of date,
4366 // so that various accessors know to check the loaded modules when the
4367 // identifier is used.
4369 // For C++ modules, we don't need information on many identifiers (just
4370 // those that provide macros or are poisoned), so we mark all of
4371 // the interesting ones via PreloadIdentifierOffsets.
4372 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4373 IdEnd = PP.getIdentifierTable().end();
4375 Id->second->setOutOfDate(true);
4377 // Mark selectors as out of date.
4378 for (auto Sel : SelectorGeneration)
4379 SelectorOutOfDate[Sel.first] = true;
4381 // Resolve any unresolved module exports.
4382 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4383 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4384 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4385 Module *ResolvedMod = getSubmodule(GlobalID);
4387 switch (Unresolved.Kind) {
4388 case UnresolvedModuleRef::Conflict:
4390 Module::Conflict Conflict;
4391 Conflict.Other = ResolvedMod;
4392 Conflict.Message = Unresolved.String.str();
4393 Unresolved.Mod->Conflicts.push_back(Conflict);
4397 case UnresolvedModuleRef::Import:
4399 Unresolved.Mod->Imports.insert(ResolvedMod);
4402 case UnresolvedModuleRef::Export:
4403 if (ResolvedMod || Unresolved.IsWildcard)
4404 Unresolved.Mod->Exports.push_back(
4405 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4409 UnresolvedModuleRefs.clear();
4412 Imported->append(ImportedModules.begin(),
4413 ImportedModules.end());
4415 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4416 // Might be unnecessary as use declarations are only used to build the
4420 InitializeContext();
4425 if (DeserializationListener)
4426 DeserializationListener->ReaderInitialized(this);
4428 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4429 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4430 // If this AST file is a precompiled preamble, then set the
4431 // preamble file ID of the source manager to the file source file
4432 // from which the preamble was built.
4433 if (Type == MK_Preamble) {
4434 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4435 } else if (Type == MK_MainFile) {
4436 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4440 // For any Objective-C class definitions we have already loaded, make sure
4441 // that we load any additional categories.
4443 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4444 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4445 ObjCClassesLoaded[I],
4446 PreviousGeneration);
4450 if (PP.getHeaderSearchInfo()
4451 .getHeaderSearchOpts()
4452 .ModulesValidateOncePerBuildSession) {
4453 // Now we are certain that the module and all modules it depends on are
4454 // up to date. Create or update timestamp files for modules that are
4455 // located in the module cache (not for PCH files that could be anywhere
4456 // in the filesystem).
4457 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4458 ImportedModule &M = Loaded[I];
4459 if (M.Mod->Kind == MK_ImplicitModule) {
4460 updateModuleTimestamp(*M.Mod);
4468 static ASTFileSignature readASTFileSignature(StringRef PCH);
4470 /// Whether \p Stream doesn't start with the AST/PCH file magic number 'CPCH'.
4471 static llvm::Error doesntStartWithASTFileMagic(BitstreamCursor &Stream) {
4472 // FIXME checking magic headers is done in other places such as
4473 // SerializedDiagnosticReader and GlobalModuleIndex, but error handling isn't
4474 // always done the same. Unify it all with a helper.
4475 if (!Stream.canSkipToPos(4))
4476 return llvm::createStringError(std::errc::illegal_byte_sequence,
4477 "file too small to contain AST file magic");
4478 for (unsigned C : {'C', 'P', 'C', 'H'})
4479 if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
4481 return llvm::createStringError(
4482 std::errc::illegal_byte_sequence,
4483 "file doesn't start with AST file magic");
4485 return Res.takeError();
4486 return llvm::Error::success();
4489 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4493 case MK_ImplicitModule:
4494 case MK_ExplicitModule:
4495 case MK_PrebuiltModule:
4499 return 2; // main source file
4501 llvm_unreachable("unknown module kind");
4504 ASTReader::ASTReadResult
4505 ASTReader::ReadASTCore(StringRef FileName,
4507 SourceLocation ImportLoc,
4508 ModuleFile *ImportedBy,
4509 SmallVectorImpl<ImportedModule> &Loaded,
4510 off_t ExpectedSize, time_t ExpectedModTime,
4511 ASTFileSignature ExpectedSignature,
4512 unsigned ClientLoadCapabilities) {
4514 std::string ErrorStr;
4515 ModuleManager::AddModuleResult AddResult
4516 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4517 getGeneration(), ExpectedSize, ExpectedModTime,
4518 ExpectedSignature, readASTFileSignature,
4521 switch (AddResult) {
4522 case ModuleManager::AlreadyLoaded:
4523 Diag(diag::remark_module_import)
4524 << M->ModuleName << M->FileName << (ImportedBy ? true : false)
4525 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
4528 case ModuleManager::NewlyLoaded:
4529 // Load module file below.
4532 case ModuleManager::Missing:
4533 // The module file was missing; if the client can handle that, return
4535 if (ClientLoadCapabilities & ARR_Missing)
4538 // Otherwise, return an error.
4539 Diag(diag::err_ast_file_not_found)
4540 << moduleKindForDiagnostic(Type) << FileName << !ErrorStr.empty()
4544 case ModuleManager::OutOfDate:
4545 // We couldn't load the module file because it is out-of-date. If the
4546 // client can handle out-of-date, return it.
4547 if (ClientLoadCapabilities & ARR_OutOfDate)
4550 // Otherwise, return an error.
4551 Diag(diag::err_ast_file_out_of_date)
4552 << moduleKindForDiagnostic(Type) << FileName << !ErrorStr.empty()
4557 assert(M && "Missing module file");
4559 bool ShouldFinalizePCM = false;
4560 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4561 auto &MC = getModuleManager().getModuleCache();
4562 if (ShouldFinalizePCM)
4563 MC.finalizePCM(FileName);
4565 MC.tryToDropPCM(FileName);
4568 BitstreamCursor &Stream = F.Stream;
4569 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4570 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4572 // Sniff for the signature.
4573 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4574 Diag(diag::err_ast_file_invalid)
4575 << moduleKindForDiagnostic(Type) << FileName << std::move(Err);
4579 // This is used for compatibility with older PCH formats.
4580 bool HaveReadControlBlock = false;
4582 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4584 Error(MaybeEntry.takeError());
4587 llvm::BitstreamEntry Entry = MaybeEntry.get();
4589 switch (Entry.Kind) {
4590 case llvm::BitstreamEntry::Error:
4591 case llvm::BitstreamEntry::Record:
4592 case llvm::BitstreamEntry::EndBlock:
4593 Error("invalid record at top-level of AST file");
4596 case llvm::BitstreamEntry::SubBlock:
4601 case CONTROL_BLOCK_ID:
4602 HaveReadControlBlock = true;
4603 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4605 // Check that we didn't try to load a non-module AST file as a module.
4607 // FIXME: Should we also perform the converse check? Loading a module as
4608 // a PCH file sort of works, but it's a bit wonky.
4609 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4610 Type == MK_PrebuiltModule) &&
4611 F.ModuleName.empty()) {
4612 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4613 if (Result != OutOfDate ||
4614 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4615 Diag(diag::err_module_file_not_module) << FileName;
4620 case Failure: return Failure;
4621 case Missing: return Missing;
4622 case OutOfDate: return OutOfDate;
4623 case VersionMismatch: return VersionMismatch;
4624 case ConfigurationMismatch: return ConfigurationMismatch;
4625 case HadErrors: return HadErrors;
4630 if (!HaveReadControlBlock) {
4631 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4632 Diag(diag::err_pch_version_too_old);
4633 return VersionMismatch;
4636 // Record that we've loaded this module.
4637 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4638 ShouldFinalizePCM = true;
4641 case UNHASHED_CONTROL_BLOCK_ID:
4642 // This block is handled using look-ahead during ReadControlBlock. We
4643 // shouldn't get here!
4644 Error("malformed block record in AST file");
4648 if (llvm::Error Err = Stream.SkipBlock()) {
4649 Error(std::move(Err));
4656 llvm_unreachable("unexpected break; expected return");
4659 ASTReader::ASTReadResult
4660 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4661 unsigned ClientLoadCapabilities) {
4662 const HeaderSearchOptions &HSOpts =
4663 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4664 bool AllowCompatibleConfigurationMismatch =
4665 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4666 bool DisableValidation = shouldDisableValidationForFile(F);
4668 ASTReadResult Result = readUnhashedControlBlockImpl(
4669 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4671 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4673 // If F was directly imported by another module, it's implicitly validated by
4674 // the importing module.
4675 if (DisableValidation || WasImportedBy ||
4676 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4679 if (Result == Failure) {
4680 Error("malformed block record in AST file");
4684 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4685 // If this module has already been finalized in the ModuleCache, we're stuck
4686 // with it; we can only load a single version of each module.
4688 // This can happen when a module is imported in two contexts: in one, as a
4689 // user module; in another, as a system module (due to an import from
4690 // another module marked with the [system] flag). It usually indicates a
4691 // bug in the module map: this module should also be marked with [system].
4693 // If -Wno-system-headers (the default), and the first import is as a
4694 // system module, then validation will fail during the as-user import,
4695 // since -Werror flags won't have been validated. However, it's reasonable
4696 // to treat this consistently as a system module.
4698 // If -Wsystem-headers, the PCM on disk was built with
4699 // -Wno-system-headers, and the first import is as a user module, then
4700 // validation will fail during the as-system import since the PCM on disk
4701 // doesn't guarantee that -Werror was respected. However, the -Werror
4702 // flags were checked during the initial as-user import.
4703 if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {
4704 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4712 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4713 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4714 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4715 bool ValidateDiagnosticOptions) {
4716 // Initialize a stream.
4717 BitstreamCursor Stream(StreamData);
4719 // Sniff for the signature.
4720 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4721 // FIXME this drops the error on the floor.
4722 consumeError(std::move(Err));
4726 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4727 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4730 // Read all of the records in the options block.
4732 ASTReadResult Result = Success;
4734 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4736 // FIXME this drops the error on the floor.
4737 consumeError(MaybeEntry.takeError());
4740 llvm::BitstreamEntry Entry = MaybeEntry.get();
4742 switch (Entry.Kind) {
4743 case llvm::BitstreamEntry::Error:
4744 case llvm::BitstreamEntry::SubBlock:
4747 case llvm::BitstreamEntry::EndBlock:
4750 case llvm::BitstreamEntry::Record:
4751 // The interesting case.
4755 // Read and process a record.
4757 Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
4758 if (!MaybeRecordType) {
4759 // FIXME this drops the error.
4762 switch ((UnhashedControlBlockRecordTypes)MaybeRecordType.get()) {
4765 F->Signature = ASTFileSignature::create(Record.begin(), Record.end());
4767 case AST_BLOCK_HASH:
4770 ASTFileSignature::create(Record.begin(), Record.end());
4772 case DIAGNOSTIC_OPTIONS: {
4773 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4774 if (Listener && ValidateDiagnosticOptions &&
4775 !AllowCompatibleConfigurationMismatch &&
4776 ParseDiagnosticOptions(Record, Complain, *Listener))
4777 Result = OutOfDate; // Don't return early. Read the signature.
4780 case DIAG_PRAGMA_MAPPINGS:
4783 if (F->PragmaDiagMappings.empty())
4784 F->PragmaDiagMappings.swap(Record);
4786 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4787 Record.begin(), Record.end());
4793 /// Parse a record and blob containing module file extension metadata.
4794 static bool parseModuleFileExtensionMetadata(
4795 const SmallVectorImpl<uint64_t> &Record,
4797 ModuleFileExtensionMetadata &Metadata) {
4798 if (Record.size() < 4) return true;
4800 Metadata.MajorVersion = Record[0];
4801 Metadata.MinorVersion = Record[1];
4803 unsigned BlockNameLen = Record[2];
4804 unsigned UserInfoLen = Record[3];
4806 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4808 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4809 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4810 Blob.data() + BlockNameLen + UserInfoLen);
4814 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4815 BitstreamCursor &Stream = F.Stream;
4819 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4821 Error(MaybeEntry.takeError());
4824 llvm::BitstreamEntry Entry = MaybeEntry.get();
4826 switch (Entry.Kind) {
4827 case llvm::BitstreamEntry::SubBlock:
4828 if (llvm::Error Err = Stream.SkipBlock()) {
4829 Error(std::move(Err));
4834 case llvm::BitstreamEntry::EndBlock:
4837 case llvm::BitstreamEntry::Error:
4840 case llvm::BitstreamEntry::Record:
4846 Expected<unsigned> MaybeRecCode =
4847 Stream.readRecord(Entry.ID, Record, &Blob);
4848 if (!MaybeRecCode) {
4849 Error(MaybeRecCode.takeError());
4852 switch (MaybeRecCode.get()) {
4853 case EXTENSION_METADATA: {
4854 ModuleFileExtensionMetadata Metadata;
4855 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata)) {
4856 Error("malformed EXTENSION_METADATA in AST file");
4860 // Find a module file extension with this block name.
4861 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4862 if (Known == ModuleFileExtensions.end()) break;
4865 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4867 F.ExtensionReaders.push_back(std::move(Reader));
4878 void ASTReader::InitializeContext() {
4879 assert(ContextObj && "no context to initialize");
4880 ASTContext &Context = *ContextObj;
4882 // If there's a listener, notify them that we "read" the translation unit.
4883 if (DeserializationListener)
4884 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4885 Context.getTranslationUnitDecl());
4887 // FIXME: Find a better way to deal with collisions between these
4888 // built-in types. Right now, we just ignore the problem.
4890 // Load the special types.
4891 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4892 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4893 if (!Context.CFConstantStringTypeDecl)
4894 Context.setCFConstantStringType(GetType(String));
4897 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4898 QualType FileType = GetType(File);
4899 if (FileType.isNull()) {
4900 Error("FILE type is NULL");
4904 if (!Context.FILEDecl) {
4905 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4906 Context.setFILEDecl(Typedef->getDecl());
4908 const TagType *Tag = FileType->getAs<TagType>();
4910 Error("Invalid FILE type in AST file");
4913 Context.setFILEDecl(Tag->getDecl());
4918 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4919 QualType Jmp_bufType = GetType(Jmp_buf);
4920 if (Jmp_bufType.isNull()) {
4921 Error("jmp_buf type is NULL");
4925 if (!Context.jmp_bufDecl) {
4926 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4927 Context.setjmp_bufDecl(Typedef->getDecl());
4929 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4931 Error("Invalid jmp_buf type in AST file");
4934 Context.setjmp_bufDecl(Tag->getDecl());
4939 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4940 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4941 if (Sigjmp_bufType.isNull()) {
4942 Error("sigjmp_buf type is NULL");
4946 if (!Context.sigjmp_bufDecl) {
4947 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4948 Context.setsigjmp_bufDecl(Typedef->getDecl());
4950 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4951 assert(Tag && "Invalid sigjmp_buf type in AST file");
4952 Context.setsigjmp_bufDecl(Tag->getDecl());
4957 if (unsigned ObjCIdRedef
4958 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4959 if (Context.ObjCIdRedefinitionType.isNull())
4960 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4963 if (unsigned ObjCClassRedef
4964 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4965 if (Context.ObjCClassRedefinitionType.isNull())
4966 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4969 if (unsigned ObjCSelRedef
4970 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4971 if (Context.ObjCSelRedefinitionType.isNull())
4972 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4975 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4976 QualType Ucontext_tType = GetType(Ucontext_t);
4977 if (Ucontext_tType.isNull()) {
4978 Error("ucontext_t type is NULL");
4982 if (!Context.ucontext_tDecl) {
4983 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4984 Context.setucontext_tDecl(Typedef->getDecl());
4986 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4987 assert(Tag && "Invalid ucontext_t type in AST file");
4988 Context.setucontext_tDecl(Tag->getDecl());
4994 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4996 // If there were any CUDA special declarations, deserialize them.
4997 if (!CUDASpecialDeclRefs.empty()) {
4998 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4999 Context.setcudaConfigureCallDecl(
5000 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5003 // Re-export any modules that were imported by a non-module AST file.
5004 // FIXME: This does not make macro-only imports visible again.
5005 for (auto &Import : ImportedModules) {
5006 if (Module *Imported = getSubmodule(Import.ID)) {
5007 makeModuleVisible(Imported, Module::AllVisible,
5008 /*ImportLoc=*/Import.ImportLoc);
5009 if (Import.ImportLoc.isValid())
5010 PP.makeModuleVisible(Imported, Import.ImportLoc);
5011 // This updates visibility for Preprocessor only. For Sema, which can be
5012 // nullptr here, we do the same later, in UpdateSema().
5017 void ASTReader::finalizeForWriting() {
5018 // Nothing to do for now.
5021 /// Reads and return the signature record from \p PCH's control block, or
5023 static ASTFileSignature readASTFileSignature(StringRef PCH) {
5024 BitstreamCursor Stream(PCH);
5025 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5026 // FIXME this drops the error on the floor.
5027 consumeError(std::move(Err));
5028 return ASTFileSignature();
5031 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5032 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
5033 return ASTFileSignature();
5035 // Scan for SIGNATURE inside the diagnostic options block.
5036 ASTReader::RecordData Record;
5038 Expected<llvm::BitstreamEntry> MaybeEntry =
5039 Stream.advanceSkippingSubblocks();
5041 // FIXME this drops the error on the floor.
5042 consumeError(MaybeEntry.takeError());
5043 return ASTFileSignature();
5045 llvm::BitstreamEntry Entry = MaybeEntry.get();
5047 if (Entry.Kind != llvm::BitstreamEntry::Record)
5048 return ASTFileSignature();
5052 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5054 // FIXME this drops the error on the floor.
5055 consumeError(MaybeRecord.takeError());
5056 return ASTFileSignature();
5058 if (SIGNATURE == MaybeRecord.get())
5059 return ASTFileSignature::create(Record.begin(),
5060 Record.begin() + ASTFileSignature::size);
5064 /// Retrieve the name of the original source file name
5065 /// directly from the AST file, without actually loading the AST
5067 std::string ASTReader::getOriginalSourceFile(
5068 const std::string &ASTFileName, FileManager &FileMgr,
5069 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
5070 // Open the AST file.
5071 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
5073 Diags.Report(diag::err_fe_unable_to_read_pch_file)
5074 << ASTFileName << Buffer.getError().message();
5075 return std::string();
5078 // Initialize the stream
5079 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
5081 // Sniff for the signature.
5082 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5083 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5084 return std::string();
5087 // Scan for the CONTROL_BLOCK_ID block.
5088 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
5089 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5090 return std::string();
5093 // Scan for ORIGINAL_FILE inside the control block.
5096 Expected<llvm::BitstreamEntry> MaybeEntry =
5097 Stream.advanceSkippingSubblocks();
5099 // FIXME this drops errors on the floor.
5100 consumeError(MaybeEntry.takeError());
5101 return std::string();
5103 llvm::BitstreamEntry Entry = MaybeEntry.get();
5105 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5106 return std::string();
5108 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5109 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5110 return std::string();
5115 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5117 // FIXME this drops the errors on the floor.
5118 consumeError(MaybeRecord.takeError());
5119 return std::string();
5121 if (ORIGINAL_FILE == MaybeRecord.get())
5128 class SimplePCHValidator : public ASTReaderListener {
5129 const LangOptions &ExistingLangOpts;
5130 const TargetOptions &ExistingTargetOpts;
5131 const PreprocessorOptions &ExistingPPOpts;
5132 std::string ExistingModuleCachePath;
5133 FileManager &FileMgr;
5136 SimplePCHValidator(const LangOptions &ExistingLangOpts,
5137 const TargetOptions &ExistingTargetOpts,
5138 const PreprocessorOptions &ExistingPPOpts,
5139 StringRef ExistingModuleCachePath, FileManager &FileMgr)
5140 : ExistingLangOpts(ExistingLangOpts),
5141 ExistingTargetOpts(ExistingTargetOpts),
5142 ExistingPPOpts(ExistingPPOpts),
5143 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr) {}
5145 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
5146 bool AllowCompatibleDifferences) override {
5147 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
5148 AllowCompatibleDifferences);
5151 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
5152 bool AllowCompatibleDifferences) override {
5153 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
5154 AllowCompatibleDifferences);
5157 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
5158 StringRef SpecificModuleCachePath,
5159 bool Complain) override {
5160 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5161 ExistingModuleCachePath, nullptr,
5162 ExistingLangOpts, ExistingPPOpts);
5165 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
5167 std::string &SuggestedPredefines) override {
5168 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
5169 SuggestedPredefines, ExistingLangOpts);
5175 bool ASTReader::readASTFileControlBlock(
5176 StringRef Filename, FileManager &FileMgr,
5177 const PCHContainerReader &PCHContainerRdr,
5178 bool FindModuleFileExtensions,
5179 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
5180 // Open the AST file.
5181 // FIXME: This allows use of the VFS; we do not allow use of the
5182 // VFS when actually loading a module.
5183 auto Buffer = FileMgr.getBufferForFile(Filename);
5188 // Initialize the stream
5189 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
5190 BitstreamCursor Stream(Bytes);
5192 // Sniff for the signature.
5193 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5194 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
5198 // Scan for the CONTROL_BLOCK_ID block.
5199 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
5202 bool NeedsInputFiles = Listener.needsInputFileVisitation();
5203 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
5204 bool NeedsImports = Listener.needsImportVisitation();
5205 BitstreamCursor InputFilesCursor;
5208 std::string ModuleDir;
5209 bool DoneWithControlBlock = false;
5210 while (!DoneWithControlBlock) {
5211 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5213 // FIXME this drops the error on the floor.
5214 consumeError(MaybeEntry.takeError());
5217 llvm::BitstreamEntry Entry = MaybeEntry.get();
5219 switch (Entry.Kind) {
5220 case llvm::BitstreamEntry::SubBlock: {
5222 case OPTIONS_BLOCK_ID: {
5223 std::string IgnoredSuggestedPredefines;
5224 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
5225 /*AllowCompatibleConfigurationMismatch*/ false,
5226 Listener, IgnoredSuggestedPredefines) != Success)
5231 case INPUT_FILES_BLOCK_ID:
5232 InputFilesCursor = Stream;
5233 if (llvm::Error Err = Stream.SkipBlock()) {
5234 // FIXME this drops the error on the floor.
5235 consumeError(std::move(Err));
5238 if (NeedsInputFiles &&
5239 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID))
5244 if (llvm::Error Err = Stream.SkipBlock()) {
5245 // FIXME this drops the error on the floor.
5246 consumeError(std::move(Err));
5255 case llvm::BitstreamEntry::EndBlock:
5256 DoneWithControlBlock = true;
5259 case llvm::BitstreamEntry::Error:
5262 case llvm::BitstreamEntry::Record:
5266 if (DoneWithControlBlock) break;
5270 Expected<unsigned> MaybeRecCode =
5271 Stream.readRecord(Entry.ID, Record, &Blob);
5272 if (!MaybeRecCode) {
5273 // FIXME this drops the error.
5276 switch ((ControlRecordTypes)MaybeRecCode.get()) {
5278 if (Record[0] != VERSION_MAJOR)
5280 if (Listener.ReadFullVersionInformation(Blob))
5284 Listener.ReadModuleName(Blob);
5286 case MODULE_DIRECTORY:
5287 ModuleDir = std::string(Blob);
5289 case MODULE_MAP_FILE: {
5291 auto Path = ReadString(Record, Idx);
5292 ResolveImportedPath(Path, ModuleDir);
5293 Listener.ReadModuleMapFile(Path);
5296 case INPUT_FILE_OFFSETS: {
5297 if (!NeedsInputFiles)
5300 unsigned NumInputFiles = Record[0];
5301 unsigned NumUserFiles = Record[1];
5302 const llvm::support::unaligned_uint64_t *InputFileOffs =
5303 (const llvm::support::unaligned_uint64_t *)Blob.data();
5304 for (unsigned I = 0; I != NumInputFiles; ++I) {
5305 // Go find this input file.
5306 bool isSystemFile = I >= NumUserFiles;
5308 if (isSystemFile && !NeedsSystemInputFiles)
5309 break; // the rest are system input files
5311 BitstreamCursor &Cursor = InputFilesCursor;
5312 SavedStreamPosition SavedPosition(Cursor);
5313 if (llvm::Error Err = Cursor.JumpToBit(InputFileOffs[I])) {
5314 // FIXME this drops errors on the floor.
5315 consumeError(std::move(Err));
5318 Expected<unsigned> MaybeCode = Cursor.ReadCode();
5320 // FIXME this drops errors on the floor.
5321 consumeError(MaybeCode.takeError());
5323 unsigned Code = MaybeCode.get();
5327 bool shouldContinue = false;
5328 Expected<unsigned> MaybeRecordType =
5329 Cursor.readRecord(Code, Record, &Blob);
5330 if (!MaybeRecordType) {
5331 // FIXME this drops errors on the floor.
5332 consumeError(MaybeRecordType.takeError());
5334 switch ((InputFileRecordTypes)MaybeRecordType.get()) {
5335 case INPUT_FILE_HASH:
5338 bool Overridden = static_cast<bool>(Record[3]);
5339 std::string Filename = std::string(Blob);
5340 ResolveImportedPath(Filename, ModuleDir);
5341 shouldContinue = Listener.visitInputFile(
5342 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
5345 if (!shouldContinue)
5355 unsigned Idx = 0, N = Record.size();
5357 // Read information about the AST file.
5360 ASTFileSignature::size; // Kind, ImportLoc, Size, ModTime, Signature
5361 std::string ModuleName = ReadString(Record, Idx);
5362 std::string Filename = ReadString(Record, Idx);
5363 ResolveImportedPath(Filename, ModuleDir);
5364 Listener.visitImport(ModuleName, Filename);
5370 // No other validation to perform.
5375 // Look for module file extension blocks, if requested.
5376 if (FindModuleFileExtensions) {
5377 BitstreamCursor SavedStream = Stream;
5378 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
5379 bool DoneWithExtensionBlock = false;
5380 while (!DoneWithExtensionBlock) {
5381 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5383 // FIXME this drops the error.
5386 llvm::BitstreamEntry Entry = MaybeEntry.get();
5388 switch (Entry.Kind) {
5389 case llvm::BitstreamEntry::SubBlock:
5390 if (llvm::Error Err = Stream.SkipBlock()) {
5391 // FIXME this drops the error on the floor.
5392 consumeError(std::move(Err));
5397 case llvm::BitstreamEntry::EndBlock:
5398 DoneWithExtensionBlock = true;
5401 case llvm::BitstreamEntry::Error:
5404 case llvm::BitstreamEntry::Record:
5410 Expected<unsigned> MaybeRecCode =
5411 Stream.readRecord(Entry.ID, Record, &Blob);
5412 if (!MaybeRecCode) {
5413 // FIXME this drops the error.
5416 switch (MaybeRecCode.get()) {
5417 case EXTENSION_METADATA: {
5418 ModuleFileExtensionMetadata Metadata;
5419 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
5422 Listener.readModuleFileExtension(Metadata);
5428 Stream = SavedStream;
5431 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5432 if (readUnhashedControlBlockImpl(
5433 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
5434 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
5435 ValidateDiagnosticOptions) != Success)
5441 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
5442 const PCHContainerReader &PCHContainerRdr,
5443 const LangOptions &LangOpts,
5444 const TargetOptions &TargetOpts,
5445 const PreprocessorOptions &PPOpts,
5446 StringRef ExistingModuleCachePath) {
5447 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5448 ExistingModuleCachePath, FileMgr);
5449 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
5450 /*FindModuleFileExtensions=*/false,
5452 /*ValidateDiagnosticOptions=*/true);
5455 ASTReader::ASTReadResult
5456 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
5457 // Enter the submodule block.
5458 if (llvm::Error Err = F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
5459 Error(std::move(Err));
5463 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5465 Module *CurrentModule = nullptr;
5468 Expected<llvm::BitstreamEntry> MaybeEntry =
5469 F.Stream.advanceSkippingSubblocks();
5471 Error(MaybeEntry.takeError());
5474 llvm::BitstreamEntry Entry = MaybeEntry.get();
5476 switch (Entry.Kind) {
5477 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
5478 case llvm::BitstreamEntry::Error:
5479 Error("malformed block record in AST file");
5481 case llvm::BitstreamEntry::EndBlock:
5483 case llvm::BitstreamEntry::Record:
5484 // The interesting case.
5491 Expected<unsigned> MaybeKind = F.Stream.readRecord(Entry.ID, Record, &Blob);
5493 Error(MaybeKind.takeError());
5496 unsigned Kind = MaybeKind.get();
5498 if ((Kind == SUBMODULE_METADATA) != First) {
5499 Error("submodule metadata record should be at beginning of block");
5504 // Submodule information is only valid if we have a current module.
5505 // FIXME: Should we error on these cases?
5506 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
5507 Kind != SUBMODULE_DEFINITION)
5511 default: // Default behavior: ignore.
5514 case SUBMODULE_DEFINITION: {
5515 if (Record.size() < 12) {
5516 Error("malformed module definition");
5520 StringRef Name = Blob;
5522 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5523 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5524 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5525 bool IsFramework = Record[Idx++];
5526 bool IsExplicit = Record[Idx++];
5527 bool IsSystem = Record[Idx++];
5528 bool IsExternC = Record[Idx++];
5529 bool InferSubmodules = Record[Idx++];
5530 bool InferExplicitSubmodules = Record[Idx++];
5531 bool InferExportWildcard = Record[Idx++];
5532 bool ConfigMacrosExhaustive = Record[Idx++];
5533 bool ModuleMapIsPrivate = Record[Idx++];
5535 Module *ParentModule = nullptr;
5537 ParentModule = getSubmodule(Parent);
5539 // Retrieve this (sub)module from the module map, creating it if
5542 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5545 // FIXME: set the definition loc for CurrentModule, or call
5546 // ModMap.setInferredModuleAllowedBy()
5548 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5549 if (GlobalIndex >= SubmodulesLoaded.size() ||
5550 SubmodulesLoaded[GlobalIndex]) {
5551 Error("too many submodules");
5555 if (!ParentModule) {
5556 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5557 // Don't emit module relocation error if we have -fno-validate-pch
5558 if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5559 DisableValidationForModuleKind::Module) &&
5560 CurFile != F.File) {
5561 Error(diag::err_module_file_conflict,
5562 CurrentModule->getTopLevelModuleName(), CurFile->getName(),
5568 F.DidReadTopLevelSubmodule = true;
5569 CurrentModule->setASTFile(F.File);
5570 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5573 CurrentModule->Kind = Kind;
5574 CurrentModule->Signature = F.Signature;
5575 CurrentModule->IsFromModuleFile = true;
5576 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5577 CurrentModule->IsExternC = IsExternC;
5578 CurrentModule->InferSubmodules = InferSubmodules;
5579 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5580 CurrentModule->InferExportWildcard = InferExportWildcard;
5581 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5582 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5583 if (DeserializationListener)
5584 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5586 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5588 // Clear out data that will be replaced by what is in the module file.
5589 CurrentModule->LinkLibraries.clear();
5590 CurrentModule->ConfigMacros.clear();
5591 CurrentModule->UnresolvedConflicts.clear();
5592 CurrentModule->Conflicts.clear();
5594 // The module is available unless it's missing a requirement; relevant
5595 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5596 // Missing headers that were present when the module was built do not
5597 // make it unavailable -- if we got this far, this must be an explicitly
5598 // imported module file.
5599 CurrentModule->Requirements.clear();
5600 CurrentModule->MissingHeaders.clear();
5601 CurrentModule->IsUnimportable =
5602 ParentModule && ParentModule->IsUnimportable;
5603 CurrentModule->IsAvailable = !CurrentModule->IsUnimportable;
5607 case SUBMODULE_UMBRELLA_HEADER: {
5608 std::string Filename = std::string(Blob);
5609 ResolveImportedPath(F, Filename);
5610 if (auto Umbrella = PP.getFileManager().getFile(Filename)) {
5611 if (!CurrentModule->getUmbrellaHeader())
5612 // FIXME: NameAsWritten
5613 ModMap.setUmbrellaHeader(CurrentModule, *Umbrella, Blob, "");
5614 else if (CurrentModule->getUmbrellaHeader().Entry != *Umbrella) {
5615 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5616 Error("mismatched umbrella headers in submodule");
5623 case SUBMODULE_HEADER:
5624 case SUBMODULE_EXCLUDED_HEADER:
5625 case SUBMODULE_PRIVATE_HEADER:
5626 // We lazily associate headers with their modules via the HeaderInfo table.
5627 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5628 // of complete filenames or remove it entirely.
5631 case SUBMODULE_TEXTUAL_HEADER:
5632 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5633 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5637 case SUBMODULE_TOPHEADER:
5638 CurrentModule->addTopHeaderFilename(Blob);
5641 case SUBMODULE_UMBRELLA_DIR: {
5642 std::string Dirname = std::string(Blob);
5643 ResolveImportedPath(F, Dirname);
5644 if (auto Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5645 if (!CurrentModule->getUmbrellaDir())
5646 // FIXME: NameAsWritten
5647 ModMap.setUmbrellaDir(CurrentModule, *Umbrella, Blob, "");
5648 else if (CurrentModule->getUmbrellaDir().Entry != *Umbrella) {
5649 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5650 Error("mismatched umbrella directories in submodule");
5657 case SUBMODULE_METADATA: {
5658 F.BaseSubmoduleID = getTotalNumSubmodules();
5659 F.LocalNumSubmodules = Record[0];
5660 unsigned LocalBaseSubmoduleID = Record[1];
5661 if (F.LocalNumSubmodules > 0) {
5662 // Introduce the global -> local mapping for submodules within this
5664 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5666 // Introduce the local -> global mapping for submodules within this
5668 F.SubmoduleRemap.insertOrReplace(
5669 std::make_pair(LocalBaseSubmoduleID,
5670 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5672 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5677 case SUBMODULE_IMPORTS:
5678 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5679 UnresolvedModuleRef Unresolved;
5680 Unresolved.File = &F;
5681 Unresolved.Mod = CurrentModule;
5682 Unresolved.ID = Record[Idx];
5683 Unresolved.Kind = UnresolvedModuleRef::Import;
5684 Unresolved.IsWildcard = false;
5685 UnresolvedModuleRefs.push_back(Unresolved);
5689 case SUBMODULE_EXPORTS:
5690 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5691 UnresolvedModuleRef Unresolved;
5692 Unresolved.File = &F;
5693 Unresolved.Mod = CurrentModule;
5694 Unresolved.ID = Record[Idx];
5695 Unresolved.Kind = UnresolvedModuleRef::Export;
5696 Unresolved.IsWildcard = Record[Idx + 1];
5697 UnresolvedModuleRefs.push_back(Unresolved);
5700 // Once we've loaded the set of exports, there's no reason to keep
5701 // the parsed, unresolved exports around.
5702 CurrentModule->UnresolvedExports.clear();
5705 case SUBMODULE_REQUIRES:
5706 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5707 PP.getTargetInfo());
5710 case SUBMODULE_LINK_LIBRARY:
5711 ModMap.resolveLinkAsDependencies(CurrentModule);
5712 CurrentModule->LinkLibraries.push_back(
5713 Module::LinkLibrary(std::string(Blob), Record[0]));
5716 case SUBMODULE_CONFIG_MACRO:
5717 CurrentModule->ConfigMacros.push_back(Blob.str());
5720 case SUBMODULE_CONFLICT: {
5721 UnresolvedModuleRef Unresolved;
5722 Unresolved.File = &F;
5723 Unresolved.Mod = CurrentModule;
5724 Unresolved.ID = Record[0];
5725 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5726 Unresolved.IsWildcard = false;
5727 Unresolved.String = Blob;
5728 UnresolvedModuleRefs.push_back(Unresolved);
5732 case SUBMODULE_INITIALIZERS: {
5735 SmallVector<uint32_t, 16> Inits;
5736 for (auto &ID : Record)
5737 Inits.push_back(getGlobalDeclID(F, ID));
5738 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5742 case SUBMODULE_EXPORT_AS:
5743 CurrentModule->ExportAsModule = Blob.str();
5744 ModMap.addLinkAsDependency(CurrentModule);
5750 /// Parse the record that corresponds to a LangOptions data
5753 /// This routine parses the language options from the AST file and then gives
5754 /// them to the AST listener if one is set.
5756 /// \returns true if the listener deems the file unacceptable, false otherwise.
5757 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5759 ASTReaderListener &Listener,
5760 bool AllowCompatibleDifferences) {
5761 LangOptions LangOpts;
5763 #define LANGOPT(Name, Bits, Default, Description) \
5764 LangOpts.Name = Record[Idx++];
5765 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5766 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5767 #include "clang/Basic/LangOptions.def"
5768 #define SANITIZER(NAME, ID) \
5769 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5770 #include "clang/Basic/Sanitizers.def"
5772 for (unsigned N = Record[Idx++]; N; --N)
5773 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5775 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5776 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5777 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5779 LangOpts.CurrentModule = ReadString(Record, Idx);
5782 for (unsigned N = Record[Idx++]; N; --N) {
5783 LangOpts.CommentOpts.BlockCommandNames.push_back(
5784 ReadString(Record, Idx));
5786 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5788 // OpenMP offloading options.
5789 for (unsigned N = Record[Idx++]; N; --N) {
5790 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5793 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5795 return Listener.ReadLanguageOptions(LangOpts, Complain,
5796 AllowCompatibleDifferences);
5799 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5800 ASTReaderListener &Listener,
5801 bool AllowCompatibleDifferences) {
5803 TargetOptions TargetOpts;
5804 TargetOpts.Triple = ReadString(Record, Idx);
5805 TargetOpts.CPU = ReadString(Record, Idx);
5806 TargetOpts.TuneCPU = ReadString(Record, Idx);
5807 TargetOpts.ABI = ReadString(Record, Idx);
5808 for (unsigned N = Record[Idx++]; N; --N) {
5809 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5811 for (unsigned N = Record[Idx++]; N; --N) {
5812 TargetOpts.Features.push_back(ReadString(Record, Idx));
5815 return Listener.ReadTargetOptions(TargetOpts, Complain,
5816 AllowCompatibleDifferences);
5819 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5820 ASTReaderListener &Listener) {
5821 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5823 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5824 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5825 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5826 #include "clang/Basic/DiagnosticOptions.def"
5828 for (unsigned N = Record[Idx++]; N; --N)
5829 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5830 for (unsigned N = Record[Idx++]; N; --N)
5831 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5833 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5836 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5837 ASTReaderListener &Listener) {
5838 FileSystemOptions FSOpts;
5840 FSOpts.WorkingDir = ReadString(Record, Idx);
5841 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5844 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5846 ASTReaderListener &Listener) {
5847 HeaderSearchOptions HSOpts;
5849 HSOpts.Sysroot = ReadString(Record, Idx);
5852 for (unsigned N = Record[Idx++]; N; --N) {
5853 std::string Path = ReadString(Record, Idx);
5854 frontend::IncludeDirGroup Group
5855 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5856 bool IsFramework = Record[Idx++];
5857 bool IgnoreSysRoot = Record[Idx++];
5858 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5862 // System header prefixes.
5863 for (unsigned N = Record[Idx++]; N; --N) {
5864 std::string Prefix = ReadString(Record, Idx);
5865 bool IsSystemHeader = Record[Idx++];
5866 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5869 HSOpts.ResourceDir = ReadString(Record, Idx);
5870 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5871 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5872 HSOpts.DisableModuleHash = Record[Idx++];
5873 HSOpts.ImplicitModuleMaps = Record[Idx++];
5874 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5875 HSOpts.EnablePrebuiltImplicitModules = Record[Idx++];
5876 HSOpts.UseBuiltinIncludes = Record[Idx++];
5877 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5878 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5879 HSOpts.UseLibcxx = Record[Idx++];
5880 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5882 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5886 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5888 ASTReaderListener &Listener,
5889 std::string &SuggestedPredefines) {
5890 PreprocessorOptions PPOpts;
5893 // Macro definitions/undefs
5894 for (unsigned N = Record[Idx++]; N; --N) {
5895 std::string Macro = ReadString(Record, Idx);
5896 bool IsUndef = Record[Idx++];
5897 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5901 for (unsigned N = Record[Idx++]; N; --N) {
5902 PPOpts.Includes.push_back(ReadString(Record, Idx));
5906 for (unsigned N = Record[Idx++]; N; --N) {
5907 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5910 PPOpts.UsePredefines = Record[Idx++];
5911 PPOpts.DetailedRecord = Record[Idx++];
5912 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5913 PPOpts.ObjCXXARCStandardLibrary =
5914 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5915 SuggestedPredefines.clear();
5916 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5917 SuggestedPredefines);
5920 std::pair<ModuleFile *, unsigned>
5921 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5922 GlobalPreprocessedEntityMapType::iterator
5923 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5924 assert(I != GlobalPreprocessedEntityMap.end() &&
5925 "Corrupted global preprocessed entity map");
5926 ModuleFile *M = I->second;
5927 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5928 return std::make_pair(M, LocalIndex);
5931 llvm::iterator_range<PreprocessingRecord::iterator>
5932 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5933 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5934 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5935 Mod.NumPreprocessedEntities);
5937 return llvm::make_range(PreprocessingRecord::iterator(),
5938 PreprocessingRecord::iterator());
5941 bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
5942 unsigned int ClientLoadCapabilities) {
5943 return ClientLoadCapabilities & ARR_OutOfDate &&
5944 !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
5947 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5948 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5949 return llvm::make_range(
5950 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5951 ModuleDeclIterator(this, &Mod,
5952 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5955 SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5956 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5957 assert(I != GlobalSkippedRangeMap.end() &&
5958 "Corrupted global skipped range map");
5959 ModuleFile *M = I->second;
5960 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5961 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5962 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5963 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5964 TranslateSourceLocation(*M, RawRange.getEnd()));
5965 assert(Range.isValid());
5969 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5970 PreprocessedEntityID PPID = Index+1;
5971 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5972 ModuleFile &M = *PPInfo.first;
5973 unsigned LocalIndex = PPInfo.second;
5974 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5976 if (!PP.getPreprocessingRecord()) {
5977 Error("no preprocessing record");
5981 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5982 if (llvm::Error Err = M.PreprocessorDetailCursor.JumpToBit(
5983 M.MacroOffsetsBase + PPOffs.BitOffset)) {
5984 Error(std::move(Err));
5988 Expected<llvm::BitstreamEntry> MaybeEntry =
5989 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5991 Error(MaybeEntry.takeError());
5994 llvm::BitstreamEntry Entry = MaybeEntry.get();
5996 if (Entry.Kind != llvm::BitstreamEntry::Record)
6000 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
6001 TranslateSourceLocation(M, PPOffs.getEnd()));
6002 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
6005 Expected<unsigned> MaybeRecType =
6006 M.PreprocessorDetailCursor.readRecord(Entry.ID, Record, &Blob);
6007 if (!MaybeRecType) {
6008 Error(MaybeRecType.takeError());
6011 switch ((PreprocessorDetailRecordTypes)MaybeRecType.get()) {
6012 case PPD_MACRO_EXPANSION: {
6013 bool isBuiltin = Record[0];
6014 IdentifierInfo *Name = nullptr;
6015 MacroDefinitionRecord *Def = nullptr;
6017 Name = getLocalIdentifier(M, Record[1]);
6019 PreprocessedEntityID GlobalID =
6020 getGlobalPreprocessedEntityID(M, Record[1]);
6021 Def = cast<MacroDefinitionRecord>(
6022 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6027 ME = new (PPRec) MacroExpansion(Name, Range);
6029 ME = new (PPRec) MacroExpansion(Def, Range);
6034 case PPD_MACRO_DEFINITION: {
6035 // Decode the identifier info and then check again; if the macro is
6036 // still defined and associated with the identifier,
6037 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
6038 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
6040 if (DeserializationListener)
6041 DeserializationListener->MacroDefinitionRead(PPID, MD);
6046 case PPD_INCLUSION_DIRECTIVE: {
6047 const char *FullFileNameStart = Blob.data() + Record[0];
6048 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
6049 const FileEntry *File = nullptr;
6050 if (!FullFileName.empty())
6051 if (auto FE = PP.getFileManager().getFile(FullFileName))
6054 // FIXME: Stable encoding
6055 InclusionDirective::InclusionKind Kind
6056 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
6057 InclusionDirective *ID
6058 = new (PPRec) InclusionDirective(PPRec, Kind,
6059 StringRef(Blob.data(), Record[0]),
6060 Record[1], Record[3],
6067 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
6070 /// Find the next module that contains entities and return the ID
6071 /// of the first entry.
6073 /// \param SLocMapI points at a chunk of a module that contains no
6074 /// preprocessed entities or the entities it contains are not the ones we are
6076 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
6077 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
6079 for (GlobalSLocOffsetMapType::const_iterator
6080 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6081 ModuleFile &M = *SLocMapI->second;
6082 if (M.NumPreprocessedEntities)
6083 return M.BasePreprocessedEntityID;
6086 return getTotalNumPreprocessedEntities();
6091 struct PPEntityComp {
6092 const ASTReader &Reader;
6095 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
6097 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
6098 SourceLocation LHS = getLoc(L);
6099 SourceLocation RHS = getLoc(R);
6100 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6103 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
6104 SourceLocation LHS = getLoc(L);
6105 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6108 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
6109 SourceLocation RHS = getLoc(R);
6110 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6113 SourceLocation getLoc(const PPEntityOffset &PPE) const {
6114 return Reader.TranslateSourceLocation(M, PPE.getBegin());
6120 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
6121 bool EndsAfter) const {
6122 if (SourceMgr.isLocalSourceLocation(Loc))
6123 return getTotalNumPreprocessedEntities();
6125 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6126 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
6127 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6128 "Corrupted global sloc offset map");
6130 if (SLocMapI->second->NumPreprocessedEntities == 0)
6131 return findNextPreprocessedEntity(SLocMapI);
6133 ModuleFile &M = *SLocMapI->second;
6135 using pp_iterator = const PPEntityOffset *;
6137 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
6138 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
6140 size_t Count = M.NumPreprocessedEntities;
6142 pp_iterator First = pp_begin;
6146 PPI = std::upper_bound(pp_begin, pp_end, Loc,
6147 PPEntityComp(*this, M));
6149 // Do a binary search manually instead of using std::lower_bound because
6150 // The end locations of entities may be unordered (when a macro expansion
6151 // is inside another macro argument), but for this case it is not important
6152 // whether we get the first macro expansion or its containing macro.
6156 std::advance(PPI, Half);
6157 if (SourceMgr.isBeforeInTranslationUnit(
6158 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
6161 Count = Count - Half - 1;
6168 return findNextPreprocessedEntity(SLocMapI);
6170 return M.BasePreprocessedEntityID + (PPI - pp_begin);
6173 /// Returns a pair of [Begin, End) indices of preallocated
6174 /// preprocessed entities that \arg Range encompasses.
6175 std::pair<unsigned, unsigned>
6176 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
6177 if (Range.isInvalid())
6178 return std::make_pair(0,0);
6179 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
6181 PreprocessedEntityID BeginID =
6182 findPreprocessedEntity(Range.getBegin(), false);
6183 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
6184 return std::make_pair(BeginID, EndID);
6187 /// Optionally returns true or false if the preallocated preprocessed
6188 /// entity with index \arg Index came from file \arg FID.
6189 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
6191 if (FID.isInvalid())
6194 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6195 ModuleFile &M = *PPInfo.first;
6196 unsigned LocalIndex = PPInfo.second;
6197 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
6199 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
6200 if (Loc.isInvalid())
6203 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
6211 /// Visitor used to search for information about a header file.
6212 class HeaderFileInfoVisitor {
6213 const FileEntry *FE;
6214 Optional<HeaderFileInfo> HFI;
6217 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
6219 bool operator()(ModuleFile &M) {
6220 HeaderFileInfoLookupTable *Table
6221 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
6225 // Look in the on-disk hash table for an entry for this file name.
6226 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6227 if (Pos == Table->end())
6234 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
6239 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
6240 HeaderFileInfoVisitor Visitor(FE);
6241 ModuleMgr.visit(Visitor);
6242 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6245 return HeaderFileInfo();
6248 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
6249 using DiagState = DiagnosticsEngine::DiagState;
6250 SmallVector<DiagState *, 32> DiagStates;
6252 for (ModuleFile &F : ModuleMgr) {
6254 auto &Record = F.PragmaDiagMappings;
6260 auto ReadDiagState =
6261 [&](const DiagState &BasedOn, SourceLocation Loc,
6262 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
6263 unsigned BackrefID = Record[Idx++];
6265 return DiagStates[BackrefID - 1];
6267 // A new DiagState was created here.
6268 Diag.DiagStates.push_back(BasedOn);
6269 DiagState *NewState = &Diag.DiagStates.back();
6270 DiagStates.push_back(NewState);
6271 unsigned Size = Record[Idx++];
6272 assert(Idx + Size * 2 <= Record.size() &&
6273 "Invalid data, not enough diag/map pairs");
6275 unsigned DiagID = Record[Idx++];
6276 DiagnosticMapping NewMapping =
6277 DiagnosticMapping::deserialize(Record[Idx++]);
6278 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
6281 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
6283 // If this mapping was specified as a warning but the severity was
6284 // upgraded due to diagnostic settings, simulate the current diagnostic
6285 // settings (and use a warning).
6286 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
6287 NewMapping.setSeverity(diag::Severity::Warning);
6288 NewMapping.setUpgradedFromWarning(false);
6291 Mapping = NewMapping;
6296 // Read the first state.
6297 DiagState *FirstState;
6298 if (F.Kind == MK_ImplicitModule) {
6299 // Implicitly-built modules are reused with different diagnostic
6300 // settings. Use the initial diagnostic state from Diag to simulate this
6301 // compilation's diagnostic settings.
6302 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
6303 DiagStates.push_back(FirstState);
6305 // Skip the initial diagnostic state from the serialized module.
6306 assert(Record[1] == 0 &&
6307 "Invalid data, unexpected backref in initial state");
6308 Idx = 3 + Record[2] * 2;
6309 assert(Idx < Record.size() &&
6310 "Invalid data, not enough state change pairs in initial state");
6311 } else if (F.isModule()) {
6312 // For an explicit module, preserve the flags from the module build
6313 // command line (-w, -Weverything, -Werror, ...) along with any explicit
6315 unsigned Flags = Record[Idx++];
6317 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6318 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6319 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6320 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6321 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6322 Initial.ExtBehavior = (diag::Severity)Flags;
6323 FirstState = ReadDiagState(Initial, SourceLocation(), true);
6325 assert(F.OriginalSourceFileID.isValid());
6327 // Set up the root buffer of the module to start with the initial
6328 // diagnostic state of the module itself, to cover files that contain no
6329 // explicit transitions (for which we did not serialize anything).
6330 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
6331 .StateTransitions.push_back({FirstState, 0});
6333 // For prefix ASTs, start with whatever the user configured on the
6335 Idx++; // Skip flags.
6336 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
6337 SourceLocation(), false);
6340 // Read the state transitions.
6341 unsigned NumLocations = Record[Idx++];
6342 while (NumLocations--) {
6343 assert(Idx < Record.size() &&
6344 "Invalid data, missing pragma diagnostic states");
6345 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
6346 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
6347 assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
6348 assert(IDAndOffset.second == 0 && "not a start location for a FileID");
6349 unsigned Transitions = Record[Idx++];
6351 // Note that we don't need to set up Parent/ParentOffset here, because
6352 // we won't be changing the diagnostic state within imported FileIDs
6353 // (other than perhaps appending to the main source file, which has no
6355 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
6356 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6357 for (unsigned I = 0; I != Transitions; ++I) {
6358 unsigned Offset = Record[Idx++];
6360 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
6361 F.StateTransitions.push_back({State, Offset});
6365 // Read the final state.
6366 assert(Idx < Record.size() &&
6367 "Invalid data, missing final pragma diagnostic state");
6368 SourceLocation CurStateLoc =
6369 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
6370 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
6372 if (!F.isModule()) {
6373 Diag.DiagStatesByLoc.CurDiagState = CurState;
6374 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6376 // Preserve the property that the imaginary root file describes the
6379 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6381 T.push_back({CurState, 0});
6383 T[0].State = CurState;
6386 // Don't try to read these mappings again.
6391 /// Get the correct cursor and offset for loading a type.
6392 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
6393 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6394 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
6395 ModuleFile *M = I->second;
6396 return RecordLocation(
6397 M, M->TypeOffsets[Index - M->BaseTypeIndex].getBitOffset() +
6398 M->DeclsBlockStartOffset);
6401 static llvm::Optional<Type::TypeClass> getTypeClassForCode(TypeCode code) {
6403 #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6404 case TYPE_##CODE_ID: return Type::CLASS_ID;
6405 #include "clang/Serialization/TypeBitCodes.def"
6406 default: return llvm::None;
6410 /// Read and return the type with the given index..
6412 /// The index is the type ID, shifted and minus the number of predefs. This
6413 /// routine actually reads the record corresponding to the type at the given
6414 /// location. It is a helper routine for GetType, which deals with reading type
6416 QualType ASTReader::readTypeRecord(unsigned Index) {
6417 assert(ContextObj && "reading type with no AST context");
6418 ASTContext &Context = *ContextObj;
6419 RecordLocation Loc = TypeCursorForIndex(Index);
6420 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
6422 // Keep track of where we are in the stream, then jump back there
6423 // after reading this type.
6424 SavedStreamPosition SavedPosition(DeclsCursor);
6426 ReadingKindTracker ReadingKind(Read_Type, *this);
6428 // Note that we are loading a type record.
6429 Deserializing AType(this);
6431 if (llvm::Error Err = DeclsCursor.JumpToBit(Loc.Offset)) {
6432 Error(std::move(Err));
6435 Expected<unsigned> RawCode = DeclsCursor.ReadCode();
6437 Error(RawCode.takeError());
6441 ASTRecordReader Record(*this, *Loc.F);
6442 Expected<unsigned> Code = Record.readRecord(DeclsCursor, RawCode.get());
6444 Error(Code.takeError());
6447 if (Code.get() == TYPE_EXT_QUAL) {
6448 QualType baseType = Record.readQualType();
6449 Qualifiers quals = Record.readQualifiers();
6450 return Context.getQualifiedType(baseType, quals);
6453 auto maybeClass = getTypeClassForCode((TypeCode) Code.get());
6455 Error("Unexpected code for type");
6459 serialization::AbstractTypeReader<ASTRecordReader> TypeReader(Record);
6460 return TypeReader.read(*maybeClass);
6465 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6466 ASTRecordReader &Reader;
6468 SourceLocation readSourceLocation() {
6469 return Reader.readSourceLocation();
6472 TypeSourceInfo *GetTypeSourceInfo() {
6473 return Reader.readTypeSourceInfo();
6476 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6477 return Reader.readNestedNameSpecifierLoc();
6481 return Reader.readAttr();
6485 TypeLocReader(ASTRecordReader &Reader) : Reader(Reader) {}
6487 // We want compile-time assurance that we've enumerated all of
6488 // these, so unfortunately we have to declare them first, then
6489 // define them out-of-line.
6490 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6491 #define TYPELOC(CLASS, PARENT) \
6492 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6493 #include "clang/AST/TypeLocNodes.def"
6495 void VisitFunctionTypeLoc(FunctionTypeLoc);
6496 void VisitArrayTypeLoc(ArrayTypeLoc);
6499 } // namespace clang
6501 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6505 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6506 TL.setBuiltinLoc(readSourceLocation());
6507 if (TL.needsExtraLocalData()) {
6508 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Reader.readInt()));
6509 TL.setWrittenSignSpec(static_cast<TypeSpecifierSign>(Reader.readInt()));
6510 TL.setWrittenWidthSpec(static_cast<TypeSpecifierWidth>(Reader.readInt()));
6511 TL.setModeAttr(Reader.readInt());
6515 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6516 TL.setNameLoc(readSourceLocation());
6519 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6520 TL.setStarLoc(readSourceLocation());
6523 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6527 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6531 void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6532 TL.setExpansionLoc(readSourceLocation());
6535 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6536 TL.setCaretLoc(readSourceLocation());
6539 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6540 TL.setAmpLoc(readSourceLocation());
6543 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6544 TL.setAmpAmpLoc(readSourceLocation());
6547 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6548 TL.setStarLoc(readSourceLocation());
6549 TL.setClassTInfo(GetTypeSourceInfo());
6552 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6553 TL.setLBracketLoc(readSourceLocation());
6554 TL.setRBracketLoc(readSourceLocation());
6555 if (Reader.readBool())
6556 TL.setSizeExpr(Reader.readExpr());
6558 TL.setSizeExpr(nullptr);
6561 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6562 VisitArrayTypeLoc(TL);
6565 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6566 VisitArrayTypeLoc(TL);
6569 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6570 VisitArrayTypeLoc(TL);
6573 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6574 DependentSizedArrayTypeLoc TL) {
6575 VisitArrayTypeLoc(TL);
6578 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6579 DependentAddressSpaceTypeLoc TL) {
6581 TL.setAttrNameLoc(readSourceLocation());
6582 TL.setAttrOperandParensRange(Reader.readSourceRange());
6583 TL.setAttrExprOperand(Reader.readExpr());
6586 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6587 DependentSizedExtVectorTypeLoc TL) {
6588 TL.setNameLoc(readSourceLocation());
6591 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6592 TL.setNameLoc(readSourceLocation());
6595 void TypeLocReader::VisitDependentVectorTypeLoc(
6596 DependentVectorTypeLoc TL) {
6597 TL.setNameLoc(readSourceLocation());
6600 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6601 TL.setNameLoc(readSourceLocation());
6604 void TypeLocReader::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
6605 TL.setAttrNameLoc(readSourceLocation());
6606 TL.setAttrOperandParensRange(Reader.readSourceRange());
6607 TL.setAttrRowOperand(Reader.readExpr());
6608 TL.setAttrColumnOperand(Reader.readExpr());
6611 void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6612 DependentSizedMatrixTypeLoc TL) {
6613 TL.setAttrNameLoc(readSourceLocation());
6614 TL.setAttrOperandParensRange(Reader.readSourceRange());
6615 TL.setAttrRowOperand(Reader.readExpr());
6616 TL.setAttrColumnOperand(Reader.readExpr());
6619 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6620 TL.setLocalRangeBegin(readSourceLocation());
6621 TL.setLParenLoc(readSourceLocation());
6622 TL.setRParenLoc(readSourceLocation());
6623 TL.setExceptionSpecRange(Reader.readSourceRange());
6624 TL.setLocalRangeEnd(readSourceLocation());
6625 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6626 TL.setParam(i, Reader.readDeclAs<ParmVarDecl>());
6630 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6631 VisitFunctionTypeLoc(TL);
6634 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6635 VisitFunctionTypeLoc(TL);
6638 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6639 TL.setNameLoc(readSourceLocation());
6642 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6643 TL.setNameLoc(readSourceLocation());
6646 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6647 TL.setTypeofLoc(readSourceLocation());
6648 TL.setLParenLoc(readSourceLocation());
6649 TL.setRParenLoc(readSourceLocation());
6652 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6653 TL.setTypeofLoc(readSourceLocation());
6654 TL.setLParenLoc(readSourceLocation());
6655 TL.setRParenLoc(readSourceLocation());
6656 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6659 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6660 TL.setNameLoc(readSourceLocation());
6663 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6664 TL.setKWLoc(readSourceLocation());
6665 TL.setLParenLoc(readSourceLocation());
6666 TL.setRParenLoc(readSourceLocation());
6667 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6670 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6671 TL.setNameLoc(readSourceLocation());
6672 if (Reader.readBool()) {
6673 TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
6674 TL.setTemplateKWLoc(readSourceLocation());
6675 TL.setConceptNameLoc(readSourceLocation());
6676 TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
6677 TL.setLAngleLoc(readSourceLocation());
6678 TL.setRAngleLoc(readSourceLocation());
6679 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6680 TL.setArgLocInfo(i, Reader.readTemplateArgumentLocInfo(
6681 TL.getTypePtr()->getArg(i).getKind()));
6685 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6686 DeducedTemplateSpecializationTypeLoc TL) {
6687 TL.setTemplateNameLoc(readSourceLocation());
6690 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6691 TL.setNameLoc(readSourceLocation());
6694 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6695 TL.setNameLoc(readSourceLocation());
6698 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6699 TL.setAttr(ReadAttr());
6702 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6703 TL.setNameLoc(readSourceLocation());
6706 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6707 SubstTemplateTypeParmTypeLoc TL) {
6708 TL.setNameLoc(readSourceLocation());
6711 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6712 SubstTemplateTypeParmPackTypeLoc TL) {
6713 TL.setNameLoc(readSourceLocation());
6716 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6717 TemplateSpecializationTypeLoc TL) {
6718 TL.setTemplateKeywordLoc(readSourceLocation());
6719 TL.setTemplateNameLoc(readSourceLocation());
6720 TL.setLAngleLoc(readSourceLocation());
6721 TL.setRAngleLoc(readSourceLocation());
6722 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6725 Reader.readTemplateArgumentLocInfo(
6726 TL.getTypePtr()->getArg(i).getKind()));
6729 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6730 TL.setLParenLoc(readSourceLocation());
6731 TL.setRParenLoc(readSourceLocation());
6734 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6735 TL.setElaboratedKeywordLoc(readSourceLocation());
6736 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6739 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6740 TL.setNameLoc(readSourceLocation());
6743 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6744 TL.setElaboratedKeywordLoc(readSourceLocation());
6745 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6746 TL.setNameLoc(readSourceLocation());
6749 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6750 DependentTemplateSpecializationTypeLoc TL) {
6751 TL.setElaboratedKeywordLoc(readSourceLocation());
6752 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6753 TL.setTemplateKeywordLoc(readSourceLocation());
6754 TL.setTemplateNameLoc(readSourceLocation());
6755 TL.setLAngleLoc(readSourceLocation());
6756 TL.setRAngleLoc(readSourceLocation());
6757 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6760 Reader.readTemplateArgumentLocInfo(
6761 TL.getTypePtr()->getArg(I).getKind()));
6764 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6765 TL.setEllipsisLoc(readSourceLocation());
6768 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6769 TL.setNameLoc(readSourceLocation());
6772 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6773 if (TL.getNumProtocols()) {
6774 TL.setProtocolLAngleLoc(readSourceLocation());
6775 TL.setProtocolRAngleLoc(readSourceLocation());
6777 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6778 TL.setProtocolLoc(i, readSourceLocation());
6781 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6782 TL.setHasBaseTypeAsWritten(Reader.readBool());
6783 TL.setTypeArgsLAngleLoc(readSourceLocation());
6784 TL.setTypeArgsRAngleLoc(readSourceLocation());
6785 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6786 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6787 TL.setProtocolLAngleLoc(readSourceLocation());
6788 TL.setProtocolRAngleLoc(readSourceLocation());
6789 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6790 TL.setProtocolLoc(i, readSourceLocation());
6793 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6794 TL.setStarLoc(readSourceLocation());
6797 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6798 TL.setKWLoc(readSourceLocation());
6799 TL.setLParenLoc(readSourceLocation());
6800 TL.setRParenLoc(readSourceLocation());
6803 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6804 TL.setKWLoc(readSourceLocation());
6807 void TypeLocReader::VisitExtIntTypeLoc(clang::ExtIntTypeLoc TL) {
6808 TL.setNameLoc(readSourceLocation());
6810 void TypeLocReader::VisitDependentExtIntTypeLoc(
6811 clang::DependentExtIntTypeLoc TL) {
6812 TL.setNameLoc(readSourceLocation());
6816 void ASTRecordReader::readTypeLoc(TypeLoc TL) {
6817 TypeLocReader TLR(*this);
6818 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6822 TypeSourceInfo *ASTRecordReader::readTypeSourceInfo() {
6823 QualType InfoTy = readType();
6824 if (InfoTy.isNull())
6827 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6828 readTypeLoc(TInfo->getTypeLoc());
6832 QualType ASTReader::GetType(TypeID ID) {
6833 assert(ContextObj && "reading type with no AST context");
6834 ASTContext &Context = *ContextObj;
6836 unsigned FastQuals = ID & Qualifiers::FastMask;
6837 unsigned Index = ID >> Qualifiers::FastWidth;
6839 if (Index < NUM_PREDEF_TYPE_IDS) {
6841 switch ((PredefinedTypeIDs)Index) {
6842 case PREDEF_TYPE_NULL_ID:
6844 case PREDEF_TYPE_VOID_ID:
6847 case PREDEF_TYPE_BOOL_ID:
6850 case PREDEF_TYPE_CHAR_U_ID:
6851 case PREDEF_TYPE_CHAR_S_ID:
6852 // FIXME: Check that the signedness of CharTy is correct!
6855 case PREDEF_TYPE_UCHAR_ID:
6856 T = Context.UnsignedCharTy;
6858 case PREDEF_TYPE_USHORT_ID:
6859 T = Context.UnsignedShortTy;
6861 case PREDEF_TYPE_UINT_ID:
6862 T = Context.UnsignedIntTy;
6864 case PREDEF_TYPE_ULONG_ID:
6865 T = Context.UnsignedLongTy;
6867 case PREDEF_TYPE_ULONGLONG_ID:
6868 T = Context.UnsignedLongLongTy;
6870 case PREDEF_TYPE_UINT128_ID:
6871 T = Context.UnsignedInt128Ty;
6873 case PREDEF_TYPE_SCHAR_ID:
6874 T = Context.SignedCharTy;
6876 case PREDEF_TYPE_WCHAR_ID:
6877 T = Context.WCharTy;
6879 case PREDEF_TYPE_SHORT_ID:
6880 T = Context.ShortTy;
6882 case PREDEF_TYPE_INT_ID:
6885 case PREDEF_TYPE_LONG_ID:
6888 case PREDEF_TYPE_LONGLONG_ID:
6889 T = Context.LongLongTy;
6891 case PREDEF_TYPE_INT128_ID:
6892 T = Context.Int128Ty;
6894 case PREDEF_TYPE_BFLOAT16_ID:
6895 T = Context.BFloat16Ty;
6897 case PREDEF_TYPE_HALF_ID:
6900 case PREDEF_TYPE_FLOAT_ID:
6901 T = Context.FloatTy;
6903 case PREDEF_TYPE_DOUBLE_ID:
6904 T = Context.DoubleTy;
6906 case PREDEF_TYPE_LONGDOUBLE_ID:
6907 T = Context.LongDoubleTy;
6909 case PREDEF_TYPE_SHORT_ACCUM_ID:
6910 T = Context.ShortAccumTy;
6912 case PREDEF_TYPE_ACCUM_ID:
6913 T = Context.AccumTy;
6915 case PREDEF_TYPE_LONG_ACCUM_ID:
6916 T = Context.LongAccumTy;
6918 case PREDEF_TYPE_USHORT_ACCUM_ID:
6919 T = Context.UnsignedShortAccumTy;
6921 case PREDEF_TYPE_UACCUM_ID:
6922 T = Context.UnsignedAccumTy;
6924 case PREDEF_TYPE_ULONG_ACCUM_ID:
6925 T = Context.UnsignedLongAccumTy;
6927 case PREDEF_TYPE_SHORT_FRACT_ID:
6928 T = Context.ShortFractTy;
6930 case PREDEF_TYPE_FRACT_ID:
6931 T = Context.FractTy;
6933 case PREDEF_TYPE_LONG_FRACT_ID:
6934 T = Context.LongFractTy;
6936 case PREDEF_TYPE_USHORT_FRACT_ID:
6937 T = Context.UnsignedShortFractTy;
6939 case PREDEF_TYPE_UFRACT_ID:
6940 T = Context.UnsignedFractTy;
6942 case PREDEF_TYPE_ULONG_FRACT_ID:
6943 T = Context.UnsignedLongFractTy;
6945 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6946 T = Context.SatShortAccumTy;
6948 case PREDEF_TYPE_SAT_ACCUM_ID:
6949 T = Context.SatAccumTy;
6951 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6952 T = Context.SatLongAccumTy;
6954 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6955 T = Context.SatUnsignedShortAccumTy;
6957 case PREDEF_TYPE_SAT_UACCUM_ID:
6958 T = Context.SatUnsignedAccumTy;
6960 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6961 T = Context.SatUnsignedLongAccumTy;
6963 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6964 T = Context.SatShortFractTy;
6966 case PREDEF_TYPE_SAT_FRACT_ID:
6967 T = Context.SatFractTy;
6969 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6970 T = Context.SatLongFractTy;
6972 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6973 T = Context.SatUnsignedShortFractTy;
6975 case PREDEF_TYPE_SAT_UFRACT_ID:
6976 T = Context.SatUnsignedFractTy;
6978 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6979 T = Context.SatUnsignedLongFractTy;
6981 case PREDEF_TYPE_FLOAT16_ID:
6982 T = Context.Float16Ty;
6984 case PREDEF_TYPE_FLOAT128_ID:
6985 T = Context.Float128Ty;
6987 case PREDEF_TYPE_OVERLOAD_ID:
6988 T = Context.OverloadTy;
6990 case PREDEF_TYPE_BOUND_MEMBER:
6991 T = Context.BoundMemberTy;
6993 case PREDEF_TYPE_PSEUDO_OBJECT:
6994 T = Context.PseudoObjectTy;
6996 case PREDEF_TYPE_DEPENDENT_ID:
6997 T = Context.DependentTy;
6999 case PREDEF_TYPE_UNKNOWN_ANY:
7000 T = Context.UnknownAnyTy;
7002 case PREDEF_TYPE_NULLPTR_ID:
7003 T = Context.NullPtrTy;
7005 case PREDEF_TYPE_CHAR8_ID:
7006 T = Context.Char8Ty;
7008 case PREDEF_TYPE_CHAR16_ID:
7009 T = Context.Char16Ty;
7011 case PREDEF_TYPE_CHAR32_ID:
7012 T = Context.Char32Ty;
7014 case PREDEF_TYPE_OBJC_ID:
7015 T = Context.ObjCBuiltinIdTy;
7017 case PREDEF_TYPE_OBJC_CLASS:
7018 T = Context.ObjCBuiltinClassTy;
7020 case PREDEF_TYPE_OBJC_SEL:
7021 T = Context.ObjCBuiltinSelTy;
7023 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7024 case PREDEF_TYPE_##Id##_ID: \
7025 T = Context.SingletonId; \
7027 #include "clang/Basic/OpenCLImageTypes.def"
7028 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7029 case PREDEF_TYPE_##Id##_ID: \
7030 T = Context.Id##Ty; \
7032 #include "clang/Basic/OpenCLExtensionTypes.def"
7033 case PREDEF_TYPE_SAMPLER_ID:
7034 T = Context.OCLSamplerTy;
7036 case PREDEF_TYPE_EVENT_ID:
7037 T = Context.OCLEventTy;
7039 case PREDEF_TYPE_CLK_EVENT_ID:
7040 T = Context.OCLClkEventTy;
7042 case PREDEF_TYPE_QUEUE_ID:
7043 T = Context.OCLQueueTy;
7045 case PREDEF_TYPE_RESERVE_ID_ID:
7046 T = Context.OCLReserveIDTy;
7048 case PREDEF_TYPE_AUTO_DEDUCT:
7049 T = Context.getAutoDeductType();
7051 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7052 T = Context.getAutoRRefDeductType();
7054 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7055 T = Context.ARCUnbridgedCastTy;
7057 case PREDEF_TYPE_BUILTIN_FN:
7058 T = Context.BuiltinFnTy;
7060 case PREDEF_TYPE_INCOMPLETE_MATRIX_IDX:
7061 T = Context.IncompleteMatrixIdxTy;
7063 case PREDEF_TYPE_OMP_ARRAY_SECTION:
7064 T = Context.OMPArraySectionTy;
7066 case PREDEF_TYPE_OMP_ARRAY_SHAPING:
7067 T = Context.OMPArraySectionTy;
7069 case PREDEF_TYPE_OMP_ITERATOR:
7070 T = Context.OMPIteratorTy;
7072 #define SVE_TYPE(Name, Id, SingletonId) \
7073 case PREDEF_TYPE_##Id##_ID: \
7074 T = Context.SingletonId; \
7076 #include "clang/Basic/AArch64SVEACLETypes.def"
7077 #define PPC_VECTOR_TYPE(Name, Id, Size) \
7078 case PREDEF_TYPE_##Id##_ID: \
7079 T = Context.Id##Ty; \
7081 #include "clang/Basic/PPCTypes.def"
7082 #define RVV_TYPE(Name, Id, SingletonId) \
7083 case PREDEF_TYPE_##Id##_ID: \
7084 T = Context.SingletonId; \
7086 #include "clang/Basic/RISCVVTypes.def"
7089 assert(!T.isNull() && "Unknown predefined type");
7090 return T.withFastQualifiers(FastQuals);
7093 Index -= NUM_PREDEF_TYPE_IDS;
7094 assert(Index < TypesLoaded.size() && "Type index out-of-range");
7095 if (TypesLoaded[Index].isNull()) {
7096 TypesLoaded[Index] = readTypeRecord(Index);
7097 if (TypesLoaded[Index].isNull())
7100 TypesLoaded[Index]->setFromAST();
7101 if (DeserializationListener)
7102 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7103 TypesLoaded[Index]);
7106 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7109 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7110 return GetType(getGlobalTypeID(F, LocalID));
7113 serialization::TypeID
7114 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7115 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7116 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7118 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7121 if (!F.ModuleOffsetMap.empty())
7122 ReadModuleOffsetMap(F);
7124 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7125 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7126 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7128 unsigned GlobalIndex = LocalIndex + I->second;
7129 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7132 TemplateArgumentLocInfo
7133 ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
7135 case TemplateArgument::Expression:
7137 case TemplateArgument::Type:
7138 return readTypeSourceInfo();
7139 case TemplateArgument::Template: {
7140 NestedNameSpecifierLoc QualifierLoc =
7141 readNestedNameSpecifierLoc();
7142 SourceLocation TemplateNameLoc = readSourceLocation();
7143 return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
7144 TemplateNameLoc, SourceLocation());
7146 case TemplateArgument::TemplateExpansion: {
7147 NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc();
7148 SourceLocation TemplateNameLoc = readSourceLocation();
7149 SourceLocation EllipsisLoc = readSourceLocation();
7150 return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
7151 TemplateNameLoc, EllipsisLoc);
7153 case TemplateArgument::Null:
7154 case TemplateArgument::Integral:
7155 case TemplateArgument::Declaration:
7156 case TemplateArgument::NullPtr:
7157 case TemplateArgument::Pack:
7158 // FIXME: Is this right?
7159 return TemplateArgumentLocInfo();
7161 llvm_unreachable("unexpected template argument loc");
7164 TemplateArgumentLoc ASTRecordReader::readTemplateArgumentLoc() {
7165 TemplateArgument Arg = readTemplateArgument();
7167 if (Arg.getKind() == TemplateArgument::Expression) {
7168 if (readBool()) // bool InfoHasSameExpr.
7169 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7171 return TemplateArgumentLoc(Arg, readTemplateArgumentLocInfo(Arg.getKind()));
7174 const ASTTemplateArgumentListInfo *
7175 ASTRecordReader::readASTTemplateArgumentListInfo() {
7176 SourceLocation LAngleLoc = readSourceLocation();
7177 SourceLocation RAngleLoc = readSourceLocation();
7178 unsigned NumArgsAsWritten = readInt();
7179 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7180 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7181 TemplArgsInfo.addArgument(readTemplateArgumentLoc());
7182 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7185 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7189 void ASTReader::CompleteRedeclChain(const Decl *D) {
7190 if (NumCurrentElementsDeserializing) {
7191 // We arrange to not care about the complete redeclaration chain while we're
7192 // deserializing. Just remember that the AST has marked this one as complete
7193 // but that it's not actually complete yet, so we know we still need to
7194 // complete it later.
7195 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7199 if (!D->getDeclContext()) {
7200 assert(isa<TranslationUnitDecl>(D) && "Not a TU?");
7204 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7206 // If this is a named declaration, complete it by looking it up
7207 // within its context.
7209 // FIXME: Merging a function definition should merge
7210 // all mergeable entities within it.
7211 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7212 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7213 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7214 if (!getContext().getLangOpts().CPlusPlus &&
7215 isa<TranslationUnitDecl>(DC)) {
7216 // Outside of C++, we don't have a lookup table for the TU, so update
7217 // the identifier instead. (For C++ modules, we don't store decls
7218 // in the serialized identifier table, so we do the lookup in the TU.)
7219 auto *II = Name.getAsIdentifierInfo();
7220 assert(II && "non-identifier name in C?");
7221 if (II->isOutOfDate())
7222 updateOutOfDateIdentifier(*II);
7225 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7226 // Find all declarations of this kind from the relevant context.
7227 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7228 auto *DC = cast<DeclContext>(DCDecl);
7229 SmallVector<Decl*, 8> Decls;
7230 FindExternalLexicalDecls(
7231 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7236 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7237 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7238 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7239 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7240 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7241 if (auto *Template = FD->getPrimaryTemplate())
7242 Template->LoadLazySpecializations();
7246 CXXCtorInitializer **
7247 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7248 RecordLocation Loc = getLocalBitOffset(Offset);
7249 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7250 SavedStreamPosition SavedPosition(Cursor);
7251 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7252 Error(std::move(Err));
7255 ReadingKindTracker ReadingKind(Read_Decl, *this);
7257 Expected<unsigned> MaybeCode = Cursor.ReadCode();
7259 Error(MaybeCode.takeError());
7262 unsigned Code = MaybeCode.get();
7264 ASTRecordReader Record(*this, *Loc.F);
7265 Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7266 if (!MaybeRecCode) {
7267 Error(MaybeRecCode.takeError());
7270 if (MaybeRecCode.get() != DECL_CXX_CTOR_INITIALIZERS) {
7271 Error("malformed AST file: missing C++ ctor initializers");
7275 return Record.readCXXCtorInitializers();
7278 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7279 assert(ContextObj && "reading base specifiers with no AST context");
7280 ASTContext &Context = *ContextObj;
7282 RecordLocation Loc = getLocalBitOffset(Offset);
7283 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7284 SavedStreamPosition SavedPosition(Cursor);
7285 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7286 Error(std::move(Err));
7289 ReadingKindTracker ReadingKind(Read_Decl, *this);
7291 Expected<unsigned> MaybeCode = Cursor.ReadCode();
7293 Error(MaybeCode.takeError());
7296 unsigned Code = MaybeCode.get();
7298 ASTRecordReader Record(*this, *Loc.F);
7299 Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7300 if (!MaybeRecCode) {
7301 Error(MaybeCode.takeError());
7304 unsigned RecCode = MaybeRecCode.get();
7306 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7307 Error("malformed AST file: missing C++ base specifiers");
7311 unsigned NumBases = Record.readInt();
7312 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7313 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7314 for (unsigned I = 0; I != NumBases; ++I)
7315 Bases[I] = Record.readCXXBaseSpecifier();
7319 serialization::DeclID
7320 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7321 if (LocalID < NUM_PREDEF_DECL_IDS)
7324 if (!F.ModuleOffsetMap.empty())
7325 ReadModuleOffsetMap(F);
7327 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7328 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7329 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7331 return LocalID + I->second;
7334 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7335 ModuleFile &M) const {
7336 // Predefined decls aren't from any module.
7337 if (ID < NUM_PREDEF_DECL_IDS)
7340 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7341 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7344 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7345 if (!D->isFromASTFile())
7347 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7348 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7352 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7353 if (ID < NUM_PREDEF_DECL_IDS)
7354 return SourceLocation();
7356 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7358 if (Index > DeclsLoaded.size()) {
7359 Error("declaration ID out-of-range for AST file");
7360 return SourceLocation();
7363 if (Decl *D = DeclsLoaded[Index])
7364 return D->getLocation();
7367 DeclCursorForID(ID, Loc);
7371 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7373 case PREDEF_DECL_NULL_ID:
7376 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7377 return Context.getTranslationUnitDecl();
7379 case PREDEF_DECL_OBJC_ID_ID:
7380 return Context.getObjCIdDecl();
7382 case PREDEF_DECL_OBJC_SEL_ID:
7383 return Context.getObjCSelDecl();
7385 case PREDEF_DECL_OBJC_CLASS_ID:
7386 return Context.getObjCClassDecl();
7388 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7389 return Context.getObjCProtocolDecl();
7391 case PREDEF_DECL_INT_128_ID:
7392 return Context.getInt128Decl();
7394 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7395 return Context.getUInt128Decl();
7397 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7398 return Context.getObjCInstanceTypeDecl();
7400 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7401 return Context.getBuiltinVaListDecl();
7403 case PREDEF_DECL_VA_LIST_TAG:
7404 return Context.getVaListTagDecl();
7406 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7407 return Context.getBuiltinMSVaListDecl();
7409 case PREDEF_DECL_BUILTIN_MS_GUID_ID:
7410 return Context.getMSGuidTagDecl();
7412 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7413 return Context.getExternCContextDecl();
7415 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7416 return Context.getMakeIntegerSeqDecl();
7418 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7419 return Context.getCFConstantStringDecl();
7421 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7422 return Context.getCFConstantStringTagDecl();
7424 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7425 return Context.getTypePackElementDecl();
7427 llvm_unreachable("PredefinedDeclIDs unknown enum value");
7430 Decl *ASTReader::GetExistingDecl(DeclID ID) {
7431 assert(ContextObj && "reading decl with no AST context");
7432 if (ID < NUM_PREDEF_DECL_IDS) {
7433 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7435 // Track that we have merged the declaration with ID \p ID into the
7436 // pre-existing predefined declaration \p D.
7437 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7439 Merged.push_back(ID);
7444 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7446 if (Index >= DeclsLoaded.size()) {
7447 assert(0 && "declaration ID out-of-range for AST file");
7448 Error("declaration ID out-of-range for AST file");
7452 return DeclsLoaded[Index];
7455 Decl *ASTReader::GetDecl(DeclID ID) {
7456 if (ID < NUM_PREDEF_DECL_IDS)
7457 return GetExistingDecl(ID);
7459 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7461 if (Index >= DeclsLoaded.size()) {
7462 assert(0 && "declaration ID out-of-range for AST file");
7463 Error("declaration ID out-of-range for AST file");
7467 if (!DeclsLoaded[Index]) {
7469 if (DeserializationListener)
7470 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7473 return DeclsLoaded[Index];
7476 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7478 if (GlobalID < NUM_PREDEF_DECL_IDS)
7481 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7482 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7483 ModuleFile *Owner = I->second;
7485 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7486 = M.GlobalToLocalDeclIDs.find(Owner);
7487 if (Pos == M.GlobalToLocalDeclIDs.end())
7490 return GlobalID - Owner->BaseDeclID + Pos->second;
7493 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7494 const RecordData &Record,
7496 if (Idx >= Record.size()) {
7497 Error("Corrupted AST file");
7501 return getGlobalDeclID(F, Record[Idx++]);
7504 /// Resolve the offset of a statement into a statement.
7506 /// This operation will read a new statement from the external
7507 /// source each time it is called, and is meant to be used via a
7508 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7509 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7510 // Switch case IDs are per Decl.
7511 ClearSwitchCaseIDs();
7513 // Offset here is a global offset across the entire chain.
7514 RecordLocation Loc = getLocalBitOffset(Offset);
7515 if (llvm::Error Err = Loc.F->DeclsCursor.JumpToBit(Loc.Offset)) {
7516 Error(std::move(Err));
7519 assert(NumCurrentElementsDeserializing == 0 &&
7520 "should not be called while already deserializing");
7521 Deserializing D(this);
7522 return ReadStmtFromStream(*Loc.F);
7525 void ASTReader::FindExternalLexicalDecls(
7526 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7527 SmallVectorImpl<Decl *> &Decls) {
7528 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7530 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7531 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7532 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7533 auto K = (Decl::Kind)+LexicalDecls[I];
7534 if (!IsKindWeWant(K))
7537 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7539 // Don't add predefined declarations to the lexical context more
7541 if (ID < NUM_PREDEF_DECL_IDS) {
7542 if (PredefsVisited[ID])
7545 PredefsVisited[ID] = true;
7548 if (Decl *D = GetLocalDecl(*M, ID)) {
7549 assert(D->getKind() == K && "wrong kind for lexical decl");
7550 if (!DC->isDeclInLexicalTraversal(D))
7556 if (isa<TranslationUnitDecl>(DC)) {
7557 for (auto Lexical : TULexicalDecls)
7558 Visit(Lexical.first, Lexical.second);
7560 auto I = LexicalDecls.find(DC);
7561 if (I != LexicalDecls.end())
7562 Visit(I->second.first, I->second.second);
7565 ++NumLexicalDeclContextsRead;
7575 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7577 bool operator()(LocalDeclID L, LocalDeclID R) const {
7578 SourceLocation LHS = getLocation(L);
7579 SourceLocation RHS = getLocation(R);
7580 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7583 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7584 SourceLocation RHS = getLocation(R);
7585 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7588 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7589 SourceLocation LHS = getLocation(L);
7590 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7593 SourceLocation getLocation(LocalDeclID ID) const {
7594 return Reader.getSourceManager().getFileLoc(
7595 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7601 void ASTReader::FindFileRegionDecls(FileID File,
7602 unsigned Offset, unsigned Length,
7603 SmallVectorImpl<Decl *> &Decls) {
7604 SourceManager &SM = getSourceManager();
7606 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7607 if (I == FileDeclIDs.end())
7610 FileDeclsInfo &DInfo = I->second;
7611 if (DInfo.Decls.empty())
7615 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7616 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7618 DeclIDComp DIDComp(*this, *DInfo.Mod);
7619 ArrayRef<serialization::LocalDeclID>::iterator BeginIt =
7620 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7621 if (BeginIt != DInfo.Decls.begin())
7624 // If we are pointing at a top-level decl inside an objc container, we need
7625 // to backtrack until we find it otherwise we will fail to report that the
7626 // region overlaps with an objc container.
7627 while (BeginIt != DInfo.Decls.begin() &&
7628 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7629 ->isTopLevelDeclInObjCContainer())
7632 ArrayRef<serialization::LocalDeclID>::iterator EndIt =
7633 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7634 if (EndIt != DInfo.Decls.end())
7637 for (ArrayRef<serialization::LocalDeclID>::iterator
7638 DIt = BeginIt; DIt != EndIt; ++DIt)
7639 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7643 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7644 DeclarationName Name) {
7645 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7646 "DeclContext has no visible decls in storage");
7650 auto It = Lookups.find(DC);
7651 if (It == Lookups.end())
7654 Deserializing LookupResults(this);
7656 // Load the list of declarations.
7657 SmallVector<NamedDecl *, 64> Decls;
7658 llvm::SmallPtrSet<NamedDecl *, 8> Found;
7659 for (DeclID ID : It->second.Table.find(Name)) {
7660 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7661 if (ND->getDeclName() == Name && Found.insert(ND).second)
7662 Decls.push_back(ND);
7665 ++NumVisibleDeclContextsRead;
7666 SetExternalVisibleDeclsForName(DC, Name, Decls);
7667 return !Decls.empty();
7670 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7671 if (!DC->hasExternalVisibleStorage())
7674 auto It = Lookups.find(DC);
7675 assert(It != Lookups.end() &&
7676 "have external visible storage but no lookup tables");
7680 for (DeclID ID : It->second.Table.findAll()) {
7681 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7682 Decls[ND->getDeclName()].push_back(ND);
7685 ++NumVisibleDeclContextsRead;
7687 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7688 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7690 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7693 const serialization::reader::DeclContextLookupTable *
7694 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7695 auto I = Lookups.find(Primary);
7696 return I == Lookups.end() ? nullptr : &I->second;
7699 /// Under non-PCH compilation the consumer receives the objc methods
7700 /// before receiving the implementation, and codegen depends on this.
7701 /// We simulate this by deserializing and passing to consumer the methods of the
7702 /// implementation before passing the deserialized implementation decl.
7703 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7704 ASTConsumer *Consumer) {
7705 assert(ImplD && Consumer);
7707 for (auto *I : ImplD->methods())
7708 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7710 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7713 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7714 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7715 PassObjCImplDeclToConsumer(ImplD, Consumer);
7717 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7720 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7721 this->Consumer = Consumer;
7724 PassInterestingDeclsToConsumer();
7726 if (DeserializationListener)
7727 DeserializationListener->ReaderInitialized(this);
7730 void ASTReader::PrintStats() {
7731 std::fprintf(stderr, "*** AST File Statistics:\n");
7733 unsigned NumTypesLoaded
7734 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7736 unsigned NumDeclsLoaded
7737 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7739 unsigned NumIdentifiersLoaded
7740 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7741 IdentifiersLoaded.end(),
7742 (IdentifierInfo *)nullptr);
7743 unsigned NumMacrosLoaded
7744 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7746 (MacroInfo *)nullptr);
7747 unsigned NumSelectorsLoaded
7748 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7749 SelectorsLoaded.end(),
7752 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7753 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7754 NumSLocEntriesRead, TotalNumSLocEntries,
7755 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7756 if (!TypesLoaded.empty())
7757 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7758 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7759 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7760 if (!DeclsLoaded.empty())
7761 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7762 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7763 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7764 if (!IdentifiersLoaded.empty())
7765 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7766 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7767 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7768 if (!MacrosLoaded.empty())
7769 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7770 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7771 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7772 if (!SelectorsLoaded.empty())
7773 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7774 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7775 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7776 if (TotalNumStatements)
7777 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7778 NumStatementsRead, TotalNumStatements,
7779 ((float)NumStatementsRead/TotalNumStatements * 100));
7781 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7782 NumMacrosRead, TotalNumMacros,
7783 ((float)NumMacrosRead/TotalNumMacros * 100));
7784 if (TotalLexicalDeclContexts)
7785 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7786 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7787 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7789 if (TotalVisibleDeclContexts)
7790 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7791 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7792 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7794 if (TotalNumMethodPoolEntries)
7795 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7796 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7797 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7799 if (NumMethodPoolLookups)
7800 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7801 NumMethodPoolHits, NumMethodPoolLookups,
7802 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7803 if (NumMethodPoolTableLookups)
7804 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7805 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7806 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7808 if (NumIdentifierLookupHits)
7809 std::fprintf(stderr,
7810 " %u / %u identifier table lookups succeeded (%f%%)\n",
7811 NumIdentifierLookupHits, NumIdentifierLookups,
7812 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7815 std::fprintf(stderr, "\n");
7816 GlobalIndex->printStats();
7819 std::fprintf(stderr, "\n");
7821 std::fprintf(stderr, "\n");
7824 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7825 LLVM_DUMP_METHOD static void
7826 dumpModuleIDMap(StringRef Name,
7827 const ContinuousRangeMap<Key, ModuleFile *,
7828 InitialCapacity> &Map) {
7829 if (Map.begin() == Map.end())
7832 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7834 llvm::errs() << Name << ":\n";
7835 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7837 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7842 LLVM_DUMP_METHOD void ASTReader::dump() {
7843 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7844 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7845 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7846 dumpModuleIDMap("Global type map", GlobalTypeMap);
7847 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7848 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7849 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7850 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7851 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7852 dumpModuleIDMap("Global preprocessed entity map",
7853 GlobalPreprocessedEntityMap);
7855 llvm::errs() << "\n*** PCH/Modules Loaded:";
7856 for (ModuleFile &M : ModuleMgr)
7860 /// Return the amount of memory used by memory buffers, breaking down
7861 /// by heap-backed versus mmap'ed memory.
7862 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7863 for (ModuleFile &I : ModuleMgr) {
7864 if (llvm::MemoryBuffer *buf = I.Buffer) {
7865 size_t bytes = buf->getBufferSize();
7866 switch (buf->getBufferKind()) {
7867 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7868 sizes.malloc_bytes += bytes;
7870 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7871 sizes.mmap_bytes += bytes;
7878 void ASTReader::InitializeSema(Sema &S) {
7880 S.addExternalSource(this);
7882 // Makes sure any declarations that were deserialized "too early"
7883 // still get added to the identifier's declaration chains.
7884 for (uint64_t ID : PreloadedDeclIDs) {
7885 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7886 pushExternalDeclIntoScope(D, D->getDeclName());
7888 PreloadedDeclIDs.clear();
7890 // FIXME: What happens if these are changed by a module import?
7891 if (!FPPragmaOptions.empty()) {
7892 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7893 FPOptionsOverride NewOverrides =
7894 FPOptionsOverride::getFromOpaqueInt(FPPragmaOptions[0]);
7895 SemaObj->CurFPFeatures =
7896 NewOverrides.applyOverrides(SemaObj->getLangOpts());
7899 SemaObj->OpenCLFeatures = OpenCLExtensions;
7904 void ASTReader::UpdateSema() {
7905 assert(SemaObj && "no Sema to update");
7907 // Load the offsets of the declarations that Sema references.
7908 // They will be lazily deserialized when needed.
7909 if (!SemaDeclRefs.empty()) {
7910 assert(SemaDeclRefs.size() % 3 == 0);
7911 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7912 if (!SemaObj->StdNamespace)
7913 SemaObj->StdNamespace = SemaDeclRefs[I];
7914 if (!SemaObj->StdBadAlloc)
7915 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7916 if (!SemaObj->StdAlignValT)
7917 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7919 SemaDeclRefs.clear();
7922 // Update the state of pragmas. Use the same API as if we had encountered the
7923 // pragma in the source.
7924 if(OptimizeOffPragmaLocation.isValid())
7925 SemaObj->ActOnPragmaOptimize(/* On = */ false, OptimizeOffPragmaLocation);
7926 if (PragmaMSStructState != -1)
7927 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7928 if (PointersToMembersPragmaLocation.isValid()) {
7929 SemaObj->ActOnPragmaMSPointersToMembers(
7930 (LangOptions::PragmaMSPointersToMembersKind)
7931 PragmaMSPointersToMembersState,
7932 PointersToMembersPragmaLocation);
7934 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7936 if (PragmaAlignPackCurrentValue) {
7937 // The bottom of the stack might have a default value. It must be adjusted
7938 // to the current value to ensure that the packing state is preserved after
7939 // popping entries that were included/imported from a PCH/module.
7940 bool DropFirst = false;
7941 if (!PragmaAlignPackStack.empty() &&
7942 PragmaAlignPackStack.front().Location.isInvalid()) {
7943 assert(PragmaAlignPackStack.front().Value ==
7944 SemaObj->AlignPackStack.DefaultValue &&
7945 "Expected a default alignment value");
7946 SemaObj->AlignPackStack.Stack.emplace_back(
7947 PragmaAlignPackStack.front().SlotLabel,
7948 SemaObj->AlignPackStack.CurrentValue,
7949 SemaObj->AlignPackStack.CurrentPragmaLocation,
7950 PragmaAlignPackStack.front().PushLocation);
7953 for (const auto &Entry : llvm::makeArrayRef(PragmaAlignPackStack)
7954 .drop_front(DropFirst ? 1 : 0)) {
7955 SemaObj->AlignPackStack.Stack.emplace_back(
7956 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
7958 if (PragmaAlignPackCurrentLocation.isInvalid()) {
7959 assert(*PragmaAlignPackCurrentValue ==
7960 SemaObj->AlignPackStack.DefaultValue &&
7961 "Expected a default align and pack value");
7962 // Keep the current values.
7964 SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
7965 SemaObj->AlignPackStack.CurrentPragmaLocation =
7966 PragmaAlignPackCurrentLocation;
7969 if (FpPragmaCurrentValue) {
7970 // The bottom of the stack might have a default value. It must be adjusted
7971 // to the current value to ensure that fp-pragma state is preserved after
7972 // popping entries that were included/imported from a PCH/module.
7973 bool DropFirst = false;
7974 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
7975 assert(FpPragmaStack.front().Value ==
7976 SemaObj->FpPragmaStack.DefaultValue &&
7977 "Expected a default pragma float_control value");
7978 SemaObj->FpPragmaStack.Stack.emplace_back(
7979 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
7980 SemaObj->FpPragmaStack.CurrentPragmaLocation,
7981 FpPragmaStack.front().PushLocation);
7984 for (const auto &Entry :
7985 llvm::makeArrayRef(FpPragmaStack).drop_front(DropFirst ? 1 : 0))
7986 SemaObj->FpPragmaStack.Stack.emplace_back(
7987 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
7988 if (FpPragmaCurrentLocation.isInvalid()) {
7989 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
7990 "Expected a default pragma float_control value");
7991 // Keep the current values.
7993 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
7994 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
7998 // For non-modular AST files, restore visiblity of modules.
7999 for (auto &Import : ImportedModules) {
8000 if (Import.ImportLoc.isInvalid())
8002 if (Module *Imported = getSubmodule(Import.ID)) {
8003 SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8008 IdentifierInfo *ASTReader::get(StringRef Name) {
8009 // Note that we are loading an identifier.
8010 Deserializing AnIdentifier(this);
8012 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
8013 NumIdentifierLookups,
8014 NumIdentifierLookupHits);
8016 // We don't need to do identifier table lookups in C++ modules (we preload
8017 // all interesting declarations, and don't need to use the scope for name
8018 // lookups). Perform the lookup in PCH files, though, since we don't build
8019 // a complete initial identifier table if we're carrying on from a PCH.
8020 if (PP.getLangOpts().CPlusPlus) {
8021 for (auto F : ModuleMgr.pch_modules())
8025 // If there is a global index, look there first to determine which modules
8026 // provably do not have any results for this identifier.
8027 GlobalModuleIndex::HitSet Hits;
8028 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
8029 if (!loadGlobalIndex()) {
8030 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8035 ModuleMgr.visit(Visitor, HitsPtr);
8038 IdentifierInfo *II = Visitor.getIdentifierInfo();
8039 markIdentifierUpToDate(II);
8045 /// An identifier-lookup iterator that enumerates all of the
8046 /// identifiers stored within a set of AST files.
8047 class ASTIdentifierIterator : public IdentifierIterator {
8048 /// The AST reader whose identifiers are being enumerated.
8049 const ASTReader &Reader;
8051 /// The current index into the chain of AST files stored in
8055 /// The current position within the identifier lookup table
8056 /// of the current AST file.
8057 ASTIdentifierLookupTable::key_iterator Current;
8059 /// The end position within the identifier lookup table of
8060 /// the current AST file.
8061 ASTIdentifierLookupTable::key_iterator End;
8063 /// Whether to skip any modules in the ASTReader.
8067 explicit ASTIdentifierIterator(const ASTReader &Reader,
8068 bool SkipModules = false);
8070 StringRef Next() override;
8073 } // namespace clang
8075 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
8077 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8080 StringRef ASTIdentifierIterator::Next() {
8081 while (Current == End) {
8082 // If we have exhausted all of our AST files, we're done.
8087 ModuleFile &F = Reader.ModuleMgr[Index];
8088 if (SkipModules && F.isModule())
8091 ASTIdentifierLookupTable *IdTable =
8092 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
8093 Current = IdTable->key_begin();
8094 End = IdTable->key_end();
8097 // We have any identifiers remaining in the current AST file; return
8099 StringRef Result = *Current;
8106 /// A utility for appending two IdentifierIterators.
8107 class ChainedIdentifierIterator : public IdentifierIterator {
8108 std::unique_ptr<IdentifierIterator> Current;
8109 std::unique_ptr<IdentifierIterator> Queued;
8112 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
8113 std::unique_ptr<IdentifierIterator> Second)
8114 : Current(std::move(First)), Queued(std::move(Second)) {}
8116 StringRef Next() override {
8120 StringRef result = Current->Next();
8121 if (!result.empty())
8124 // Try the queued iterator, which may itself be empty.
8126 std::swap(Current, Queued);
8133 IdentifierIterator *ASTReader::getIdentifiers() {
8134 if (!loadGlobalIndex()) {
8135 std::unique_ptr<IdentifierIterator> ReaderIter(
8136 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
8137 std::unique_ptr<IdentifierIterator> ModulesIter(
8138 GlobalIndex->createIdentifierIterator());
8139 return new ChainedIdentifierIterator(std::move(ReaderIter),
8140 std::move(ModulesIter));
8143 return new ASTIdentifierIterator(*this);
8147 namespace serialization {
8149 class ReadMethodPoolVisitor {
8152 unsigned PriorGeneration;
8153 unsigned InstanceBits = 0;
8154 unsigned FactoryBits = 0;
8155 bool InstanceHasMoreThanOneDecl = false;
8156 bool FactoryHasMoreThanOneDecl = false;
8157 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8158 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8161 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8162 unsigned PriorGeneration)
8163 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8165 bool operator()(ModuleFile &M) {
8166 if (!M.SelectorLookupTable)
8169 // If we've already searched this module file, skip it now.
8170 if (M.Generation <= PriorGeneration)
8173 ++Reader.NumMethodPoolTableLookups;
8174 ASTSelectorLookupTable *PoolTable
8175 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8176 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8177 if (Pos == PoolTable->end())
8180 ++Reader.NumMethodPoolTableHits;
8181 ++Reader.NumSelectorsRead;
8182 // FIXME: Not quite happy with the statistics here. We probably should
8183 // disable this tracking when called via LoadSelector.
8184 // Also, should entries without methods count as misses?
8185 ++Reader.NumMethodPoolEntriesRead;
8186 ASTSelectorLookupTrait::data_type Data = *Pos;
8187 if (Reader.DeserializationListener)
8188 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8190 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8191 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8192 InstanceBits = Data.InstanceBits;
8193 FactoryBits = Data.FactoryBits;
8194 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8195 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8199 /// Retrieve the instance methods found by this visitor.
8200 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8201 return InstanceMethods;
8204 /// Retrieve the instance methods found by this visitor.
8205 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8206 return FactoryMethods;
8209 unsigned getInstanceBits() const { return InstanceBits; }
8210 unsigned getFactoryBits() const { return FactoryBits; }
8212 bool instanceHasMoreThanOneDecl() const {
8213 return InstanceHasMoreThanOneDecl;
8216 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8219 } // namespace serialization
8220 } // namespace clang
8222 /// Add the given set of methods to the method list.
8223 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8224 ObjCMethodList &List) {
8225 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8226 S.addMethodToGlobalList(&List, Methods[I]);
8230 void ASTReader::ReadMethodPool(Selector Sel) {
8231 // Get the selector generation and update it to the current generation.
8232 unsigned &Generation = SelectorGeneration[Sel];
8233 unsigned PriorGeneration = Generation;
8234 Generation = getGeneration();
8235 SelectorOutOfDate[Sel] = false;
8237 // Search for methods defined with this selector.
8238 ++NumMethodPoolLookups;
8239 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8240 ModuleMgr.visit(Visitor);
8242 if (Visitor.getInstanceMethods().empty() &&
8243 Visitor.getFactoryMethods().empty())
8246 ++NumMethodPoolHits;
8251 Sema &S = *getSema();
8252 Sema::GlobalMethodPool::iterator Pos
8253 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8255 Pos->second.first.setBits(Visitor.getInstanceBits());
8256 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8257 Pos->second.second.setBits(Visitor.getFactoryBits());
8258 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8260 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8261 // when building a module we keep every method individually and may need to
8262 // update hasMoreThanOneDecl as we add the methods.
8263 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8264 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8267 void ASTReader::updateOutOfDateSelector(Selector Sel) {
8268 if (SelectorOutOfDate[Sel])
8269 ReadMethodPool(Sel);
8272 void ASTReader::ReadKnownNamespaces(
8273 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8276 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8277 if (NamespaceDecl *Namespace
8278 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8279 Namespaces.push_back(Namespace);
8283 void ASTReader::ReadUndefinedButUsed(
8284 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8285 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8286 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8287 SourceLocation Loc =
8288 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8289 Undefined.insert(std::make_pair(D, Loc));
8293 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8294 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8296 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8297 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8298 uint64_t Count = DelayedDeleteExprs[Idx++];
8299 for (uint64_t C = 0; C < Count; ++C) {
8300 SourceLocation DeleteLoc =
8301 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8302 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8303 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8308 void ASTReader::ReadTentativeDefinitions(
8309 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8310 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8311 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8313 TentativeDefs.push_back(Var);
8315 TentativeDefinitions.clear();
8318 void ASTReader::ReadUnusedFileScopedDecls(
8319 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8320 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8322 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8326 UnusedFileScopedDecls.clear();
8329 void ASTReader::ReadDelegatingConstructors(
8330 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8331 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8332 CXXConstructorDecl *D
8333 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8337 DelegatingCtorDecls.clear();
8340 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8341 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8343 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8347 ExtVectorDecls.clear();
8350 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8351 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8352 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8354 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8355 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8359 UnusedLocalTypedefNameCandidates.clear();
8362 void ASTReader::ReadDeclsToCheckForDeferredDiags(
8363 llvm::SmallSetVector<Decl *, 4> &Decls) {
8364 for (auto I : DeclsToCheckForDeferredDiags) {
8365 auto *D = dyn_cast_or_null<Decl>(GetDecl(I));
8369 DeclsToCheckForDeferredDiags.clear();
8372 void ASTReader::ReadReferencedSelectors(
8373 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8374 if (ReferencedSelectorsData.empty())
8377 // If there are @selector references added them to its pool. This is for
8378 // implementation of -Wselector.
8379 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8381 while (I < DataSize) {
8382 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8383 SourceLocation SelLoc
8384 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8385 Sels.push_back(std::make_pair(Sel, SelLoc));
8387 ReferencedSelectorsData.clear();
8390 void ASTReader::ReadWeakUndeclaredIdentifiers(
8391 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8392 if (WeakUndeclaredIdentifiers.empty())
8395 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8396 IdentifierInfo *WeakId
8397 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8398 IdentifierInfo *AliasId
8399 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8401 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8402 bool Used = WeakUndeclaredIdentifiers[I++];
8403 WeakInfo WI(AliasId, Loc);
8405 WeakIDs.push_back(std::make_pair(WeakId, WI));
8407 WeakUndeclaredIdentifiers.clear();
8410 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8411 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8412 ExternalVTableUse VT;
8413 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8414 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8415 VT.DefinitionRequired = VTableUses[Idx++];
8416 VTables.push_back(VT);
8422 void ASTReader::ReadPendingInstantiations(
8423 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8424 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8425 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8427 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8429 Pending.push_back(std::make_pair(D, Loc));
8431 PendingInstantiations.clear();
8434 void ASTReader::ReadLateParsedTemplates(
8435 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8437 for (auto &LPT : LateParsedTemplates) {
8438 ModuleFile *FMod = LPT.first;
8439 RecordDataImpl &LateParsed = LPT.second;
8440 for (unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8443 cast<FunctionDecl>(GetLocalDecl(*FMod, LateParsed[Idx++]));
8445 auto LT = std::make_unique<LateParsedTemplate>();
8446 LT->D = GetLocalDecl(*FMod, LateParsed[Idx++]);
8448 ModuleFile *F = getOwningModuleFile(LT->D);
8449 assert(F && "No module");
8451 unsigned TokN = LateParsed[Idx++];
8452 LT->Toks.reserve(TokN);
8453 for (unsigned T = 0; T < TokN; ++T)
8454 LT->Toks.push_back(ReadToken(*F, LateParsed, Idx));
8456 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8460 LateParsedTemplates.clear();
8463 void ASTReader::LoadSelector(Selector Sel) {
8464 // It would be complicated to avoid reading the methods anyway. So don't.
8465 ReadMethodPool(Sel);
8468 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8469 assert(ID && "Non-zero identifier ID required");
8470 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8471 IdentifiersLoaded[ID - 1] = II;
8472 if (DeserializationListener)
8473 DeserializationListener->IdentifierRead(ID, II);
8476 /// Set the globally-visible declarations associated with the given
8479 /// If the AST reader is currently in a state where the given declaration IDs
8480 /// cannot safely be resolved, they are queued until it is safe to resolve
8483 /// \param II an IdentifierInfo that refers to one or more globally-visible
8486 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8487 /// visible at global scope.
8489 /// \param Decls if non-null, this vector will be populated with the set of
8490 /// deserialized declarations. These declarations will not be pushed into
8493 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8494 const SmallVectorImpl<uint32_t> &DeclIDs,
8495 SmallVectorImpl<Decl *> *Decls) {
8496 if (NumCurrentElementsDeserializing && !Decls) {
8497 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8501 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8503 // Queue this declaration so that it will be added to the
8504 // translation unit scope and identifier's declaration chain
8505 // once a Sema object is known.
8506 PreloadedDeclIDs.push_back(DeclIDs[I]);
8510 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8512 // If we're simply supposed to record the declarations, do so now.
8514 Decls->push_back(D);
8518 // Introduce this declaration into the translation-unit scope
8519 // and add it to the declaration chain for this identifier, so
8520 // that (unqualified) name lookup will find it.
8521 pushExternalDeclIntoScope(D, II);
8525 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8529 if (IdentifiersLoaded.empty()) {
8530 Error("no identifier table in AST file");
8535 if (!IdentifiersLoaded[ID]) {
8536 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8537 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8538 ModuleFile *M = I->second;
8539 unsigned Index = ID - M->BaseIdentifierID;
8540 const unsigned char *Data =
8541 M->IdentifierTableData + M->IdentifierOffsets[Index];
8543 ASTIdentifierLookupTrait Trait(*this, *M);
8544 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
8545 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
8546 auto &II = PP.getIdentifierTable().get(Key);
8547 IdentifiersLoaded[ID] = &II;
8548 markIdentifierFromAST(*this, II);
8549 if (DeserializationListener)
8550 DeserializationListener->IdentifierRead(ID + 1, &II);
8553 return IdentifiersLoaded[ID];
8556 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8557 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8560 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8561 if (LocalID < NUM_PREDEF_IDENT_IDS)
8564 if (!M.ModuleOffsetMap.empty())
8565 ReadModuleOffsetMap(M);
8567 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8568 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8569 assert(I != M.IdentifierRemap.end()
8570 && "Invalid index into identifier index remap");
8572 return LocalID + I->second;
8575 MacroInfo *ASTReader::getMacro(MacroID ID) {
8579 if (MacrosLoaded.empty()) {
8580 Error("no macro table in AST file");
8584 ID -= NUM_PREDEF_MACRO_IDS;
8585 if (!MacrosLoaded[ID]) {
8586 GlobalMacroMapType::iterator I
8587 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8588 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8589 ModuleFile *M = I->second;
8590 unsigned Index = ID - M->BaseMacroID;
8592 ReadMacroRecord(*M, M->MacroOffsetsBase + M->MacroOffsets[Index]);
8594 if (DeserializationListener)
8595 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8599 return MacrosLoaded[ID];
8602 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8603 if (LocalID < NUM_PREDEF_MACRO_IDS)
8606 if (!M.ModuleOffsetMap.empty())
8607 ReadModuleOffsetMap(M);
8609 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8610 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8611 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8613 return LocalID + I->second;
8616 serialization::SubmoduleID
8617 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8618 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8621 if (!M.ModuleOffsetMap.empty())
8622 ReadModuleOffsetMap(M);
8624 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8625 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8626 assert(I != M.SubmoduleRemap.end()
8627 && "Invalid index into submodule index remap");
8629 return LocalID + I->second;
8632 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8633 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8634 assert(GlobalID == 0 && "Unhandled global submodule ID");
8638 if (GlobalID > SubmodulesLoaded.size()) {
8639 Error("submodule ID out of range in AST file");
8643 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8646 Module *ASTReader::getModule(unsigned ID) {
8647 return getSubmodule(ID);
8650 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8652 // It's a module, look it up by submodule ID.
8653 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8654 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8656 // It's a prefix (preamble, PCH, ...). Look it up by index.
8657 unsigned IndexFromEnd = ID >> 1;
8658 assert(IndexFromEnd && "got reference to unknown module file");
8659 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8663 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8667 // For a file representing a module, use the submodule ID of the top-level
8668 // module as the file ID. For any other kind of file, the number of such
8669 // files loaded beforehand will be the same on reload.
8670 // FIXME: Is this true even if we have an explicit module file and a PCH?
8672 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8674 auto PCHModules = getModuleManager().pch_modules();
8675 auto I = llvm::find(PCHModules, F);
8676 assert(I != PCHModules.end() && "emitting reference to unknown file");
8677 return (I - PCHModules.end()) << 1;
8680 llvm::Optional<ASTSourceDescriptor>
8681 ASTReader::getSourceDescriptor(unsigned ID) {
8682 if (Module *M = getSubmodule(ID))
8683 return ASTSourceDescriptor(*M);
8685 // If there is only a single PCH, return it instead.
8686 // Chained PCH are not supported.
8687 const auto &PCHChain = ModuleMgr.pch_modules();
8688 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8689 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8690 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8691 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8692 return ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8698 ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8699 auto I = DefinitionSource.find(FD);
8700 if (I == DefinitionSource.end())
8701 return EK_ReplyHazy;
8702 return I->second ? EK_Never : EK_Always;
8705 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8706 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8709 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8713 if (ID > SelectorsLoaded.size()) {
8714 Error("selector ID out of range in AST file");
8718 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8719 // Load this selector from the selector table.
8720 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8721 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8722 ModuleFile &M = *I->second;
8723 ASTSelectorLookupTrait Trait(*this, M);
8724 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8725 SelectorsLoaded[ID - 1] =
8726 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8727 if (DeserializationListener)
8728 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8731 return SelectorsLoaded[ID - 1];
8734 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8735 return DecodeSelector(ID);
8738 uint32_t ASTReader::GetNumExternalSelectors() {
8739 // ID 0 (the null selector) is considered an external selector.
8740 return getTotalNumSelectors() + 1;
8743 serialization::SelectorID
8744 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8745 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8748 if (!M.ModuleOffsetMap.empty())
8749 ReadModuleOffsetMap(M);
8751 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8752 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8753 assert(I != M.SelectorRemap.end()
8754 && "Invalid index into selector index remap");
8756 return LocalID + I->second;
8760 ASTRecordReader::readDeclarationNameLoc(DeclarationName Name) {
8761 switch (Name.getNameKind()) {
8762 case DeclarationName::CXXConstructorName:
8763 case DeclarationName::CXXDestructorName:
8764 case DeclarationName::CXXConversionFunctionName:
8765 return DeclarationNameLoc::makeNamedTypeLoc(readTypeSourceInfo());
8767 case DeclarationName::CXXOperatorName:
8768 return DeclarationNameLoc::makeCXXOperatorNameLoc(readSourceRange());
8770 case DeclarationName::CXXLiteralOperatorName:
8771 return DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(
8772 readSourceLocation());
8774 case DeclarationName::Identifier:
8775 case DeclarationName::ObjCZeroArgSelector:
8776 case DeclarationName::ObjCOneArgSelector:
8777 case DeclarationName::ObjCMultiArgSelector:
8778 case DeclarationName::CXXUsingDirective:
8779 case DeclarationName::CXXDeductionGuideName:
8782 return DeclarationNameLoc();
8785 DeclarationNameInfo ASTRecordReader::readDeclarationNameInfo() {
8786 DeclarationNameInfo NameInfo;
8787 NameInfo.setName(readDeclarationName());
8788 NameInfo.setLoc(readSourceLocation());
8789 NameInfo.setInfo(readDeclarationNameLoc(NameInfo.getName()));
8793 void ASTRecordReader::readQualifierInfo(QualifierInfo &Info) {
8794 Info.QualifierLoc = readNestedNameSpecifierLoc();
8795 unsigned NumTPLists = readInt();
8796 Info.NumTemplParamLists = NumTPLists;
8798 Info.TemplParamLists =
8799 new (getContext()) TemplateParameterList *[NumTPLists];
8800 for (unsigned i = 0; i != NumTPLists; ++i)
8801 Info.TemplParamLists[i] = readTemplateParameterList();
8805 TemplateParameterList *
8806 ASTRecordReader::readTemplateParameterList() {
8807 SourceLocation TemplateLoc = readSourceLocation();
8808 SourceLocation LAngleLoc = readSourceLocation();
8809 SourceLocation RAngleLoc = readSourceLocation();
8811 unsigned NumParams = readInt();
8812 SmallVector<NamedDecl *, 16> Params;
8813 Params.reserve(NumParams);
8815 Params.push_back(readDeclAs<NamedDecl>());
8817 bool HasRequiresClause = readBool();
8818 Expr *RequiresClause = HasRequiresClause ? readExpr() : nullptr;
8820 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8821 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
8822 return TemplateParams;
8825 void ASTRecordReader::readTemplateArgumentList(
8826 SmallVectorImpl<TemplateArgument> &TemplArgs,
8827 bool Canonicalize) {
8828 unsigned NumTemplateArgs = readInt();
8829 TemplArgs.reserve(NumTemplateArgs);
8830 while (NumTemplateArgs--)
8831 TemplArgs.push_back(readTemplateArgument(Canonicalize));
8834 /// Read a UnresolvedSet structure.
8835 void ASTRecordReader::readUnresolvedSet(LazyASTUnresolvedSet &Set) {
8836 unsigned NumDecls = readInt();
8837 Set.reserve(getContext(), NumDecls);
8838 while (NumDecls--) {
8839 DeclID ID = readDeclID();
8840 AccessSpecifier AS = (AccessSpecifier) readInt();
8841 Set.addLazyDecl(getContext(), ID, AS);
8846 ASTRecordReader::readCXXBaseSpecifier() {
8847 bool isVirtual = readBool();
8848 bool isBaseOfClass = readBool();
8849 AccessSpecifier AS = static_cast<AccessSpecifier>(readInt());
8850 bool inheritConstructors = readBool();
8851 TypeSourceInfo *TInfo = readTypeSourceInfo();
8852 SourceRange Range = readSourceRange();
8853 SourceLocation EllipsisLoc = readSourceLocation();
8854 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8856 Result.setInheritConstructors(inheritConstructors);
8860 CXXCtorInitializer **
8861 ASTRecordReader::readCXXCtorInitializers() {
8862 ASTContext &Context = getContext();
8863 unsigned NumInitializers = readInt();
8864 assert(NumInitializers && "wrote ctor initializers but have no inits");
8865 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8866 for (unsigned i = 0; i != NumInitializers; ++i) {
8867 TypeSourceInfo *TInfo = nullptr;
8868 bool IsBaseVirtual = false;
8869 FieldDecl *Member = nullptr;
8870 IndirectFieldDecl *IndirectMember = nullptr;
8872 CtorInitializerType Type = (CtorInitializerType) readInt();
8874 case CTOR_INITIALIZER_BASE:
8875 TInfo = readTypeSourceInfo();
8876 IsBaseVirtual = readBool();
8879 case CTOR_INITIALIZER_DELEGATING:
8880 TInfo = readTypeSourceInfo();
8883 case CTOR_INITIALIZER_MEMBER:
8884 Member = readDeclAs<FieldDecl>();
8887 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8888 IndirectMember = readDeclAs<IndirectFieldDecl>();
8892 SourceLocation MemberOrEllipsisLoc = readSourceLocation();
8893 Expr *Init = readExpr();
8894 SourceLocation LParenLoc = readSourceLocation();
8895 SourceLocation RParenLoc = readSourceLocation();
8897 CXXCtorInitializer *BOMInit;
8898 if (Type == CTOR_INITIALIZER_BASE)
8899 BOMInit = new (Context)
8900 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8901 RParenLoc, MemberOrEllipsisLoc);
8902 else if (Type == CTOR_INITIALIZER_DELEGATING)
8903 BOMInit = new (Context)
8904 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8906 BOMInit = new (Context)
8907 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8910 BOMInit = new (Context)
8911 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8912 LParenLoc, Init, RParenLoc);
8914 if (/*IsWritten*/readBool()) {
8915 unsigned SourceOrder = readInt();
8916 BOMInit->setSourceOrder(SourceOrder);
8919 CtorInitializers[i] = BOMInit;
8922 return CtorInitializers;
8925 NestedNameSpecifierLoc
8926 ASTRecordReader::readNestedNameSpecifierLoc() {
8927 ASTContext &Context = getContext();
8928 unsigned N = readInt();
8929 NestedNameSpecifierLocBuilder Builder;
8930 for (unsigned I = 0; I != N; ++I) {
8931 auto Kind = readNestedNameSpecifierKind();
8933 case NestedNameSpecifier::Identifier: {
8934 IdentifierInfo *II = readIdentifier();
8935 SourceRange Range = readSourceRange();
8936 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8940 case NestedNameSpecifier::Namespace: {
8941 NamespaceDecl *NS = readDeclAs<NamespaceDecl>();
8942 SourceRange Range = readSourceRange();
8943 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8947 case NestedNameSpecifier::NamespaceAlias: {
8948 NamespaceAliasDecl *Alias = readDeclAs<NamespaceAliasDecl>();
8949 SourceRange Range = readSourceRange();
8950 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8954 case NestedNameSpecifier::TypeSpec:
8955 case NestedNameSpecifier::TypeSpecWithTemplate: {
8956 bool Template = readBool();
8957 TypeSourceInfo *T = readTypeSourceInfo();
8959 return NestedNameSpecifierLoc();
8960 SourceLocation ColonColonLoc = readSourceLocation();
8962 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8963 Builder.Extend(Context,
8964 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8965 T->getTypeLoc(), ColonColonLoc);
8969 case NestedNameSpecifier::Global: {
8970 SourceLocation ColonColonLoc = readSourceLocation();
8971 Builder.MakeGlobal(Context, ColonColonLoc);
8975 case NestedNameSpecifier::Super: {
8976 CXXRecordDecl *RD = readDeclAs<CXXRecordDecl>();
8977 SourceRange Range = readSourceRange();
8978 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8984 return Builder.getWithLocInContext(Context);
8988 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8990 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8991 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8992 return SourceRange(beg, end);
8995 /// Read a floating-point value
8996 llvm::APFloat ASTRecordReader::readAPFloat(const llvm::fltSemantics &Sem) {
8997 return llvm::APFloat(Sem, readAPInt());
9001 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9002 unsigned Len = Record[Idx++];
9003 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9008 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9010 std::string Filename = ReadString(Record, Idx);
9011 ResolveImportedPath(F, Filename);
9015 std::string ASTReader::ReadPath(StringRef BaseDirectory,
9016 const RecordData &Record, unsigned &Idx) {
9017 std::string Filename = ReadString(Record, Idx);
9018 if (!BaseDirectory.empty())
9019 ResolveImportedPath(Filename, BaseDirectory);
9023 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9025 unsigned Major = Record[Idx++];
9026 unsigned Minor = Record[Idx++];
9027 unsigned Subminor = Record[Idx++];
9029 return VersionTuple(Major);
9031 return VersionTuple(Major, Minor - 1);
9032 return VersionTuple(Major, Minor - 1, Subminor - 1);
9035 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9036 const RecordData &Record,
9038 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9039 return CXXTemporary::Create(getContext(), Decl);
9042 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9043 return Diag(CurrentImportLoc, DiagID);
9046 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9047 return Diags.Report(Loc, DiagID);
9050 /// Retrieve the identifier table associated with the
9052 IdentifierTable &ASTReader::getIdentifierTable() {
9053 return PP.getIdentifierTable();
9056 /// Record that the given ID maps to the given switch-case
9058 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9059 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9060 "Already have a SwitchCase with this ID");
9061 (*CurrSwitchCaseStmts)[ID] = SC;
9064 /// Retrieve the switch-case statement with the given ID.
9065 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9066 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9067 return (*CurrSwitchCaseStmts)[ID];
9070 void ASTReader::ClearSwitchCaseIDs() {
9071 CurrSwitchCaseStmts->clear();
9074 void ASTReader::ReadComments() {
9075 ASTContext &Context = getContext();
9076 std::vector<RawComment *> Comments;
9077 for (SmallVectorImpl<std::pair<BitstreamCursor,
9078 serialization::ModuleFile *>>::iterator
9079 I = CommentsCursors.begin(),
9080 E = CommentsCursors.end();
9083 BitstreamCursor &Cursor = I->first;
9084 serialization::ModuleFile &F = *I->second;
9085 SavedStreamPosition SavedPosition(Cursor);
9089 Expected<llvm::BitstreamEntry> MaybeEntry =
9090 Cursor.advanceSkippingSubblocks(
9091 BitstreamCursor::AF_DontPopBlockAtEnd);
9093 Error(MaybeEntry.takeError());
9096 llvm::BitstreamEntry Entry = MaybeEntry.get();
9098 switch (Entry.Kind) {
9099 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9100 case llvm::BitstreamEntry::Error:
9101 Error("malformed block record in AST file");
9103 case llvm::BitstreamEntry::EndBlock:
9105 case llvm::BitstreamEntry::Record:
9106 // The interesting case.
9112 Expected<unsigned> MaybeComment = Cursor.readRecord(Entry.ID, Record);
9113 if (!MaybeComment) {
9114 Error(MaybeComment.takeError());
9117 switch ((CommentRecordTypes)MaybeComment.get()) {
9118 case COMMENTS_RAW_COMMENT: {
9120 SourceRange SR = ReadSourceRange(F, Record, Idx);
9121 RawComment::CommentKind Kind =
9122 (RawComment::CommentKind) Record[Idx++];
9123 bool IsTrailingComment = Record[Idx++];
9124 bool IsAlmostTrailingComment = Record[Idx++];
9125 Comments.push_back(new (Context) RawComment(
9126 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9132 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9133 FileToOffsetToComment;
9134 for (RawComment *C : Comments) {
9135 SourceLocation CommentLoc = C->getBeginLoc();
9136 if (CommentLoc.isValid()) {
9137 std::pair<FileID, unsigned> Loc =
9138 SourceMgr.getDecomposedLoc(CommentLoc);
9139 if (Loc.first.isValid())
9140 Context.Comments.OrderedComments[Loc.first].emplace(Loc.second, C);
9146 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9147 bool IncludeSystem, bool Complain,
9148 llvm::function_ref<void(const serialization::InputFile &IF,
9149 bool isSystem)> Visitor) {
9150 unsigned NumUserInputs = MF.NumUserInputFiles;
9151 unsigned NumInputs = MF.InputFilesLoaded.size();
9152 assert(NumUserInputs <= NumInputs);
9153 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9154 for (unsigned I = 0; I < N; ++I) {
9155 bool IsSystem = I >= NumUserInputs;
9156 InputFile IF = getInputFile(MF, I+1, Complain);
9157 Visitor(IF, IsSystem);
9161 void ASTReader::visitTopLevelModuleMaps(
9162 serialization::ModuleFile &MF,
9163 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9164 unsigned NumInputs = MF.InputFilesLoaded.size();
9165 for (unsigned I = 0; I < NumInputs; ++I) {
9166 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9167 if (IFI.TopLevelModuleMap)
9168 // FIXME: This unnecessarily re-reads the InputFileInfo.
9169 if (auto FE = getInputFile(MF, I + 1).getFile())
9174 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9175 // If we know the owning module, use it.
9176 if (Module *M = D->getImportedOwningModule())
9177 return M->getFullModuleName();
9179 // Otherwise, use the name of the top-level module the decl is within.
9180 if (ModuleFile *M = getOwningModuleFile(D))
9181 return M->ModuleName;
9183 // Not from a module.
9187 void ASTReader::finishPendingActions() {
9188 while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
9189 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9190 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9191 !PendingUpdateRecords.empty()) {
9192 // If any identifiers with corresponding top-level declarations have
9193 // been loaded, load those declarations now.
9194 using TopLevelDeclsMap =
9195 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9196 TopLevelDeclsMap TopLevelDecls;
9198 while (!PendingIdentifierInfos.empty()) {
9199 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9200 SmallVector<uint32_t, 4> DeclIDs =
9201 std::move(PendingIdentifierInfos.back().second);
9202 PendingIdentifierInfos.pop_back();
9204 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9207 // Load each function type that we deferred loading because it was a
9208 // deduced type that might refer to a local type declared within itself.
9209 for (unsigned I = 0; I != PendingFunctionTypes.size(); ++I) {
9210 auto *FD = PendingFunctionTypes[I].first;
9211 FD->setType(GetType(PendingFunctionTypes[I].second));
9213 // If we gave a function a deduced return type, remember that we need to
9214 // propagate that along the redeclaration chain.
9215 auto *DT = FD->getReturnType()->getContainedDeducedType();
9216 if (DT && DT->isDeduced())
9217 PendingDeducedTypeUpdates.insert(
9218 {FD->getCanonicalDecl(), FD->getReturnType()});
9220 PendingFunctionTypes.clear();
9222 // For each decl chain that we wanted to complete while deserializing, mark
9223 // it as "still needs to be completed".
9224 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9225 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9227 PendingIncompleteDeclChains.clear();
9229 // Load pending declaration chains.
9230 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9231 loadPendingDeclChain(PendingDeclChains[I].first,
9232 PendingDeclChains[I].second);
9233 PendingDeclChains.clear();
9235 // Make the most recent of the top-level declarations visible.
9236 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9237 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9238 IdentifierInfo *II = TLD->first;
9239 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9240 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9244 // Load any pending macro definitions.
9245 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9246 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9247 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9248 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9249 // Initialize the macro history from chained-PCHs ahead of module imports.
9250 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9252 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9253 if (!Info.M->isModule())
9254 resolvePendingMacro(II, Info);
9256 // Handle module imports.
9257 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9259 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9260 if (Info.M->isModule())
9261 resolvePendingMacro(II, Info);
9264 PendingMacroIDs.clear();
9266 // Wire up the DeclContexts for Decls that we delayed setting until
9267 // recursive loading is completed.
9268 while (!PendingDeclContextInfos.empty()) {
9269 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9270 PendingDeclContextInfos.pop_front();
9271 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9272 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9273 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9276 // Perform any pending declaration updates.
9277 while (!PendingUpdateRecords.empty()) {
9278 auto Update = PendingUpdateRecords.pop_back_val();
9279 ReadingKindTracker ReadingKind(Read_Decl, *this);
9280 loadDeclUpdateRecords(Update);
9284 // At this point, all update records for loaded decls are in place, so any
9285 // fake class definitions should have become real.
9286 assert(PendingFakeDefinitionData.empty() &&
9287 "faked up a class definition but never saw the real one");
9289 // If we deserialized any C++ or Objective-C class definitions, any
9290 // Objective-C protocol definitions, or any redeclarable templates, make sure
9291 // that all redeclarations point to the definitions. Note that this can only
9292 // happen now, after the redeclaration chains have been fully wired.
9293 for (Decl *D : PendingDefinitions) {
9294 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9295 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9296 // Make sure that the TagType points at the definition.
9297 const_cast<TagType*>(TagT)->decl = TD;
9300 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9301 for (auto *R = getMostRecentExistingDecl(RD); R;
9302 R = R->getPreviousDecl()) {
9304 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9305 "declaration thinks it's the definition but it isn't");
9306 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9313 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9314 // Make sure that the ObjCInterfaceType points at the definition.
9315 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9318 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9319 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9324 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9325 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9326 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9331 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9332 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9333 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9335 PendingDefinitions.clear();
9337 // Load the bodies of any functions or methods we've encountered. We do
9338 // this now (delayed) so that we can be sure that the declaration chains
9339 // have been fully wired up (hasBody relies on this).
9340 // FIXME: We shouldn't require complete redeclaration chains here.
9341 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9342 PBEnd = PendingBodies.end();
9343 PB != PBEnd; ++PB) {
9344 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9345 // For a function defined inline within a class template, force the
9346 // canonical definition to be the one inside the canonical definition of
9347 // the template. This ensures that we instantiate from a correct view
9350 // Sadly we can't do this more generally: we can't be sure that all
9351 // copies of an arbitrary class definition will have the same members
9352 // defined (eg, some member functions may not be instantiated, and some
9353 // special members may or may not have been implicitly defined).
9354 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9355 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9358 // FIXME: Check for =delete/=default?
9359 // FIXME: Complain about ODR violations here?
9360 const FunctionDecl *Defn = nullptr;
9361 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9362 FD->setLazyBody(PB->second);
9364 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9365 mergeDefinitionVisibility(NonConstDefn, FD);
9367 if (!FD->isLateTemplateParsed() &&
9368 !NonConstDefn->isLateTemplateParsed() &&
9369 FD->getODRHash() != NonConstDefn->getODRHash()) {
9370 if (!isa<CXXMethodDecl>(FD)) {
9371 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9372 } else if (FD->getLexicalParent()->isFileContext() &&
9373 NonConstDefn->getLexicalParent()->isFileContext()) {
9374 // Only diagnose out-of-line method definitions. If they are
9375 // in class definitions, then an error will be generated when
9376 // processing the class bodies.
9377 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9384 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9385 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9386 MD->setLazyBody(PB->second);
9388 PendingBodies.clear();
9391 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9392 getContext().deduplicateMergedDefinitonsFor(ND);
9393 PendingMergedDefinitionsToDeduplicate.clear();
9396 void ASTReader::diagnoseOdrViolations() {
9397 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9398 PendingFunctionOdrMergeFailures.empty() &&
9399 PendingEnumOdrMergeFailures.empty())
9402 // Trigger the import of the full definition of each class that had any
9403 // odr-merging problems, so we can produce better diagnostics for them.
9404 // These updates may in turn find and diagnose some ODR failures, so take
9405 // ownership of the set first.
9406 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9407 PendingOdrMergeFailures.clear();
9408 for (auto &Merge : OdrMergeFailures) {
9409 Merge.first->buildLookup();
9410 Merge.first->decls_begin();
9411 Merge.first->bases_begin();
9412 Merge.first->vbases_begin();
9413 for (auto &RecordPair : Merge.second) {
9414 auto *RD = RecordPair.first;
9421 // Trigger the import of functions.
9422 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9423 PendingFunctionOdrMergeFailures.clear();
9424 for (auto &Merge : FunctionOdrMergeFailures) {
9425 Merge.first->buildLookup();
9426 Merge.first->decls_begin();
9427 Merge.first->getBody();
9428 for (auto &FD : Merge.second) {
9435 // Trigger the import of enums.
9436 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9437 PendingEnumOdrMergeFailures.clear();
9438 for (auto &Merge : EnumOdrMergeFailures) {
9439 Merge.first->decls_begin();
9440 for (auto &Enum : Merge.second) {
9441 Enum->decls_begin();
9445 // For each declaration from a merged context, check that the canonical
9446 // definition of that context also contains a declaration of the same
9449 // Caution: this loop does things that might invalidate iterators into
9450 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9451 while (!PendingOdrMergeChecks.empty()) {
9452 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9454 // FIXME: Skip over implicit declarations for now. This matters for things
9455 // like implicitly-declared special member functions. This isn't entirely
9456 // correct; we can end up with multiple unmerged declarations of the same
9458 if (D->isImplicit())
9461 DeclContext *CanonDef = D->getDeclContext();
9464 const Decl *DCanon = D->getCanonicalDecl();
9466 for (auto RI : D->redecls()) {
9467 if (RI->getLexicalDeclContext() == CanonDef) {
9475 // Quick check failed, time to do the slow thing. Note, we can't just
9476 // look up the name of D in CanonDef here, because the member that is
9477 // in CanonDef might not be found by name lookup (it might have been
9478 // replaced by a more recent declaration in the lookup table), and we
9479 // can't necessarily find it in the redeclaration chain because it might
9480 // be merely mergeable, not redeclarable.
9481 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9482 for (auto *CanonMember : CanonDef->decls()) {
9483 if (CanonMember->getCanonicalDecl() == DCanon) {
9484 // This can happen if the declaration is merely mergeable and not
9485 // actually redeclarable (we looked for redeclarations earlier).
9487 // FIXME: We should be able to detect this more efficiently, without
9488 // pulling in all of the members of CanonDef.
9492 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9493 if (ND->getDeclName() == D->getDeclName())
9494 Candidates.push_back(ND);
9498 // The AST doesn't like TagDecls becoming invalid after they've been
9499 // completed. We only really need to mark FieldDecls as invalid here.
9500 if (!isa<TagDecl>(D))
9501 D->setInvalidDecl();
9503 // Ensure we don't accidentally recursively enter deserialization while
9504 // we're producing our diagnostic.
9505 Deserializing RecursionGuard(this);
9507 std::string CanonDefModule =
9508 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9509 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9510 << D << getOwningModuleNameForDiagnostic(D)
9511 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9513 if (Candidates.empty())
9514 Diag(cast<Decl>(CanonDef)->getLocation(),
9515 diag::note_module_odr_violation_no_possible_decls) << D;
9517 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9518 Diag(Candidates[I]->getLocation(),
9519 diag::note_module_odr_violation_possible_decl)
9523 DiagnosedOdrMergeFailures.insert(CanonDef);
9527 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9528 EnumOdrMergeFailures.empty())
9531 // Ensure we don't accidentally recursively enter deserialization while
9532 // we're producing our diagnostics.
9533 Deserializing RecursionGuard(this);
9535 // Common code for hashing helpers.
9537 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9539 Hash.AddQualType(Ty);
9540 return Hash.CalculateHash();
9543 auto ComputeODRHash = [&Hash](const Stmt *S) {
9547 return Hash.CalculateHash();
9550 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9554 return Hash.CalculateHash();
9557 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9559 Hash.AddTemplateArgument(TA);
9560 return Hash.CalculateHash();
9563 auto ComputeTemplateParameterListODRHash =
9564 [&Hash](const TemplateParameterList *TPL) {
9567 Hash.AddTemplateParameterList(TPL);
9568 return Hash.CalculateHash();
9571 // Used with err_module_odr_violation_mismatch_decl and
9572 // note_module_odr_violation_mismatch_decl
9573 // This list should be the same Decl's as in ODRHash::isDeclToBeProcessed
9574 enum ODRMismatchDecl {
9590 // Used with err_module_odr_violation_mismatch_decl_diff and
9591 // note_module_odr_violation_mismatch_decl_diff
9592 enum ODRMismatchDeclDifference {
9593 StaticAssertCondition,
9594 StaticAssertMessage,
9595 StaticAssertOnlyMessage,
9598 FieldSingleBitField,
9599 FieldDifferentWidthBitField,
9601 FieldSingleInitializer,
9602 FieldDifferentInitializers,
9611 MethodNumberParameters,
9612 MethodParameterType,
9613 MethodParameterName,
9614 MethodParameterSingleDefaultArgument,
9615 MethodParameterDifferentDefaultArgument,
9616 MethodNoTemplateArguments,
9617 MethodDifferentNumberTemplateArguments,
9618 MethodDifferentTemplateArgument,
9620 MethodDifferentBody,
9625 VarSingleInitializer,
9626 VarDifferentInitializer,
9631 FunctionTemplateDifferentNumberParameters,
9632 FunctionTemplateParameterDifferentKind,
9633 FunctionTemplateParameterName,
9634 FunctionTemplateParameterSingleDefaultArgument,
9635 FunctionTemplateParameterDifferentDefaultArgument,
9636 FunctionTemplateParameterDifferentType,
9637 FunctionTemplatePackParameter,
9640 // These lambdas have the common portions of the ODR diagnostics. This
9641 // has the same return as Diag(), so addition parameters can be passed
9642 // in with operator<<
9643 auto ODRDiagDeclError = [this](NamedDecl *FirstRecord, StringRef FirstModule,
9644 SourceLocation Loc, SourceRange Range,
9645 ODRMismatchDeclDifference DiffType) {
9646 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
9647 << FirstRecord << FirstModule.empty() << FirstModule << Range
9650 auto ODRDiagDeclNote = [this](StringRef SecondModule, SourceLocation Loc,
9651 SourceRange Range, ODRMismatchDeclDifference DiffType) {
9652 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
9653 << SecondModule << Range << DiffType;
9656 auto ODRDiagField = [this, &ODRDiagDeclError, &ODRDiagDeclNote,
9657 &ComputeQualTypeODRHash, &ComputeODRHash](
9658 NamedDecl *FirstRecord, StringRef FirstModule,
9659 StringRef SecondModule, FieldDecl *FirstField,
9660 FieldDecl *SecondField) {
9661 IdentifierInfo *FirstII = FirstField->getIdentifier();
9662 IdentifierInfo *SecondII = SecondField->getIdentifier();
9663 if (FirstII->getName() != SecondII->getName()) {
9664 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9665 FirstField->getSourceRange(), FieldName)
9667 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9668 SecondField->getSourceRange(), FieldName)
9674 assert(getContext().hasSameType(FirstField->getType(),
9675 SecondField->getType()));
9677 QualType FirstType = FirstField->getType();
9678 QualType SecondType = SecondField->getType();
9679 if (ComputeQualTypeODRHash(FirstType) !=
9680 ComputeQualTypeODRHash(SecondType)) {
9681 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9682 FirstField->getSourceRange(), FieldTypeName)
9683 << FirstII << FirstType;
9684 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9685 SecondField->getSourceRange(), FieldTypeName)
9686 << SecondII << SecondType;
9691 const bool IsFirstBitField = FirstField->isBitField();
9692 const bool IsSecondBitField = SecondField->isBitField();
9693 if (IsFirstBitField != IsSecondBitField) {
9694 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9695 FirstField->getSourceRange(), FieldSingleBitField)
9696 << FirstII << IsFirstBitField;
9697 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9698 SecondField->getSourceRange(), FieldSingleBitField)
9699 << SecondII << IsSecondBitField;
9703 if (IsFirstBitField && IsSecondBitField) {
9704 unsigned FirstBitWidthHash =
9705 ComputeODRHash(FirstField->getBitWidth());
9706 unsigned SecondBitWidthHash =
9707 ComputeODRHash(SecondField->getBitWidth());
9708 if (FirstBitWidthHash != SecondBitWidthHash) {
9709 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9710 FirstField->getSourceRange(),
9711 FieldDifferentWidthBitField)
9712 << FirstII << FirstField->getBitWidth()->getSourceRange();
9713 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9714 SecondField->getSourceRange(),
9715 FieldDifferentWidthBitField)
9716 << SecondII << SecondField->getBitWidth()->getSourceRange();
9721 if (!PP.getLangOpts().CPlusPlus)
9724 const bool IsFirstMutable = FirstField->isMutable();
9725 const bool IsSecondMutable = SecondField->isMutable();
9726 if (IsFirstMutable != IsSecondMutable) {
9727 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9728 FirstField->getSourceRange(), FieldSingleMutable)
9729 << FirstII << IsFirstMutable;
9730 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9731 SecondField->getSourceRange(), FieldSingleMutable)
9732 << SecondII << IsSecondMutable;
9736 const Expr *FirstInitializer = FirstField->getInClassInitializer();
9737 const Expr *SecondInitializer = SecondField->getInClassInitializer();
9738 if ((!FirstInitializer && SecondInitializer) ||
9739 (FirstInitializer && !SecondInitializer)) {
9740 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9741 FirstField->getSourceRange(), FieldSingleInitializer)
9742 << FirstII << (FirstInitializer != nullptr);
9743 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9744 SecondField->getSourceRange(), FieldSingleInitializer)
9745 << SecondII << (SecondInitializer != nullptr);
9749 if (FirstInitializer && SecondInitializer) {
9750 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
9751 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
9752 if (FirstInitHash != SecondInitHash) {
9753 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9754 FirstField->getSourceRange(),
9755 FieldDifferentInitializers)
9756 << FirstII << FirstInitializer->getSourceRange();
9757 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9758 SecondField->getSourceRange(),
9759 FieldDifferentInitializers)
9760 << SecondII << SecondInitializer->getSourceRange();
9768 auto ODRDiagTypeDefOrAlias =
9769 [&ODRDiagDeclError, &ODRDiagDeclNote, &ComputeQualTypeODRHash](
9770 NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
9771 TypedefNameDecl *FirstTD, TypedefNameDecl *SecondTD,
9773 auto FirstName = FirstTD->getDeclName();
9774 auto SecondName = SecondTD->getDeclName();
9775 if (FirstName != SecondName) {
9776 ODRDiagDeclError(FirstRecord, FirstModule, FirstTD->getLocation(),
9777 FirstTD->getSourceRange(), TypedefName)
9778 << IsTypeAlias << FirstName;
9779 ODRDiagDeclNote(SecondModule, SecondTD->getLocation(),
9780 SecondTD->getSourceRange(), TypedefName)
9781 << IsTypeAlias << SecondName;
9785 QualType FirstType = FirstTD->getUnderlyingType();
9786 QualType SecondType = SecondTD->getUnderlyingType();
9787 if (ComputeQualTypeODRHash(FirstType) !=
9788 ComputeQualTypeODRHash(SecondType)) {
9789 ODRDiagDeclError(FirstRecord, FirstModule, FirstTD->getLocation(),
9790 FirstTD->getSourceRange(), TypedefType)
9791 << IsTypeAlias << FirstName << FirstType;
9792 ODRDiagDeclNote(SecondModule, SecondTD->getLocation(),
9793 SecondTD->getSourceRange(), TypedefType)
9794 << IsTypeAlias << SecondName << SecondType;
9801 auto ODRDiagVar = [&ODRDiagDeclError, &ODRDiagDeclNote,
9802 &ComputeQualTypeODRHash, &ComputeODRHash,
9803 this](NamedDecl *FirstRecord, StringRef FirstModule,
9804 StringRef SecondModule, VarDecl *FirstVD,
9805 VarDecl *SecondVD) {
9806 auto FirstName = FirstVD->getDeclName();
9807 auto SecondName = SecondVD->getDeclName();
9808 if (FirstName != SecondName) {
9809 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9810 FirstVD->getSourceRange(), VarName)
9812 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9813 SecondVD->getSourceRange(), VarName)
9818 QualType FirstType = FirstVD->getType();
9819 QualType SecondType = SecondVD->getType();
9820 if (ComputeQualTypeODRHash(FirstType) !=
9821 ComputeQualTypeODRHash(SecondType)) {
9822 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9823 FirstVD->getSourceRange(), VarType)
9824 << FirstName << FirstType;
9825 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9826 SecondVD->getSourceRange(), VarType)
9827 << SecondName << SecondType;
9831 if (!PP.getLangOpts().CPlusPlus)
9834 const Expr *FirstInit = FirstVD->getInit();
9835 const Expr *SecondInit = SecondVD->getInit();
9836 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
9837 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9838 FirstVD->getSourceRange(), VarSingleInitializer)
9839 << FirstName << (FirstInit == nullptr)
9840 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
9841 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9842 SecondVD->getSourceRange(), VarSingleInitializer)
9843 << SecondName << (SecondInit == nullptr)
9844 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
9848 if (FirstInit && SecondInit &&
9849 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
9850 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9851 FirstVD->getSourceRange(), VarDifferentInitializer)
9852 << FirstName << FirstInit->getSourceRange();
9853 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9854 SecondVD->getSourceRange(), VarDifferentInitializer)
9855 << SecondName << SecondInit->getSourceRange();
9859 const bool FirstIsConstexpr = FirstVD->isConstexpr();
9860 const bool SecondIsConstexpr = SecondVD->isConstexpr();
9861 if (FirstIsConstexpr != SecondIsConstexpr) {
9862 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9863 FirstVD->getSourceRange(), VarConstexpr)
9864 << FirstName << FirstIsConstexpr;
9865 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9866 SecondVD->getSourceRange(), VarConstexpr)
9867 << SecondName << SecondIsConstexpr;
9873 auto DifferenceSelector = [](Decl *D) {
9874 assert(D && "valid Decl required");
9875 switch (D->getKind()) {
9878 case Decl::AccessSpec:
9879 switch (D->getAccess()) {
9881 return PublicSpecifer;
9883 return PrivateSpecifer;
9885 return ProtectedSpecifer;
9889 llvm_unreachable("Invalid access specifier");
9890 case Decl::StaticAssert:
9891 return StaticAssert;
9894 case Decl::CXXMethod:
9895 case Decl::CXXConstructor:
9896 case Decl::CXXDestructor:
9898 case Decl::TypeAlias:
9906 case Decl::FunctionTemplate:
9907 return FunctionTemplate;
9911 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9912 auto PopulateHashes = [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9914 const DeclContext *DC) {
9915 for (auto *D : Record->decls()) {
9916 if (!ODRHash::isDeclToBeProcessed(D, DC))
9918 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9923 Decl *FirstDecl = nullptr, *SecondDecl = nullptr;
9924 ODRMismatchDecl FirstDiffType = Other, SecondDiffType = Other;
9927 // If there is a diagnoseable difference, FirstDiffType and
9928 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
9929 // filled in if not EndOfClass.
9930 auto FindTypeDiffs = [&DifferenceSelector](DeclHashes &FirstHashes,
9931 DeclHashes &SecondHashes) {
9933 auto FirstIt = FirstHashes.begin();
9934 auto SecondIt = SecondHashes.begin();
9935 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
9936 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
9937 FirstIt->second == SecondIt->second) {
9943 DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
9945 SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
9948 DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
9950 DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
9956 // Use this to diagnose that an unexpected Decl was encountered
9957 // or no difference was detected. This causes a generic error
9958 // message to be emitted.
9959 auto DiagnoseODRUnexpected = [this](DiffResult &DR, NamedDecl *FirstRecord,
9960 StringRef FirstModule,
9961 NamedDecl *SecondRecord,
9962 StringRef SecondModule) {
9963 Diag(FirstRecord->getLocation(),
9964 diag::err_module_odr_violation_different_definitions)
9965 << FirstRecord << FirstModule.empty() << FirstModule;
9968 Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
9969 << FirstRecord << DR.FirstDecl->getSourceRange();
9972 Diag(SecondRecord->getLocation(),
9973 diag::note_module_odr_violation_different_definitions)
9976 if (DR.SecondDecl) {
9977 Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
9978 << DR.SecondDecl->getSourceRange();
9982 auto DiagnoseODRMismatch =
9983 [this](DiffResult &DR, NamedDecl *FirstRecord, StringRef FirstModule,
9984 NamedDecl *SecondRecord, StringRef SecondModule) {
9985 SourceLocation FirstLoc;
9986 SourceRange FirstRange;
9987 auto *FirstTag = dyn_cast<TagDecl>(FirstRecord);
9988 if (DR.FirstDiffType == EndOfClass && FirstTag) {
9989 FirstLoc = FirstTag->getBraceRange().getEnd();
9991 FirstLoc = DR.FirstDecl->getLocation();
9992 FirstRange = DR.FirstDecl->getSourceRange();
9994 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
9995 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
9996 << DR.FirstDiffType;
9998 SourceLocation SecondLoc;
9999 SourceRange SecondRange;
10000 auto *SecondTag = dyn_cast<TagDecl>(SecondRecord);
10001 if (DR.SecondDiffType == EndOfClass && SecondTag) {
10002 SecondLoc = SecondTag->getBraceRange().getEnd();
10004 SecondLoc = DR.SecondDecl->getLocation();
10005 SecondRange = DR.SecondDecl->getSourceRange();
10007 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10008 << SecondModule << SecondRange << DR.SecondDiffType;
10011 // Issue any pending ODR-failure diagnostics.
10012 for (auto &Merge : OdrMergeFailures) {
10013 // If we've already pointed out a specific problem with this class, don't
10014 // bother issuing a general "something's different" diagnostic.
10015 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10018 bool Diagnosed = false;
10019 CXXRecordDecl *FirstRecord = Merge.first;
10020 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
10021 for (auto &RecordPair : Merge.second) {
10022 CXXRecordDecl *SecondRecord = RecordPair.first;
10023 // Multiple different declarations got merged together; tell the user
10024 // where they came from.
10025 if (FirstRecord == SecondRecord)
10028 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
10030 auto *FirstDD = FirstRecord->DefinitionData;
10031 auto *SecondDD = RecordPair.second;
10033 assert(FirstDD && SecondDD && "Definitions without DefinitionData");
10035 // Diagnostics from DefinitionData are emitted here.
10036 if (FirstDD != SecondDD) {
10037 enum ODRDefinitionDataDifference {
10044 auto ODRDiagBaseError = [FirstRecord, &FirstModule,
10045 this](SourceLocation Loc, SourceRange Range,
10046 ODRDefinitionDataDifference DiffType) {
10047 return Diag(Loc, diag::err_module_odr_violation_definition_data)
10048 << FirstRecord << FirstModule.empty() << FirstModule << Range
10051 auto ODRDiagBaseNote = [&SecondModule,
10052 this](SourceLocation Loc, SourceRange Range,
10053 ODRDefinitionDataDifference DiffType) {
10054 return Diag(Loc, diag::note_module_odr_violation_definition_data)
10055 << SecondModule << Range << DiffType;
10058 unsigned FirstNumBases = FirstDD->NumBases;
10059 unsigned FirstNumVBases = FirstDD->NumVBases;
10060 unsigned SecondNumBases = SecondDD->NumBases;
10061 unsigned SecondNumVBases = SecondDD->NumVBases;
10063 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
10064 unsigned NumBases = DD->NumBases;
10065 if (NumBases == 0) return SourceRange();
10066 auto bases = DD->bases();
10067 return SourceRange(bases[0].getBeginLoc(),
10068 bases[NumBases - 1].getEndLoc());
10071 if (FirstNumBases != SecondNumBases) {
10072 ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
10075 ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
10082 if (FirstNumVBases != SecondNumVBases) {
10083 ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
10086 ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
10088 << SecondNumVBases;
10093 auto FirstBases = FirstDD->bases();
10094 auto SecondBases = SecondDD->bases();
10096 for (i = 0; i < FirstNumBases; ++i) {
10097 auto FirstBase = FirstBases[i];
10098 auto SecondBase = SecondBases[i];
10099 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
10100 ComputeQualTypeODRHash(SecondBase.getType())) {
10101 ODRDiagBaseError(FirstRecord->getLocation(),
10102 FirstBase.getSourceRange(), BaseType)
10103 << (i + 1) << FirstBase.getType();
10104 ODRDiagBaseNote(SecondRecord->getLocation(),
10105 SecondBase.getSourceRange(), BaseType)
10106 << (i + 1) << SecondBase.getType();
10110 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
10111 ODRDiagBaseError(FirstRecord->getLocation(),
10112 FirstBase.getSourceRange(), BaseVirtual)
10113 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
10114 ODRDiagBaseNote(SecondRecord->getLocation(),
10115 SecondBase.getSourceRange(), BaseVirtual)
10116 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
10120 if (FirstBase.getAccessSpecifierAsWritten() !=
10121 SecondBase.getAccessSpecifierAsWritten()) {
10122 ODRDiagBaseError(FirstRecord->getLocation(),
10123 FirstBase.getSourceRange(), BaseAccess)
10124 << (i + 1) << FirstBase.getType()
10125 << (int)FirstBase.getAccessSpecifierAsWritten();
10126 ODRDiagBaseNote(SecondRecord->getLocation(),
10127 SecondBase.getSourceRange(), BaseAccess)
10128 << (i + 1) << SecondBase.getType()
10129 << (int)SecondBase.getAccessSpecifierAsWritten();
10134 if (i != FirstNumBases) {
10140 const ClassTemplateDecl *FirstTemplate =
10141 FirstRecord->getDescribedClassTemplate();
10142 const ClassTemplateDecl *SecondTemplate =
10143 SecondRecord->getDescribedClassTemplate();
10145 assert(!FirstTemplate == !SecondTemplate &&
10146 "Both pointers should be null or non-null");
10148 enum ODRTemplateDifference {
10151 ParamSingleDefaultArgument,
10152 ParamDifferentDefaultArgument,
10155 if (FirstTemplate && SecondTemplate) {
10156 DeclHashes FirstTemplateHashes;
10157 DeclHashes SecondTemplateHashes;
10159 auto PopulateTemplateParameterHashs =
10160 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
10161 const ClassTemplateDecl *TD) {
10162 for (auto *D : TD->getTemplateParameters()->asArray()) {
10163 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
10167 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
10168 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
10170 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
10171 "Number of template parameters should be equal.");
10173 auto FirstIt = FirstTemplateHashes.begin();
10174 auto FirstEnd = FirstTemplateHashes.end();
10175 auto SecondIt = SecondTemplateHashes.begin();
10176 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
10177 if (FirstIt->second == SecondIt->second)
10180 auto ODRDiagTemplateError = [FirstRecord, &FirstModule, this](
10181 SourceLocation Loc, SourceRange Range,
10182 ODRTemplateDifference DiffType) {
10183 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
10184 << FirstRecord << FirstModule.empty() << FirstModule << Range
10187 auto ODRDiagTemplateNote = [&SecondModule, this](
10188 SourceLocation Loc, SourceRange Range,
10189 ODRTemplateDifference DiffType) {
10190 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
10191 << SecondModule << Range << DiffType;
10194 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
10195 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
10197 assert(FirstDecl->getKind() == SecondDecl->getKind() &&
10198 "Parameter Decl's should be the same kind.");
10200 DeclarationName FirstName = FirstDecl->getDeclName();
10201 DeclarationName SecondName = SecondDecl->getDeclName();
10203 if (FirstName != SecondName) {
10204 const bool FirstNameEmpty =
10205 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
10206 const bool SecondNameEmpty =
10207 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
10208 assert((!FirstNameEmpty || !SecondNameEmpty) &&
10209 "Both template parameters cannot be unnamed.");
10210 ODRDiagTemplateError(FirstDecl->getLocation(),
10211 FirstDecl->getSourceRange(),
10212 FirstNameEmpty ? ParamEmptyName : ParamName)
10214 ODRDiagTemplateNote(SecondDecl->getLocation(),
10215 SecondDecl->getSourceRange(),
10216 SecondNameEmpty ? ParamEmptyName : ParamName)
10221 switch (FirstDecl->getKind()) {
10223 llvm_unreachable("Invalid template parameter type.");
10224 case Decl::TemplateTypeParm: {
10225 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
10226 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
10227 const bool HasFirstDefaultArgument =
10228 FirstParam->hasDefaultArgument() &&
10229 !FirstParam->defaultArgumentWasInherited();
10230 const bool HasSecondDefaultArgument =
10231 SecondParam->hasDefaultArgument() &&
10232 !SecondParam->defaultArgumentWasInherited();
10234 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10235 ODRDiagTemplateError(FirstDecl->getLocation(),
10236 FirstDecl->getSourceRange(),
10237 ParamSingleDefaultArgument)
10238 << HasFirstDefaultArgument;
10239 ODRDiagTemplateNote(SecondDecl->getLocation(),
10240 SecondDecl->getSourceRange(),
10241 ParamSingleDefaultArgument)
10242 << HasSecondDefaultArgument;
10246 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10247 "Expecting default arguments.");
10249 ODRDiagTemplateError(FirstDecl->getLocation(),
10250 FirstDecl->getSourceRange(),
10251 ParamDifferentDefaultArgument);
10252 ODRDiagTemplateNote(SecondDecl->getLocation(),
10253 SecondDecl->getSourceRange(),
10254 ParamDifferentDefaultArgument);
10258 case Decl::NonTypeTemplateParm: {
10259 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
10260 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
10261 const bool HasFirstDefaultArgument =
10262 FirstParam->hasDefaultArgument() &&
10263 !FirstParam->defaultArgumentWasInherited();
10264 const bool HasSecondDefaultArgument =
10265 SecondParam->hasDefaultArgument() &&
10266 !SecondParam->defaultArgumentWasInherited();
10268 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10269 ODRDiagTemplateError(FirstDecl->getLocation(),
10270 FirstDecl->getSourceRange(),
10271 ParamSingleDefaultArgument)
10272 << HasFirstDefaultArgument;
10273 ODRDiagTemplateNote(SecondDecl->getLocation(),
10274 SecondDecl->getSourceRange(),
10275 ParamSingleDefaultArgument)
10276 << HasSecondDefaultArgument;
10280 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10281 "Expecting default arguments.");
10283 ODRDiagTemplateError(FirstDecl->getLocation(),
10284 FirstDecl->getSourceRange(),
10285 ParamDifferentDefaultArgument);
10286 ODRDiagTemplateNote(SecondDecl->getLocation(),
10287 SecondDecl->getSourceRange(),
10288 ParamDifferentDefaultArgument);
10292 case Decl::TemplateTemplateParm: {
10293 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
10294 const auto *SecondParam =
10295 cast<TemplateTemplateParmDecl>(SecondDecl);
10296 const bool HasFirstDefaultArgument =
10297 FirstParam->hasDefaultArgument() &&
10298 !FirstParam->defaultArgumentWasInherited();
10299 const bool HasSecondDefaultArgument =
10300 SecondParam->hasDefaultArgument() &&
10301 !SecondParam->defaultArgumentWasInherited();
10303 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10304 ODRDiagTemplateError(FirstDecl->getLocation(),
10305 FirstDecl->getSourceRange(),
10306 ParamSingleDefaultArgument)
10307 << HasFirstDefaultArgument;
10308 ODRDiagTemplateNote(SecondDecl->getLocation(),
10309 SecondDecl->getSourceRange(),
10310 ParamSingleDefaultArgument)
10311 << HasSecondDefaultArgument;
10315 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10316 "Expecting default arguments.");
10318 ODRDiagTemplateError(FirstDecl->getLocation(),
10319 FirstDecl->getSourceRange(),
10320 ParamDifferentDefaultArgument);
10321 ODRDiagTemplateNote(SecondDecl->getLocation(),
10322 SecondDecl->getSourceRange(),
10323 ParamDifferentDefaultArgument);
10332 if (FirstIt != FirstEnd) {
10338 DeclHashes FirstHashes;
10339 DeclHashes SecondHashes;
10340 const DeclContext *DC = FirstRecord;
10341 PopulateHashes(FirstHashes, FirstRecord, DC);
10342 PopulateHashes(SecondHashes, SecondRecord, DC);
10344 auto DR = FindTypeDiffs(FirstHashes, SecondHashes);
10345 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
10346 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
10347 Decl *FirstDecl = DR.FirstDecl;
10348 Decl *SecondDecl = DR.SecondDecl;
10350 if (FirstDiffType == Other || SecondDiffType == Other) {
10351 DiagnoseODRUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
10357 if (FirstDiffType != SecondDiffType) {
10358 DiagnoseODRMismatch(DR, FirstRecord, FirstModule, SecondRecord,
10364 assert(FirstDiffType == SecondDiffType);
10366 switch (FirstDiffType) {
10369 case PublicSpecifer:
10370 case PrivateSpecifer:
10371 case ProtectedSpecifer:
10372 llvm_unreachable("Invalid diff type");
10374 case StaticAssert: {
10375 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10376 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10378 Expr *FirstExpr = FirstSA->getAssertExpr();
10379 Expr *SecondExpr = SecondSA->getAssertExpr();
10380 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10381 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10382 if (FirstODRHash != SecondODRHash) {
10383 ODRDiagDeclError(FirstRecord, FirstModule, FirstExpr->getBeginLoc(),
10384 FirstExpr->getSourceRange(), StaticAssertCondition);
10385 ODRDiagDeclNote(SecondModule, SecondExpr->getBeginLoc(),
10386 SecondExpr->getSourceRange(), StaticAssertCondition);
10391 StringLiteral *FirstStr = FirstSA->getMessage();
10392 StringLiteral *SecondStr = SecondSA->getMessage();
10393 assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10394 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10395 SourceLocation FirstLoc, SecondLoc;
10396 SourceRange FirstRange, SecondRange;
10398 FirstLoc = FirstStr->getBeginLoc();
10399 FirstRange = FirstStr->getSourceRange();
10401 FirstLoc = FirstSA->getBeginLoc();
10402 FirstRange = FirstSA->getSourceRange();
10405 SecondLoc = SecondStr->getBeginLoc();
10406 SecondRange = SecondStr->getSourceRange();
10408 SecondLoc = SecondSA->getBeginLoc();
10409 SecondRange = SecondSA->getSourceRange();
10411 ODRDiagDeclError(FirstRecord, FirstModule, FirstLoc, FirstRange,
10412 StaticAssertOnlyMessage)
10413 << (FirstStr == nullptr);
10414 ODRDiagDeclNote(SecondModule, SecondLoc, SecondRange,
10415 StaticAssertOnlyMessage)
10416 << (SecondStr == nullptr);
10421 if (FirstStr && SecondStr &&
10422 FirstStr->getString() != SecondStr->getString()) {
10423 ODRDiagDeclError(FirstRecord, FirstModule, FirstStr->getBeginLoc(),
10424 FirstStr->getSourceRange(), StaticAssertMessage);
10425 ODRDiagDeclNote(SecondModule, SecondStr->getBeginLoc(),
10426 SecondStr->getSourceRange(), StaticAssertMessage);
10433 Diagnosed = ODRDiagField(FirstRecord, FirstModule, SecondModule,
10434 cast<FieldDecl>(FirstDecl),
10435 cast<FieldDecl>(SecondDecl));
10445 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10446 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10447 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10450 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10451 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10452 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10453 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10454 auto FirstName = FirstMethod->getDeclName();
10455 auto SecondName = SecondMethod->getDeclName();
10456 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10457 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10458 FirstMethod->getSourceRange(), MethodName)
10459 << FirstMethodType << FirstName;
10460 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10461 SecondMethod->getSourceRange(), MethodName)
10462 << SecondMethodType << SecondName;
10468 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10469 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10470 if (FirstDeleted != SecondDeleted) {
10471 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10472 FirstMethod->getSourceRange(), MethodDeleted)
10473 << FirstMethodType << FirstName << FirstDeleted;
10475 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10476 SecondMethod->getSourceRange(), MethodDeleted)
10477 << SecondMethodType << SecondName << SecondDeleted;
10482 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10483 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10484 if (FirstDefaulted != SecondDefaulted) {
10485 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10486 FirstMethod->getSourceRange(), MethodDefaulted)
10487 << FirstMethodType << FirstName << FirstDefaulted;
10489 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10490 SecondMethod->getSourceRange(), MethodDefaulted)
10491 << SecondMethodType << SecondName << SecondDefaulted;
10496 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10497 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10498 const bool FirstPure = FirstMethod->isPure();
10499 const bool SecondPure = SecondMethod->isPure();
10500 if ((FirstVirtual || SecondVirtual) &&
10501 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10502 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10503 FirstMethod->getSourceRange(), MethodVirtual)
10504 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10505 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10506 SecondMethod->getSourceRange(), MethodVirtual)
10507 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10512 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10513 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10514 // class needs to be checked instead.
10515 const auto FirstStorage = FirstMethod->getStorageClass();
10516 const auto SecondStorage = SecondMethod->getStorageClass();
10517 const bool FirstStatic = FirstStorage == SC_Static;
10518 const bool SecondStatic = SecondStorage == SC_Static;
10519 if (FirstStatic != SecondStatic) {
10520 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10521 FirstMethod->getSourceRange(), MethodStatic)
10522 << FirstMethodType << FirstName << FirstStatic;
10523 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10524 SecondMethod->getSourceRange(), MethodStatic)
10525 << SecondMethodType << SecondName << SecondStatic;
10530 const bool FirstVolatile = FirstMethod->isVolatile();
10531 const bool SecondVolatile = SecondMethod->isVolatile();
10532 if (FirstVolatile != SecondVolatile) {
10533 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10534 FirstMethod->getSourceRange(), MethodVolatile)
10535 << FirstMethodType << FirstName << FirstVolatile;
10536 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10537 SecondMethod->getSourceRange(), MethodVolatile)
10538 << SecondMethodType << SecondName << SecondVolatile;
10543 const bool FirstConst = FirstMethod->isConst();
10544 const bool SecondConst = SecondMethod->isConst();
10545 if (FirstConst != SecondConst) {
10546 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10547 FirstMethod->getSourceRange(), MethodConst)
10548 << FirstMethodType << FirstName << FirstConst;
10549 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10550 SecondMethod->getSourceRange(), MethodConst)
10551 << SecondMethodType << SecondName << SecondConst;
10556 const bool FirstInline = FirstMethod->isInlineSpecified();
10557 const bool SecondInline = SecondMethod->isInlineSpecified();
10558 if (FirstInline != SecondInline) {
10559 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10560 FirstMethod->getSourceRange(), MethodInline)
10561 << FirstMethodType << FirstName << FirstInline;
10562 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10563 SecondMethod->getSourceRange(), MethodInline)
10564 << SecondMethodType << SecondName << SecondInline;
10569 const unsigned FirstNumParameters = FirstMethod->param_size();
10570 const unsigned SecondNumParameters = SecondMethod->param_size();
10571 if (FirstNumParameters != SecondNumParameters) {
10572 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10573 FirstMethod->getSourceRange(),
10574 MethodNumberParameters)
10575 << FirstMethodType << FirstName << FirstNumParameters;
10576 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10577 SecondMethod->getSourceRange(),
10578 MethodNumberParameters)
10579 << SecondMethodType << SecondName << SecondNumParameters;
10584 // Need this status boolean to know when break out of the switch.
10585 bool ParameterMismatch = false;
10586 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10587 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10588 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10590 QualType FirstParamType = FirstParam->getType();
10591 QualType SecondParamType = SecondParam->getType();
10592 if (FirstParamType != SecondParamType &&
10593 ComputeQualTypeODRHash(FirstParamType) !=
10594 ComputeQualTypeODRHash(SecondParamType)) {
10595 if (const DecayedType *ParamDecayedType =
10596 FirstParamType->getAs<DecayedType>()) {
10598 FirstRecord, FirstModule, FirstMethod->getLocation(),
10599 FirstMethod->getSourceRange(), MethodParameterType)
10600 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10601 << true << ParamDecayedType->getOriginalType();
10604 FirstRecord, FirstModule, FirstMethod->getLocation(),
10605 FirstMethod->getSourceRange(), MethodParameterType)
10606 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10610 if (const DecayedType *ParamDecayedType =
10611 SecondParamType->getAs<DecayedType>()) {
10612 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10613 SecondMethod->getSourceRange(),
10614 MethodParameterType)
10615 << SecondMethodType << SecondName << (I + 1)
10616 << SecondParamType << true
10617 << ParamDecayedType->getOriginalType();
10619 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10620 SecondMethod->getSourceRange(),
10621 MethodParameterType)
10622 << SecondMethodType << SecondName << (I + 1)
10623 << SecondParamType << false;
10625 ParameterMismatch = true;
10629 DeclarationName FirstParamName = FirstParam->getDeclName();
10630 DeclarationName SecondParamName = SecondParam->getDeclName();
10631 if (FirstParamName != SecondParamName) {
10632 ODRDiagDeclError(FirstRecord, FirstModule,
10633 FirstMethod->getLocation(),
10634 FirstMethod->getSourceRange(), MethodParameterName)
10635 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10636 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10637 SecondMethod->getSourceRange(), MethodParameterName)
10638 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10639 ParameterMismatch = true;
10643 const Expr *FirstInit = FirstParam->getInit();
10644 const Expr *SecondInit = SecondParam->getInit();
10645 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10646 ODRDiagDeclError(FirstRecord, FirstModule,
10647 FirstMethod->getLocation(),
10648 FirstMethod->getSourceRange(),
10649 MethodParameterSingleDefaultArgument)
10650 << FirstMethodType << FirstName << (I + 1)
10651 << (FirstInit == nullptr)
10652 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10653 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10654 SecondMethod->getSourceRange(),
10655 MethodParameterSingleDefaultArgument)
10656 << SecondMethodType << SecondName << (I + 1)
10657 << (SecondInit == nullptr)
10658 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10659 ParameterMismatch = true;
10663 if (FirstInit && SecondInit &&
10664 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10665 ODRDiagDeclError(FirstRecord, FirstModule,
10666 FirstMethod->getLocation(),
10667 FirstMethod->getSourceRange(),
10668 MethodParameterDifferentDefaultArgument)
10669 << FirstMethodType << FirstName << (I + 1)
10670 << FirstInit->getSourceRange();
10671 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10672 SecondMethod->getSourceRange(),
10673 MethodParameterDifferentDefaultArgument)
10674 << SecondMethodType << SecondName << (I + 1)
10675 << SecondInit->getSourceRange();
10676 ParameterMismatch = true;
10682 if (ParameterMismatch) {
10687 const auto *FirstTemplateArgs =
10688 FirstMethod->getTemplateSpecializationArgs();
10689 const auto *SecondTemplateArgs =
10690 SecondMethod->getTemplateSpecializationArgs();
10692 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10693 (!FirstTemplateArgs && SecondTemplateArgs)) {
10694 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10695 FirstMethod->getSourceRange(),
10696 MethodNoTemplateArguments)
10697 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10698 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10699 SecondMethod->getSourceRange(),
10700 MethodNoTemplateArguments)
10701 << SecondMethodType << SecondName
10702 << (SecondTemplateArgs != nullptr);
10708 if (FirstTemplateArgs && SecondTemplateArgs) {
10709 // Remove pack expansions from argument list.
10710 auto ExpandTemplateArgumentList =
10711 [](const TemplateArgumentList *TAL) {
10712 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10713 for (const TemplateArgument &TA : TAL->asArray()) {
10714 if (TA.getKind() != TemplateArgument::Pack) {
10715 ExpandedList.push_back(&TA);
10718 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10719 ExpandedList.push_back(&PackTA);
10722 return ExpandedList;
10724 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10725 ExpandTemplateArgumentList(FirstTemplateArgs);
10726 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10727 ExpandTemplateArgumentList(SecondTemplateArgs);
10729 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10730 ODRDiagDeclError(FirstRecord, FirstModule,
10731 FirstMethod->getLocation(),
10732 FirstMethod->getSourceRange(),
10733 MethodDifferentNumberTemplateArguments)
10734 << FirstMethodType << FirstName
10735 << (unsigned)FirstExpandedList.size();
10736 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10737 SecondMethod->getSourceRange(),
10738 MethodDifferentNumberTemplateArguments)
10739 << SecondMethodType << SecondName
10740 << (unsigned)SecondExpandedList.size();
10746 bool TemplateArgumentMismatch = false;
10747 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10748 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10749 &SecondTA = *SecondExpandedList[i];
10750 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10751 ComputeTemplateArgumentODRHash(SecondTA)) {
10756 FirstRecord, FirstModule, FirstMethod->getLocation(),
10757 FirstMethod->getSourceRange(), MethodDifferentTemplateArgument)
10758 << FirstMethodType << FirstName << FirstTA << i + 1;
10759 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10760 SecondMethod->getSourceRange(),
10761 MethodDifferentTemplateArgument)
10762 << SecondMethodType << SecondName << SecondTA << i + 1;
10764 TemplateArgumentMismatch = true;
10768 if (TemplateArgumentMismatch) {
10774 // Compute the hash of the method as if it has no body.
10775 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10777 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10778 return Hash.CalculateHash();
10781 // Compare the hash generated to the hash stored. A difference means
10782 // that a body was present in the original source. Due to merging,
10783 // the stardard way of detecting a body will not work.
10784 const bool HasFirstBody =
10785 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10786 const bool HasSecondBody =
10787 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10789 if (HasFirstBody != HasSecondBody) {
10790 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10791 FirstMethod->getSourceRange(), MethodSingleBody)
10792 << FirstMethodType << FirstName << HasFirstBody;
10793 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10794 SecondMethod->getSourceRange(), MethodSingleBody)
10795 << SecondMethodType << SecondName << HasSecondBody;
10800 if (HasFirstBody && HasSecondBody) {
10801 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10802 FirstMethod->getSourceRange(), MethodDifferentBody)
10803 << FirstMethodType << FirstName;
10804 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10805 SecondMethod->getSourceRange(), MethodDifferentBody)
10806 << SecondMethodType << SecondName;
10815 Diagnosed = ODRDiagTypeDefOrAlias(
10816 FirstRecord, FirstModule, SecondModule,
10817 cast<TypedefNameDecl>(FirstDecl), cast<TypedefNameDecl>(SecondDecl),
10818 FirstDiffType == TypeAlias);
10823 ODRDiagVar(FirstRecord, FirstModule, SecondModule,
10824 cast<VarDecl>(FirstDecl), cast<VarDecl>(SecondDecl));
10828 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10829 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10831 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10832 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10834 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10835 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10837 if (FirstND && SecondND) {
10838 ODRDiagDeclError(FirstRecord, FirstModule,
10839 FirstFriend->getFriendLoc(),
10840 FirstFriend->getSourceRange(), FriendFunction)
10842 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10843 SecondFriend->getSourceRange(), FriendFunction)
10850 if (FirstTSI && SecondTSI) {
10851 QualType FirstFriendType = FirstTSI->getType();
10852 QualType SecondFriendType = SecondTSI->getType();
10853 assert(ComputeQualTypeODRHash(FirstFriendType) !=
10854 ComputeQualTypeODRHash(SecondFriendType));
10855 ODRDiagDeclError(FirstRecord, FirstModule,
10856 FirstFriend->getFriendLoc(),
10857 FirstFriend->getSourceRange(), FriendType)
10858 << FirstFriendType;
10859 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10860 SecondFriend->getSourceRange(), FriendType)
10861 << SecondFriendType;
10866 ODRDiagDeclError(FirstRecord, FirstModule, FirstFriend->getFriendLoc(),
10867 FirstFriend->getSourceRange(), FriendTypeFunction)
10868 << (FirstTSI == nullptr);
10869 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10870 SecondFriend->getSourceRange(), FriendTypeFunction)
10871 << (SecondTSI == nullptr);
10876 case FunctionTemplate: {
10877 FunctionTemplateDecl *FirstTemplate =
10878 cast<FunctionTemplateDecl>(FirstDecl);
10879 FunctionTemplateDecl *SecondTemplate =
10880 cast<FunctionTemplateDecl>(SecondDecl);
10882 TemplateParameterList *FirstTPL =
10883 FirstTemplate->getTemplateParameters();
10884 TemplateParameterList *SecondTPL =
10885 SecondTemplate->getTemplateParameters();
10887 if (FirstTPL->size() != SecondTPL->size()) {
10888 ODRDiagDeclError(FirstRecord, FirstModule,
10889 FirstTemplate->getLocation(),
10890 FirstTemplate->getSourceRange(),
10891 FunctionTemplateDifferentNumberParameters)
10892 << FirstTemplate << FirstTPL->size();
10893 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10894 SecondTemplate->getSourceRange(),
10895 FunctionTemplateDifferentNumberParameters)
10896 << SecondTemplate << SecondTPL->size();
10902 bool ParameterMismatch = false;
10903 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10904 NamedDecl *FirstParam = FirstTPL->getParam(i);
10905 NamedDecl *SecondParam = SecondTPL->getParam(i);
10907 if (FirstParam->getKind() != SecondParam->getKind()) {
10909 TemplateTypeParameter,
10910 NonTypeTemplateParameter,
10911 TemplateTemplateParameter,
10913 auto GetParamType = [](NamedDecl *D) {
10914 switch (D->getKind()) {
10916 llvm_unreachable("Unexpected template parameter type");
10917 case Decl::TemplateTypeParm:
10918 return TemplateTypeParameter;
10919 case Decl::NonTypeTemplateParm:
10920 return NonTypeTemplateParameter;
10921 case Decl::TemplateTemplateParm:
10922 return TemplateTemplateParameter;
10926 ODRDiagDeclError(FirstRecord, FirstModule,
10927 FirstTemplate->getLocation(),
10928 FirstTemplate->getSourceRange(),
10929 FunctionTemplateParameterDifferentKind)
10930 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10931 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10932 SecondTemplate->getSourceRange(),
10933 FunctionTemplateParameterDifferentKind)
10934 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10936 ParameterMismatch = true;
10940 if (FirstParam->getName() != SecondParam->getName()) {
10942 FirstRecord, FirstModule, FirstTemplate->getLocation(),
10943 FirstTemplate->getSourceRange(), FunctionTemplateParameterName)
10944 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10946 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10947 SecondTemplate->getSourceRange(),
10948 FunctionTemplateParameterName)
10949 << SecondTemplate << (i + 1)
10950 << (bool)SecondParam->getIdentifier() << SecondParam;
10951 ParameterMismatch = true;
10955 if (isa<TemplateTypeParmDecl>(FirstParam) &&
10956 isa<TemplateTypeParmDecl>(SecondParam)) {
10957 TemplateTypeParmDecl *FirstTTPD =
10958 cast<TemplateTypeParmDecl>(FirstParam);
10959 TemplateTypeParmDecl *SecondTTPD =
10960 cast<TemplateTypeParmDecl>(SecondParam);
10961 bool HasFirstDefaultArgument =
10962 FirstTTPD->hasDefaultArgument() &&
10963 !FirstTTPD->defaultArgumentWasInherited();
10964 bool HasSecondDefaultArgument =
10965 SecondTTPD->hasDefaultArgument() &&
10966 !SecondTTPD->defaultArgumentWasInherited();
10967 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10968 ODRDiagDeclError(FirstRecord, FirstModule,
10969 FirstTemplate->getLocation(),
10970 FirstTemplate->getSourceRange(),
10971 FunctionTemplateParameterSingleDefaultArgument)
10972 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10973 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10974 SecondTemplate->getSourceRange(),
10975 FunctionTemplateParameterSingleDefaultArgument)
10976 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
10977 ParameterMismatch = true;
10981 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
10982 QualType FirstType = FirstTTPD->getDefaultArgument();
10983 QualType SecondType = SecondTTPD->getDefaultArgument();
10984 if (ComputeQualTypeODRHash(FirstType) !=
10985 ComputeQualTypeODRHash(SecondType)) {
10987 FirstRecord, FirstModule, FirstTemplate->getLocation(),
10988 FirstTemplate->getSourceRange(),
10989 FunctionTemplateParameterDifferentDefaultArgument)
10990 << FirstTemplate << (i + 1) << FirstType;
10992 SecondModule, SecondTemplate->getLocation(),
10993 SecondTemplate->getSourceRange(),
10994 FunctionTemplateParameterDifferentDefaultArgument)
10995 << SecondTemplate << (i + 1) << SecondType;
10996 ParameterMismatch = true;
11001 if (FirstTTPD->isParameterPack() !=
11002 SecondTTPD->isParameterPack()) {
11003 ODRDiagDeclError(FirstRecord, FirstModule,
11004 FirstTemplate->getLocation(),
11005 FirstTemplate->getSourceRange(),
11006 FunctionTemplatePackParameter)
11007 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11008 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11009 SecondTemplate->getSourceRange(),
11010 FunctionTemplatePackParameter)
11011 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11012 ParameterMismatch = true;
11017 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
11018 isa<TemplateTemplateParmDecl>(SecondParam)) {
11019 TemplateTemplateParmDecl *FirstTTPD =
11020 cast<TemplateTemplateParmDecl>(FirstParam);
11021 TemplateTemplateParmDecl *SecondTTPD =
11022 cast<TemplateTemplateParmDecl>(SecondParam);
11024 TemplateParameterList *FirstTPL =
11025 FirstTTPD->getTemplateParameters();
11026 TemplateParameterList *SecondTPL =
11027 SecondTTPD->getTemplateParameters();
11029 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
11030 ComputeTemplateParameterListODRHash(SecondTPL)) {
11031 ODRDiagDeclError(FirstRecord, FirstModule,
11032 FirstTemplate->getLocation(),
11033 FirstTemplate->getSourceRange(),
11034 FunctionTemplateParameterDifferentType)
11035 << FirstTemplate << (i + 1);
11036 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11037 SecondTemplate->getSourceRange(),
11038 FunctionTemplateParameterDifferentType)
11039 << SecondTemplate << (i + 1);
11040 ParameterMismatch = true;
11044 bool HasFirstDefaultArgument =
11045 FirstTTPD->hasDefaultArgument() &&
11046 !FirstTTPD->defaultArgumentWasInherited();
11047 bool HasSecondDefaultArgument =
11048 SecondTTPD->hasDefaultArgument() &&
11049 !SecondTTPD->defaultArgumentWasInherited();
11050 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11051 ODRDiagDeclError(FirstRecord, FirstModule,
11052 FirstTemplate->getLocation(),
11053 FirstTemplate->getSourceRange(),
11054 FunctionTemplateParameterSingleDefaultArgument)
11055 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11056 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11057 SecondTemplate->getSourceRange(),
11058 FunctionTemplateParameterSingleDefaultArgument)
11059 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11060 ParameterMismatch = true;
11064 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11065 TemplateArgument FirstTA =
11066 FirstTTPD->getDefaultArgument().getArgument();
11067 TemplateArgument SecondTA =
11068 SecondTTPD->getDefaultArgument().getArgument();
11069 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11070 ComputeTemplateArgumentODRHash(SecondTA)) {
11072 FirstRecord, FirstModule, FirstTemplate->getLocation(),
11073 FirstTemplate->getSourceRange(),
11074 FunctionTemplateParameterDifferentDefaultArgument)
11075 << FirstTemplate << (i + 1) << FirstTA;
11077 SecondModule, SecondTemplate->getLocation(),
11078 SecondTemplate->getSourceRange(),
11079 FunctionTemplateParameterDifferentDefaultArgument)
11080 << SecondTemplate << (i + 1) << SecondTA;
11081 ParameterMismatch = true;
11086 if (FirstTTPD->isParameterPack() !=
11087 SecondTTPD->isParameterPack()) {
11088 ODRDiagDeclError(FirstRecord, FirstModule,
11089 FirstTemplate->getLocation(),
11090 FirstTemplate->getSourceRange(),
11091 FunctionTemplatePackParameter)
11092 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11093 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11094 SecondTemplate->getSourceRange(),
11095 FunctionTemplatePackParameter)
11096 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11097 ParameterMismatch = true;
11102 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11103 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11104 NonTypeTemplateParmDecl *FirstNTTPD =
11105 cast<NonTypeTemplateParmDecl>(FirstParam);
11106 NonTypeTemplateParmDecl *SecondNTTPD =
11107 cast<NonTypeTemplateParmDecl>(SecondParam);
11109 QualType FirstType = FirstNTTPD->getType();
11110 QualType SecondType = SecondNTTPD->getType();
11111 if (ComputeQualTypeODRHash(FirstType) !=
11112 ComputeQualTypeODRHash(SecondType)) {
11113 ODRDiagDeclError(FirstRecord, FirstModule,
11114 FirstTemplate->getLocation(),
11115 FirstTemplate->getSourceRange(),
11116 FunctionTemplateParameterDifferentType)
11117 << FirstTemplate << (i + 1);
11118 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11119 SecondTemplate->getSourceRange(),
11120 FunctionTemplateParameterDifferentType)
11121 << SecondTemplate << (i + 1);
11122 ParameterMismatch = true;
11126 bool HasFirstDefaultArgument =
11127 FirstNTTPD->hasDefaultArgument() &&
11128 !FirstNTTPD->defaultArgumentWasInherited();
11129 bool HasSecondDefaultArgument =
11130 SecondNTTPD->hasDefaultArgument() &&
11131 !SecondNTTPD->defaultArgumentWasInherited();
11132 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11133 ODRDiagDeclError(FirstRecord, FirstModule,
11134 FirstTemplate->getLocation(),
11135 FirstTemplate->getSourceRange(),
11136 FunctionTemplateParameterSingleDefaultArgument)
11137 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11138 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11139 SecondTemplate->getSourceRange(),
11140 FunctionTemplateParameterSingleDefaultArgument)
11141 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11142 ParameterMismatch = true;
11146 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11147 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11148 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11149 if (ComputeODRHash(FirstDefaultArgument) !=
11150 ComputeODRHash(SecondDefaultArgument)) {
11152 FirstRecord, FirstModule, FirstTemplate->getLocation(),
11153 FirstTemplate->getSourceRange(),
11154 FunctionTemplateParameterDifferentDefaultArgument)
11155 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11157 SecondModule, SecondTemplate->getLocation(),
11158 SecondTemplate->getSourceRange(),
11159 FunctionTemplateParameterDifferentDefaultArgument)
11160 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11161 ParameterMismatch = true;
11166 if (FirstNTTPD->isParameterPack() !=
11167 SecondNTTPD->isParameterPack()) {
11168 ODRDiagDeclError(FirstRecord, FirstModule,
11169 FirstTemplate->getLocation(),
11170 FirstTemplate->getSourceRange(),
11171 FunctionTemplatePackParameter)
11172 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11173 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11174 SecondTemplate->getSourceRange(),
11175 FunctionTemplatePackParameter)
11176 << SecondTemplate << (i + 1)
11177 << SecondNTTPD->isParameterPack();
11178 ParameterMismatch = true;
11184 if (ParameterMismatch) {
11196 Diag(FirstDecl->getLocation(),
11197 diag::err_module_odr_violation_mismatch_decl_unknown)
11198 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11199 << FirstDecl->getSourceRange();
11200 Diag(SecondDecl->getLocation(),
11201 diag::note_module_odr_violation_mismatch_decl_unknown)
11202 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11207 // All definitions are updates to the same declaration. This happens if a
11208 // module instantiates the declaration of a class template specialization
11209 // and two or more other modules instantiate its definition.
11211 // FIXME: Indicate which modules had instantiations of this definition.
11212 // FIXME: How can this even happen?
11213 Diag(Merge.first->getLocation(),
11214 diag::err_module_odr_violation_different_instantiations)
11219 // Issue ODR failures diagnostics for functions.
11220 for (auto &Merge : FunctionOdrMergeFailures) {
11221 enum ODRFunctionDifference {
11225 ParameterSingleDefaultArgument,
11226 ParameterDifferentDefaultArgument,
11230 FunctionDecl *FirstFunction = Merge.first;
11231 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11233 bool Diagnosed = false;
11234 for (auto &SecondFunction : Merge.second) {
11236 if (FirstFunction == SecondFunction)
11239 std::string SecondModule =
11240 getOwningModuleNameForDiagnostic(SecondFunction);
11242 auto ODRDiagError = [FirstFunction, &FirstModule,
11243 this](SourceLocation Loc, SourceRange Range,
11244 ODRFunctionDifference DiffType) {
11245 return Diag(Loc, diag::err_module_odr_violation_function)
11246 << FirstFunction << FirstModule.empty() << FirstModule << Range
11249 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11251 ODRFunctionDifference DiffType) {
11252 return Diag(Loc, diag::note_module_odr_violation_function)
11253 << SecondModule << Range << DiffType;
11256 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11257 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11258 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11259 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11260 << FirstFunction->getReturnType();
11261 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11262 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11263 << SecondFunction->getReturnType();
11268 assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11269 "Merged functions with different number of parameters");
11271 auto ParamSize = FirstFunction->param_size();
11272 bool ParameterMismatch = false;
11273 for (unsigned I = 0; I < ParamSize; ++I) {
11274 auto *FirstParam = FirstFunction->getParamDecl(I);
11275 auto *SecondParam = SecondFunction->getParamDecl(I);
11277 assert(getContext().hasSameType(FirstParam->getType(),
11278 SecondParam->getType()) &&
11279 "Merged function has different parameter types.");
11281 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11282 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11284 << I + 1 << FirstParam->getDeclName();
11285 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11287 << I + 1 << SecondParam->getDeclName();
11288 ParameterMismatch = true;
11292 QualType FirstParamType = FirstParam->getType();
11293 QualType SecondParamType = SecondParam->getType();
11294 if (FirstParamType != SecondParamType &&
11295 ComputeQualTypeODRHash(FirstParamType) !=
11296 ComputeQualTypeODRHash(SecondParamType)) {
11297 if (const DecayedType *ParamDecayedType =
11298 FirstParamType->getAs<DecayedType>()) {
11299 ODRDiagError(FirstParam->getLocation(),
11300 FirstParam->getSourceRange(), ParameterType)
11301 << (I + 1) << FirstParamType << true
11302 << ParamDecayedType->getOriginalType();
11304 ODRDiagError(FirstParam->getLocation(),
11305 FirstParam->getSourceRange(), ParameterType)
11306 << (I + 1) << FirstParamType << false;
11309 if (const DecayedType *ParamDecayedType =
11310 SecondParamType->getAs<DecayedType>()) {
11311 ODRDiagNote(SecondParam->getLocation(),
11312 SecondParam->getSourceRange(), ParameterType)
11313 << (I + 1) << SecondParamType << true
11314 << ParamDecayedType->getOriginalType();
11316 ODRDiagNote(SecondParam->getLocation(),
11317 SecondParam->getSourceRange(), ParameterType)
11318 << (I + 1) << SecondParamType << false;
11320 ParameterMismatch = true;
11324 const Expr *FirstInit = FirstParam->getInit();
11325 const Expr *SecondInit = SecondParam->getInit();
11326 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11327 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11328 ParameterSingleDefaultArgument)
11329 << (I + 1) << (FirstInit == nullptr)
11330 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11331 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11332 ParameterSingleDefaultArgument)
11333 << (I + 1) << (SecondInit == nullptr)
11334 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11335 ParameterMismatch = true;
11339 if (FirstInit && SecondInit &&
11340 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11341 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11342 ParameterDifferentDefaultArgument)
11343 << (I + 1) << FirstInit->getSourceRange();
11344 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11345 ParameterDifferentDefaultArgument)
11346 << (I + 1) << SecondInit->getSourceRange();
11347 ParameterMismatch = true;
11351 assert(ComputeSubDeclODRHash(FirstParam) ==
11352 ComputeSubDeclODRHash(SecondParam) &&
11353 "Undiagnosed parameter difference.");
11356 if (ParameterMismatch) {
11361 // If no error has been generated before now, assume the problem is in
11362 // the body and generate a message.
11363 ODRDiagError(FirstFunction->getLocation(),
11364 FirstFunction->getSourceRange(), FunctionBody);
11365 ODRDiagNote(SecondFunction->getLocation(),
11366 SecondFunction->getSourceRange(), FunctionBody);
11371 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11374 // Issue ODR failures diagnostics for enums.
11375 for (auto &Merge : EnumOdrMergeFailures) {
11376 enum ODREnumDifference {
11378 EnumTagKeywordMismatch,
11379 SingleSpecifiedType,
11380 DifferentSpecifiedTypes,
11381 DifferentNumberEnumConstants,
11383 EnumConstantSingleInitilizer,
11384 EnumConstantDifferentInitilizer,
11387 // If we've already pointed out a specific problem with this enum, don't
11388 // bother issuing a general "something's different" diagnostic.
11389 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11392 EnumDecl *FirstEnum = Merge.first;
11393 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11396 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11397 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11398 DeclHashes &Hashes, EnumDecl *Enum) {
11399 for (auto *D : Enum->decls()) {
11400 // Due to decl merging, the first EnumDecl is the parent of
11401 // Decls in both records.
11402 if (!ODRHash::isDeclToBeProcessed(D, FirstEnum))
11404 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11405 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11406 ComputeSubDeclODRHash(D));
11409 DeclHashes FirstHashes;
11410 PopulateHashes(FirstHashes, FirstEnum);
11411 bool Diagnosed = false;
11412 for (auto &SecondEnum : Merge.second) {
11414 if (FirstEnum == SecondEnum)
11417 std::string SecondModule =
11418 getOwningModuleNameForDiagnostic(SecondEnum);
11420 auto ODRDiagError = [FirstEnum, &FirstModule,
11421 this](SourceLocation Loc, SourceRange Range,
11422 ODREnumDifference DiffType) {
11423 return Diag(Loc, diag::err_module_odr_violation_enum)
11424 << FirstEnum << FirstModule.empty() << FirstModule << Range
11427 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11429 ODREnumDifference DiffType) {
11430 return Diag(Loc, diag::note_module_odr_violation_enum)
11431 << SecondModule << Range << DiffType;
11434 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11435 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11437 << FirstEnum->isScoped();
11438 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11440 << SecondEnum->isScoped();
11445 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11446 if (FirstEnum->isScopedUsingClassTag() !=
11447 SecondEnum->isScopedUsingClassTag()) {
11448 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11449 EnumTagKeywordMismatch)
11450 << FirstEnum->isScopedUsingClassTag();
11451 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11452 EnumTagKeywordMismatch)
11453 << SecondEnum->isScopedUsingClassTag();
11459 QualType FirstUnderlyingType =
11460 FirstEnum->getIntegerTypeSourceInfo()
11461 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11463 QualType SecondUnderlyingType =
11464 SecondEnum->getIntegerTypeSourceInfo()
11465 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11467 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11468 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11469 SingleSpecifiedType)
11470 << !FirstUnderlyingType.isNull();
11471 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11472 SingleSpecifiedType)
11473 << !SecondUnderlyingType.isNull();
11478 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11479 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11480 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11481 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11482 DifferentSpecifiedTypes)
11483 << FirstUnderlyingType;
11484 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11485 DifferentSpecifiedTypes)
11486 << SecondUnderlyingType;
11492 DeclHashes SecondHashes;
11493 PopulateHashes(SecondHashes, SecondEnum);
11495 if (FirstHashes.size() != SecondHashes.size()) {
11496 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11497 DifferentNumberEnumConstants)
11498 << (int)FirstHashes.size();
11499 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11500 DifferentNumberEnumConstants)
11501 << (int)SecondHashes.size();
11506 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11507 if (FirstHashes[I].second == SecondHashes[I].second)
11509 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11510 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11512 if (FirstEnumConstant->getDeclName() !=
11513 SecondEnumConstant->getDeclName()) {
11515 ODRDiagError(FirstEnumConstant->getLocation(),
11516 FirstEnumConstant->getSourceRange(), EnumConstantName)
11517 << I + 1 << FirstEnumConstant;
11518 ODRDiagNote(SecondEnumConstant->getLocation(),
11519 SecondEnumConstant->getSourceRange(), EnumConstantName)
11520 << I + 1 << SecondEnumConstant;
11525 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11526 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11527 if (!FirstInit && !SecondInit)
11530 if (!FirstInit || !SecondInit) {
11531 ODRDiagError(FirstEnumConstant->getLocation(),
11532 FirstEnumConstant->getSourceRange(),
11533 EnumConstantSingleInitilizer)
11534 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11535 ODRDiagNote(SecondEnumConstant->getLocation(),
11536 SecondEnumConstant->getSourceRange(),
11537 EnumConstantSingleInitilizer)
11538 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11543 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11544 ODRDiagError(FirstEnumConstant->getLocation(),
11545 FirstEnumConstant->getSourceRange(),
11546 EnumConstantDifferentInitilizer)
11547 << I + 1 << FirstEnumConstant;
11548 ODRDiagNote(SecondEnumConstant->getLocation(),
11549 SecondEnumConstant->getSourceRange(),
11550 EnumConstantDifferentInitilizer)
11551 << I + 1 << SecondEnumConstant;
11559 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11563 void ASTReader::StartedDeserializing() {
11564 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11565 ReadTimer->startTimer();
11568 void ASTReader::FinishedDeserializing() {
11569 assert(NumCurrentElementsDeserializing &&
11570 "FinishedDeserializing not paired with StartedDeserializing");
11571 if (NumCurrentElementsDeserializing == 1) {
11572 // We decrease NumCurrentElementsDeserializing only after pending actions
11573 // are finished, to avoid recursively re-calling finishPendingActions().
11574 finishPendingActions();
11576 --NumCurrentElementsDeserializing;
11578 if (NumCurrentElementsDeserializing == 0) {
11579 // Propagate exception specification and deduced type updates along
11580 // redeclaration chains.
11582 // We do this now rather than in finishPendingActions because we want to
11583 // be able to walk the complete redeclaration chains of the updated decls.
11584 while (!PendingExceptionSpecUpdates.empty() ||
11585 !PendingDeducedTypeUpdates.empty()) {
11586 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
11587 PendingExceptionSpecUpdates.clear();
11588 for (auto Update : ESUpdates) {
11589 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11590 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11591 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11592 if (auto *Listener = getContext().getASTMutationListener())
11593 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11594 for (auto *Redecl : Update.second->redecls())
11595 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11598 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
11599 PendingDeducedTypeUpdates.clear();
11600 for (auto Update : DTUpdates) {
11601 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11602 // FIXME: If the return type is already deduced, check that it matches.
11603 getContext().adjustDeducedFunctionResultType(Update.first,
11609 ReadTimer->stopTimer();
11611 diagnoseOdrViolations();
11613 // We are not in recursive loading, so it's safe to pass the "interesting"
11614 // decls to the consumer.
11616 PassInterestingDeclsToConsumer();
11620 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11621 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11622 // Remove any fake results before adding any real ones.
11623 auto It = PendingFakeLookupResults.find(II);
11624 if (It != PendingFakeLookupResults.end()) {
11625 for (auto *ND : It->second)
11626 SemaObj->IdResolver.RemoveDecl(ND);
11627 // FIXME: this works around module+PCH performance issue.
11628 // Rather than erase the result from the map, which is O(n), just clear
11629 // the vector of NamedDecls.
11630 It->second.clear();
11634 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11635 SemaObj->TUScope->AddDecl(D);
11636 } else if (SemaObj->TUScope) {
11637 // Adding the decl to IdResolver may have failed because it was already in
11638 // (even though it was not added in scope). If it is already in, make sure
11639 // it gets in the scope as well.
11640 if (std::find(SemaObj->IdResolver.begin(Name),
11641 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11642 SemaObj->TUScope->AddDecl(D);
11646 ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
11647 ASTContext *Context,
11648 const PCHContainerReader &PCHContainerRdr,
11649 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11650 StringRef isysroot,
11651 DisableValidationForModuleKind DisableValidationKind,
11652 bool AllowASTWithCompilerErrors,
11653 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11654 bool ValidateASTInputFilesContent, bool UseGlobalIndex,
11655 std::unique_ptr<llvm::Timer> ReadTimer)
11656 : Listener(bool(DisableValidationKind &DisableValidationForModuleKind::PCH)
11657 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11658 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11659 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11660 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11661 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
11662 PCHContainerRdr, PP.getHeaderSearchInfo()),
11663 DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11664 DisableValidationKind(DisableValidationKind),
11665 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11666 AllowConfigurationMismatch(AllowConfigurationMismatch),
11667 ValidateSystemInputs(ValidateSystemInputs),
11668 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
11669 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11670 SourceMgr.setExternalSLocEntrySource(this);
11672 for (const auto &Ext : Extensions) {
11673 auto BlockName = Ext->getExtensionMetadata().BlockName;
11674 auto Known = ModuleFileExtensions.find(BlockName);
11675 if (Known != ModuleFileExtensions.end()) {
11676 Diags.Report(diag::warn_duplicate_module_file_extension)
11681 ModuleFileExtensions.insert({BlockName, Ext});
11685 ASTReader::~ASTReader() {
11686 if (OwnsDeserializationListener)
11687 delete DeserializationListener;
11690 IdentifierResolver &ASTReader::getIdResolver() {
11691 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11694 Expected<unsigned> ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11695 unsigned AbbrevID) {
11698 return Cursor.readRecord(AbbrevID, Record);
11700 //===----------------------------------------------------------------------===//
11701 //// OMPClauseReader implementation
11702 ////===----------------------------------------------------------------------===//
11704 // This has to be in namespace clang because it's friended by all
11705 // of the OMP clauses.
11708 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
11709 ASTRecordReader &Record;
11710 ASTContext &Context;
11713 OMPClauseReader(ASTRecordReader &Record)
11714 : Record(Record), Context(Record.getContext()) {}
11715 #define GEN_CLANG_CLAUSE_CLASS
11716 #define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
11717 #include "llvm/Frontend/OpenMP/OMP.inc"
11718 OMPClause *readClause();
11719 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
11720 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
11723 } // end namespace clang
11725 OMPClause *ASTRecordReader::readOMPClause() {
11726 return OMPClauseReader(*this).readClause();
11729 OMPClause *OMPClauseReader::readClause() {
11730 OMPClause *C = nullptr;
11731 switch (llvm::omp::Clause(Record.readInt())) {
11732 case llvm::omp::OMPC_if:
11733 C = new (Context) OMPIfClause();
11735 case llvm::omp::OMPC_final:
11736 C = new (Context) OMPFinalClause();
11738 case llvm::omp::OMPC_num_threads:
11739 C = new (Context) OMPNumThreadsClause();
11741 case llvm::omp::OMPC_safelen:
11742 C = new (Context) OMPSafelenClause();
11744 case llvm::omp::OMPC_simdlen:
11745 C = new (Context) OMPSimdlenClause();
11747 case llvm::omp::OMPC_sizes: {
11748 unsigned NumSizes = Record.readInt();
11749 C = OMPSizesClause::CreateEmpty(Context, NumSizes);
11752 case llvm::omp::OMPC_full:
11753 C = OMPFullClause::CreateEmpty(Context);
11755 case llvm::omp::OMPC_partial:
11756 C = OMPPartialClause::CreateEmpty(Context);
11758 case llvm::omp::OMPC_allocator:
11759 C = new (Context) OMPAllocatorClause();
11761 case llvm::omp::OMPC_collapse:
11762 C = new (Context) OMPCollapseClause();
11764 case llvm::omp::OMPC_default:
11765 C = new (Context) OMPDefaultClause();
11767 case llvm::omp::OMPC_proc_bind:
11768 C = new (Context) OMPProcBindClause();
11770 case llvm::omp::OMPC_schedule:
11771 C = new (Context) OMPScheduleClause();
11773 case llvm::omp::OMPC_ordered:
11774 C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
11776 case llvm::omp::OMPC_nowait:
11777 C = new (Context) OMPNowaitClause();
11779 case llvm::omp::OMPC_untied:
11780 C = new (Context) OMPUntiedClause();
11782 case llvm::omp::OMPC_mergeable:
11783 C = new (Context) OMPMergeableClause();
11785 case llvm::omp::OMPC_read:
11786 C = new (Context) OMPReadClause();
11788 case llvm::omp::OMPC_write:
11789 C = new (Context) OMPWriteClause();
11791 case llvm::omp::OMPC_update:
11792 C = OMPUpdateClause::CreateEmpty(Context, Record.readInt());
11794 case llvm::omp::OMPC_capture:
11795 C = new (Context) OMPCaptureClause();
11797 case llvm::omp::OMPC_seq_cst:
11798 C = new (Context) OMPSeqCstClause();
11800 case llvm::omp::OMPC_acq_rel:
11801 C = new (Context) OMPAcqRelClause();
11803 case llvm::omp::OMPC_acquire:
11804 C = new (Context) OMPAcquireClause();
11806 case llvm::omp::OMPC_release:
11807 C = new (Context) OMPReleaseClause();
11809 case llvm::omp::OMPC_relaxed:
11810 C = new (Context) OMPRelaxedClause();
11812 case llvm::omp::OMPC_threads:
11813 C = new (Context) OMPThreadsClause();
11815 case llvm::omp::OMPC_simd:
11816 C = new (Context) OMPSIMDClause();
11818 case llvm::omp::OMPC_nogroup:
11819 C = new (Context) OMPNogroupClause();
11821 case llvm::omp::OMPC_unified_address:
11822 C = new (Context) OMPUnifiedAddressClause();
11824 case llvm::omp::OMPC_unified_shared_memory:
11825 C = new (Context) OMPUnifiedSharedMemoryClause();
11827 case llvm::omp::OMPC_reverse_offload:
11828 C = new (Context) OMPReverseOffloadClause();
11830 case llvm::omp::OMPC_dynamic_allocators:
11831 C = new (Context) OMPDynamicAllocatorsClause();
11833 case llvm::omp::OMPC_atomic_default_mem_order:
11834 C = new (Context) OMPAtomicDefaultMemOrderClause();
11836 case llvm::omp::OMPC_private:
11837 C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
11839 case llvm::omp::OMPC_firstprivate:
11840 C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
11842 case llvm::omp::OMPC_lastprivate:
11843 C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
11845 case llvm::omp::OMPC_shared:
11846 C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
11848 case llvm::omp::OMPC_reduction: {
11849 unsigned N = Record.readInt();
11850 auto Modifier = Record.readEnum<OpenMPReductionClauseModifier>();
11851 C = OMPReductionClause::CreateEmpty(Context, N, Modifier);
11854 case llvm::omp::OMPC_task_reduction:
11855 C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
11857 case llvm::omp::OMPC_in_reduction:
11858 C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
11860 case llvm::omp::OMPC_linear:
11861 C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
11863 case llvm::omp::OMPC_aligned:
11864 C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
11866 case llvm::omp::OMPC_copyin:
11867 C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
11869 case llvm::omp::OMPC_copyprivate:
11870 C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
11872 case llvm::omp::OMPC_flush:
11873 C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
11875 case llvm::omp::OMPC_depobj:
11876 C = OMPDepobjClause::CreateEmpty(Context);
11878 case llvm::omp::OMPC_depend: {
11879 unsigned NumVars = Record.readInt();
11880 unsigned NumLoops = Record.readInt();
11881 C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
11884 case llvm::omp::OMPC_device:
11885 C = new (Context) OMPDeviceClause();
11887 case llvm::omp::OMPC_map: {
11888 OMPMappableExprListSizeTy Sizes;
11889 Sizes.NumVars = Record.readInt();
11890 Sizes.NumUniqueDeclarations = Record.readInt();
11891 Sizes.NumComponentLists = Record.readInt();
11892 Sizes.NumComponents = Record.readInt();
11893 C = OMPMapClause::CreateEmpty(Context, Sizes);
11896 case llvm::omp::OMPC_num_teams:
11897 C = new (Context) OMPNumTeamsClause();
11899 case llvm::omp::OMPC_thread_limit:
11900 C = new (Context) OMPThreadLimitClause();
11902 case llvm::omp::OMPC_priority:
11903 C = new (Context) OMPPriorityClause();
11905 case llvm::omp::OMPC_grainsize:
11906 C = new (Context) OMPGrainsizeClause();
11908 case llvm::omp::OMPC_num_tasks:
11909 C = new (Context) OMPNumTasksClause();
11911 case llvm::omp::OMPC_hint:
11912 C = new (Context) OMPHintClause();
11914 case llvm::omp::OMPC_dist_schedule:
11915 C = new (Context) OMPDistScheduleClause();
11917 case llvm::omp::OMPC_defaultmap:
11918 C = new (Context) OMPDefaultmapClause();
11920 case llvm::omp::OMPC_to: {
11921 OMPMappableExprListSizeTy Sizes;
11922 Sizes.NumVars = Record.readInt();
11923 Sizes.NumUniqueDeclarations = Record.readInt();
11924 Sizes.NumComponentLists = Record.readInt();
11925 Sizes.NumComponents = Record.readInt();
11926 C = OMPToClause::CreateEmpty(Context, Sizes);
11929 case llvm::omp::OMPC_from: {
11930 OMPMappableExprListSizeTy Sizes;
11931 Sizes.NumVars = Record.readInt();
11932 Sizes.NumUniqueDeclarations = Record.readInt();
11933 Sizes.NumComponentLists = Record.readInt();
11934 Sizes.NumComponents = Record.readInt();
11935 C = OMPFromClause::CreateEmpty(Context, Sizes);
11938 case llvm::omp::OMPC_use_device_ptr: {
11939 OMPMappableExprListSizeTy Sizes;
11940 Sizes.NumVars = Record.readInt();
11941 Sizes.NumUniqueDeclarations = Record.readInt();
11942 Sizes.NumComponentLists = Record.readInt();
11943 Sizes.NumComponents = Record.readInt();
11944 C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
11947 case llvm::omp::OMPC_use_device_addr: {
11948 OMPMappableExprListSizeTy Sizes;
11949 Sizes.NumVars = Record.readInt();
11950 Sizes.NumUniqueDeclarations = Record.readInt();
11951 Sizes.NumComponentLists = Record.readInt();
11952 Sizes.NumComponents = Record.readInt();
11953 C = OMPUseDeviceAddrClause::CreateEmpty(Context, Sizes);
11956 case llvm::omp::OMPC_is_device_ptr: {
11957 OMPMappableExprListSizeTy Sizes;
11958 Sizes.NumVars = Record.readInt();
11959 Sizes.NumUniqueDeclarations = Record.readInt();
11960 Sizes.NumComponentLists = Record.readInt();
11961 Sizes.NumComponents = Record.readInt();
11962 C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
11965 case llvm::omp::OMPC_allocate:
11966 C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
11968 case llvm::omp::OMPC_nontemporal:
11969 C = OMPNontemporalClause::CreateEmpty(Context, Record.readInt());
11971 case llvm::omp::OMPC_inclusive:
11972 C = OMPInclusiveClause::CreateEmpty(Context, Record.readInt());
11974 case llvm::omp::OMPC_exclusive:
11975 C = OMPExclusiveClause::CreateEmpty(Context, Record.readInt());
11977 case llvm::omp::OMPC_order:
11978 C = new (Context) OMPOrderClause();
11980 case llvm::omp::OMPC_init:
11981 C = OMPInitClause::CreateEmpty(Context, Record.readInt());
11983 case llvm::omp::OMPC_use:
11984 C = new (Context) OMPUseClause();
11986 case llvm::omp::OMPC_destroy:
11987 C = new (Context) OMPDestroyClause();
11989 case llvm::omp::OMPC_novariants:
11990 C = new (Context) OMPNovariantsClause();
11992 case llvm::omp::OMPC_nocontext:
11993 C = new (Context) OMPNocontextClause();
11995 case llvm::omp::OMPC_detach:
11996 C = new (Context) OMPDetachClause();
11998 case llvm::omp::OMPC_uses_allocators:
11999 C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
12001 case llvm::omp::OMPC_affinity:
12002 C = OMPAffinityClause::CreateEmpty(Context, Record.readInt());
12004 case llvm::omp::OMPC_filter:
12005 C = new (Context) OMPFilterClause();
12007 #define OMP_CLAUSE_NO_CLASS(Enum, Str) \
12008 case llvm::omp::Enum: \
12010 #include "llvm/Frontend/OpenMP/OMPKinds.def"
12014 assert(C && "Unknown OMPClause type");
12017 C->setLocStart(Record.readSourceLocation());
12018 C->setLocEnd(Record.readSourceLocation());
12023 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
12024 C->setPreInitStmt(Record.readSubStmt(),
12025 static_cast<OpenMPDirectiveKind>(Record.readInt()));
12028 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
12029 VisitOMPClauseWithPreInit(C);
12030 C->setPostUpdateExpr(Record.readSubExpr());
12033 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
12034 VisitOMPClauseWithPreInit(C);
12035 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
12036 C->setNameModifierLoc(Record.readSourceLocation());
12037 C->setColonLoc(Record.readSourceLocation());
12038 C->setCondition(Record.readSubExpr());
12039 C->setLParenLoc(Record.readSourceLocation());
12042 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
12043 VisitOMPClauseWithPreInit(C);
12044 C->setCondition(Record.readSubExpr());
12045 C->setLParenLoc(Record.readSourceLocation());
12048 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
12049 VisitOMPClauseWithPreInit(C);
12050 C->setNumThreads(Record.readSubExpr());
12051 C->setLParenLoc(Record.readSourceLocation());
12054 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
12055 C->setSafelen(Record.readSubExpr());
12056 C->setLParenLoc(Record.readSourceLocation());
12059 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
12060 C->setSimdlen(Record.readSubExpr());
12061 C->setLParenLoc(Record.readSourceLocation());
12064 void OMPClauseReader::VisitOMPSizesClause(OMPSizesClause *C) {
12065 for (Expr *&E : C->getSizesRefs())
12066 E = Record.readSubExpr();
12067 C->setLParenLoc(Record.readSourceLocation());
12070 void OMPClauseReader::VisitOMPFullClause(OMPFullClause *C) {}
12072 void OMPClauseReader::VisitOMPPartialClause(OMPPartialClause *C) {
12073 C->setFactor(Record.readSubExpr());
12074 C->setLParenLoc(Record.readSourceLocation());
12077 void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
12078 C->setAllocator(Record.readExpr());
12079 C->setLParenLoc(Record.readSourceLocation());
12082 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
12083 C->setNumForLoops(Record.readSubExpr());
12084 C->setLParenLoc(Record.readSourceLocation());
12087 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
12088 C->setDefaultKind(static_cast<llvm::omp::DefaultKind>(Record.readInt()));
12089 C->setLParenLoc(Record.readSourceLocation());
12090 C->setDefaultKindKwLoc(Record.readSourceLocation());
12093 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
12094 C->setProcBindKind(static_cast<llvm::omp::ProcBindKind>(Record.readInt()));
12095 C->setLParenLoc(Record.readSourceLocation());
12096 C->setProcBindKindKwLoc(Record.readSourceLocation());
12099 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
12100 VisitOMPClauseWithPreInit(C);
12101 C->setScheduleKind(
12102 static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
12103 C->setFirstScheduleModifier(
12104 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12105 C->setSecondScheduleModifier(
12106 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12107 C->setChunkSize(Record.readSubExpr());
12108 C->setLParenLoc(Record.readSourceLocation());
12109 C->setFirstScheduleModifierLoc(Record.readSourceLocation());
12110 C->setSecondScheduleModifierLoc(Record.readSourceLocation());
12111 C->setScheduleKindLoc(Record.readSourceLocation());
12112 C->setCommaLoc(Record.readSourceLocation());
12115 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
12116 C->setNumForLoops(Record.readSubExpr());
12117 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12118 C->setLoopNumIterations(I, Record.readSubExpr());
12119 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12120 C->setLoopCounter(I, Record.readSubExpr());
12121 C->setLParenLoc(Record.readSourceLocation());
12124 void OMPClauseReader::VisitOMPDetachClause(OMPDetachClause *C) {
12125 C->setEventHandler(Record.readSubExpr());
12126 C->setLParenLoc(Record.readSourceLocation());
12129 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
12131 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
12133 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
12135 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
12137 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
12139 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *C) {
12140 if (C->isExtended()) {
12141 C->setLParenLoc(Record.readSourceLocation());
12142 C->setArgumentLoc(Record.readSourceLocation());
12143 C->setDependencyKind(Record.readEnum<OpenMPDependClauseKind>());
12147 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
12149 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
12151 void OMPClauseReader::VisitOMPAcqRelClause(OMPAcqRelClause *) {}
12153 void OMPClauseReader::VisitOMPAcquireClause(OMPAcquireClause *) {}
12155 void OMPClauseReader::VisitOMPReleaseClause(OMPReleaseClause *) {}
12157 void OMPClauseReader::VisitOMPRelaxedClause(OMPRelaxedClause *) {}
12159 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
12161 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
12163 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
12165 void OMPClauseReader::VisitOMPInitClause(OMPInitClause *C) {
12166 unsigned NumVars = C->varlist_size();
12167 SmallVector<Expr *, 16> Vars;
12168 Vars.reserve(NumVars);
12169 for (unsigned I = 0; I != NumVars; ++I)
12170 Vars.push_back(Record.readSubExpr());
12171 C->setVarRefs(Vars);
12172 C->setIsTarget(Record.readBool());
12173 C->setIsTargetSync(Record.readBool());
12174 C->setLParenLoc(Record.readSourceLocation());
12175 C->setVarLoc(Record.readSourceLocation());
12178 void OMPClauseReader::VisitOMPUseClause(OMPUseClause *C) {
12179 C->setInteropVar(Record.readSubExpr());
12180 C->setLParenLoc(Record.readSourceLocation());
12181 C->setVarLoc(Record.readSourceLocation());
12184 void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *C) {
12185 C->setInteropVar(Record.readSubExpr());
12186 C->setLParenLoc(Record.readSourceLocation());
12187 C->setVarLoc(Record.readSourceLocation());
12190 void OMPClauseReader::VisitOMPNovariantsClause(OMPNovariantsClause *C) {
12191 VisitOMPClauseWithPreInit(C);
12192 C->setCondition(Record.readSubExpr());
12193 C->setLParenLoc(Record.readSourceLocation());
12196 void OMPClauseReader::VisitOMPNocontextClause(OMPNocontextClause *C) {
12197 VisitOMPClauseWithPreInit(C);
12198 C->setCondition(Record.readSubExpr());
12199 C->setLParenLoc(Record.readSourceLocation());
12202 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
12204 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
12205 OMPUnifiedSharedMemoryClause *) {}
12207 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
12210 OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
12213 void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
12214 OMPAtomicDefaultMemOrderClause *C) {
12215 C->setAtomicDefaultMemOrderKind(
12216 static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
12217 C->setLParenLoc(Record.readSourceLocation());
12218 C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
12221 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
12222 C->setLParenLoc(Record.readSourceLocation());
12223 unsigned NumVars = C->varlist_size();
12224 SmallVector<Expr *, 16> Vars;
12225 Vars.reserve(NumVars);
12226 for (unsigned i = 0; i != NumVars; ++i)
12227 Vars.push_back(Record.readSubExpr());
12228 C->setVarRefs(Vars);
12230 for (unsigned i = 0; i != NumVars; ++i)
12231 Vars.push_back(Record.readSubExpr());
12232 C->setPrivateCopies(Vars);
12235 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
12236 VisitOMPClauseWithPreInit(C);
12237 C->setLParenLoc(Record.readSourceLocation());
12238 unsigned NumVars = C->varlist_size();
12239 SmallVector<Expr *, 16> Vars;
12240 Vars.reserve(NumVars);
12241 for (unsigned i = 0; i != NumVars; ++i)
12242 Vars.push_back(Record.readSubExpr());
12243 C->setVarRefs(Vars);
12245 for (unsigned i = 0; i != NumVars; ++i)
12246 Vars.push_back(Record.readSubExpr());
12247 C->setPrivateCopies(Vars);
12249 for (unsigned i = 0; i != NumVars; ++i)
12250 Vars.push_back(Record.readSubExpr());
12254 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
12255 VisitOMPClauseWithPostUpdate(C);
12256 C->setLParenLoc(Record.readSourceLocation());
12257 C->setKind(Record.readEnum<OpenMPLastprivateModifier>());
12258 C->setKindLoc(Record.readSourceLocation());
12259 C->setColonLoc(Record.readSourceLocation());
12260 unsigned NumVars = C->varlist_size();
12261 SmallVector<Expr *, 16> Vars;
12262 Vars.reserve(NumVars);
12263 for (unsigned i = 0; i != NumVars; ++i)
12264 Vars.push_back(Record.readSubExpr());
12265 C->setVarRefs(Vars);
12267 for (unsigned i = 0; i != NumVars; ++i)
12268 Vars.push_back(Record.readSubExpr());
12269 C->setPrivateCopies(Vars);
12271 for (unsigned i = 0; i != NumVars; ++i)
12272 Vars.push_back(Record.readSubExpr());
12273 C->setSourceExprs(Vars);
12275 for (unsigned i = 0; i != NumVars; ++i)
12276 Vars.push_back(Record.readSubExpr());
12277 C->setDestinationExprs(Vars);
12279 for (unsigned i = 0; i != NumVars; ++i)
12280 Vars.push_back(Record.readSubExpr());
12281 C->setAssignmentOps(Vars);
12284 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
12285 C->setLParenLoc(Record.readSourceLocation());
12286 unsigned NumVars = C->varlist_size();
12287 SmallVector<Expr *, 16> Vars;
12288 Vars.reserve(NumVars);
12289 for (unsigned i = 0; i != NumVars; ++i)
12290 Vars.push_back(Record.readSubExpr());
12291 C->setVarRefs(Vars);
12294 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
12295 VisitOMPClauseWithPostUpdate(C);
12296 C->setLParenLoc(Record.readSourceLocation());
12297 C->setModifierLoc(Record.readSourceLocation());
12298 C->setColonLoc(Record.readSourceLocation());
12299 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12300 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12301 C->setQualifierLoc(NNSL);
12302 C->setNameInfo(DNI);
12304 unsigned NumVars = C->varlist_size();
12305 SmallVector<Expr *, 16> Vars;
12306 Vars.reserve(NumVars);
12307 for (unsigned i = 0; i != NumVars; ++i)
12308 Vars.push_back(Record.readSubExpr());
12309 C->setVarRefs(Vars);
12311 for (unsigned i = 0; i != NumVars; ++i)
12312 Vars.push_back(Record.readSubExpr());
12313 C->setPrivates(Vars);
12315 for (unsigned i = 0; i != NumVars; ++i)
12316 Vars.push_back(Record.readSubExpr());
12317 C->setLHSExprs(Vars);
12319 for (unsigned i = 0; i != NumVars; ++i)
12320 Vars.push_back(Record.readSubExpr());
12321 C->setRHSExprs(Vars);
12323 for (unsigned i = 0; i != NumVars; ++i)
12324 Vars.push_back(Record.readSubExpr());
12325 C->setReductionOps(Vars);
12326 if (C->getModifier() == OMPC_REDUCTION_inscan) {
12328 for (unsigned i = 0; i != NumVars; ++i)
12329 Vars.push_back(Record.readSubExpr());
12330 C->setInscanCopyOps(Vars);
12332 for (unsigned i = 0; i != NumVars; ++i)
12333 Vars.push_back(Record.readSubExpr());
12334 C->setInscanCopyArrayTemps(Vars);
12336 for (unsigned i = 0; i != NumVars; ++i)
12337 Vars.push_back(Record.readSubExpr());
12338 C->setInscanCopyArrayElems(Vars);
12342 void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
12343 VisitOMPClauseWithPostUpdate(C);
12344 C->setLParenLoc(Record.readSourceLocation());
12345 C->setColonLoc(Record.readSourceLocation());
12346 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12347 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12348 C->setQualifierLoc(NNSL);
12349 C->setNameInfo(DNI);
12351 unsigned NumVars = C->varlist_size();
12352 SmallVector<Expr *, 16> Vars;
12353 Vars.reserve(NumVars);
12354 for (unsigned I = 0; I != NumVars; ++I)
12355 Vars.push_back(Record.readSubExpr());
12356 C->setVarRefs(Vars);
12358 for (unsigned I = 0; I != NumVars; ++I)
12359 Vars.push_back(Record.readSubExpr());
12360 C->setPrivates(Vars);
12362 for (unsigned I = 0; I != NumVars; ++I)
12363 Vars.push_back(Record.readSubExpr());
12364 C->setLHSExprs(Vars);
12366 for (unsigned I = 0; I != NumVars; ++I)
12367 Vars.push_back(Record.readSubExpr());
12368 C->setRHSExprs(Vars);
12370 for (unsigned I = 0; I != NumVars; ++I)
12371 Vars.push_back(Record.readSubExpr());
12372 C->setReductionOps(Vars);
12375 void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
12376 VisitOMPClauseWithPostUpdate(C);
12377 C->setLParenLoc(Record.readSourceLocation());
12378 C->setColonLoc(Record.readSourceLocation());
12379 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12380 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12381 C->setQualifierLoc(NNSL);
12382 C->setNameInfo(DNI);
12384 unsigned NumVars = C->varlist_size();
12385 SmallVector<Expr *, 16> Vars;
12386 Vars.reserve(NumVars);
12387 for (unsigned I = 0; I != NumVars; ++I)
12388 Vars.push_back(Record.readSubExpr());
12389 C->setVarRefs(Vars);
12391 for (unsigned I = 0; I != NumVars; ++I)
12392 Vars.push_back(Record.readSubExpr());
12393 C->setPrivates(Vars);
12395 for (unsigned I = 0; I != NumVars; ++I)
12396 Vars.push_back(Record.readSubExpr());
12397 C->setLHSExprs(Vars);
12399 for (unsigned I = 0; I != NumVars; ++I)
12400 Vars.push_back(Record.readSubExpr());
12401 C->setRHSExprs(Vars);
12403 for (unsigned I = 0; I != NumVars; ++I)
12404 Vars.push_back(Record.readSubExpr());
12405 C->setReductionOps(Vars);
12407 for (unsigned I = 0; I != NumVars; ++I)
12408 Vars.push_back(Record.readSubExpr());
12409 C->setTaskgroupDescriptors(Vars);
12412 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
12413 VisitOMPClauseWithPostUpdate(C);
12414 C->setLParenLoc(Record.readSourceLocation());
12415 C->setColonLoc(Record.readSourceLocation());
12416 C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
12417 C->setModifierLoc(Record.readSourceLocation());
12418 unsigned NumVars = C->varlist_size();
12419 SmallVector<Expr *, 16> Vars;
12420 Vars.reserve(NumVars);
12421 for (unsigned i = 0; i != NumVars; ++i)
12422 Vars.push_back(Record.readSubExpr());
12423 C->setVarRefs(Vars);
12425 for (unsigned i = 0; i != NumVars; ++i)
12426 Vars.push_back(Record.readSubExpr());
12427 C->setPrivates(Vars);
12429 for (unsigned i = 0; i != NumVars; ++i)
12430 Vars.push_back(Record.readSubExpr());
12433 for (unsigned i = 0; i != NumVars; ++i)
12434 Vars.push_back(Record.readSubExpr());
12435 C->setUpdates(Vars);
12437 for (unsigned i = 0; i != NumVars; ++i)
12438 Vars.push_back(Record.readSubExpr());
12439 C->setFinals(Vars);
12440 C->setStep(Record.readSubExpr());
12441 C->setCalcStep(Record.readSubExpr());
12443 for (unsigned I = 0; I != NumVars + 1; ++I)
12444 Vars.push_back(Record.readSubExpr());
12445 C->setUsedExprs(Vars);
12448 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
12449 C->setLParenLoc(Record.readSourceLocation());
12450 C->setColonLoc(Record.readSourceLocation());
12451 unsigned NumVars = C->varlist_size();
12452 SmallVector<Expr *, 16> Vars;
12453 Vars.reserve(NumVars);
12454 for (unsigned i = 0; i != NumVars; ++i)
12455 Vars.push_back(Record.readSubExpr());
12456 C->setVarRefs(Vars);
12457 C->setAlignment(Record.readSubExpr());
12460 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
12461 C->setLParenLoc(Record.readSourceLocation());
12462 unsigned NumVars = C->varlist_size();
12463 SmallVector<Expr *, 16> Exprs;
12464 Exprs.reserve(NumVars);
12465 for (unsigned i = 0; i != NumVars; ++i)
12466 Exprs.push_back(Record.readSubExpr());
12467 C->setVarRefs(Exprs);
12469 for (unsigned i = 0; i != NumVars; ++i)
12470 Exprs.push_back(Record.readSubExpr());
12471 C->setSourceExprs(Exprs);
12473 for (unsigned i = 0; i != NumVars; ++i)
12474 Exprs.push_back(Record.readSubExpr());
12475 C->setDestinationExprs(Exprs);
12477 for (unsigned i = 0; i != NumVars; ++i)
12478 Exprs.push_back(Record.readSubExpr());
12479 C->setAssignmentOps(Exprs);
12482 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
12483 C->setLParenLoc(Record.readSourceLocation());
12484 unsigned NumVars = C->varlist_size();
12485 SmallVector<Expr *, 16> Exprs;
12486 Exprs.reserve(NumVars);
12487 for (unsigned i = 0; i != NumVars; ++i)
12488 Exprs.push_back(Record.readSubExpr());
12489 C->setVarRefs(Exprs);
12491 for (unsigned i = 0; i != NumVars; ++i)
12492 Exprs.push_back(Record.readSubExpr());
12493 C->setSourceExprs(Exprs);
12495 for (unsigned i = 0; i != NumVars; ++i)
12496 Exprs.push_back(Record.readSubExpr());
12497 C->setDestinationExprs(Exprs);
12499 for (unsigned i = 0; i != NumVars; ++i)
12500 Exprs.push_back(Record.readSubExpr());
12501 C->setAssignmentOps(Exprs);
12504 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
12505 C->setLParenLoc(Record.readSourceLocation());
12506 unsigned NumVars = C->varlist_size();
12507 SmallVector<Expr *, 16> Vars;
12508 Vars.reserve(NumVars);
12509 for (unsigned i = 0; i != NumVars; ++i)
12510 Vars.push_back(Record.readSubExpr());
12511 C->setVarRefs(Vars);
12514 void OMPClauseReader::VisitOMPDepobjClause(OMPDepobjClause *C) {
12515 C->setDepobj(Record.readSubExpr());
12516 C->setLParenLoc(Record.readSourceLocation());
12519 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
12520 C->setLParenLoc(Record.readSourceLocation());
12521 C->setModifier(Record.readSubExpr());
12522 C->setDependencyKind(
12523 static_cast<OpenMPDependClauseKind>(Record.readInt()));
12524 C->setDependencyLoc(Record.readSourceLocation());
12525 C->setColonLoc(Record.readSourceLocation());
12526 unsigned NumVars = C->varlist_size();
12527 SmallVector<Expr *, 16> Vars;
12528 Vars.reserve(NumVars);
12529 for (unsigned I = 0; I != NumVars; ++I)
12530 Vars.push_back(Record.readSubExpr());
12531 C->setVarRefs(Vars);
12532 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
12533 C->setLoopData(I, Record.readSubExpr());
12536 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
12537 VisitOMPClauseWithPreInit(C);
12538 C->setModifier(Record.readEnum<OpenMPDeviceClauseModifier>());
12539 C->setDevice(Record.readSubExpr());
12540 C->setModifierLoc(Record.readSourceLocation());
12541 C->setLParenLoc(Record.readSourceLocation());
12544 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
12545 C->setLParenLoc(Record.readSourceLocation());
12546 for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) {
12547 C->setMapTypeModifier(
12548 I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
12549 C->setMapTypeModifierLoc(I, Record.readSourceLocation());
12551 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12552 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12554 static_cast<OpenMPMapClauseKind>(Record.readInt()));
12555 C->setMapLoc(Record.readSourceLocation());
12556 C->setColonLoc(Record.readSourceLocation());
12557 auto NumVars = C->varlist_size();
12558 auto UniqueDecls = C->getUniqueDeclarationsNum();
12559 auto TotalLists = C->getTotalComponentListNum();
12560 auto TotalComponents = C->getTotalComponentsNum();
12562 SmallVector<Expr *, 16> Vars;
12563 Vars.reserve(NumVars);
12564 for (unsigned i = 0; i != NumVars; ++i)
12565 Vars.push_back(Record.readExpr());
12566 C->setVarRefs(Vars);
12568 SmallVector<Expr *, 16> UDMappers;
12569 UDMappers.reserve(NumVars);
12570 for (unsigned I = 0; I < NumVars; ++I)
12571 UDMappers.push_back(Record.readExpr());
12572 C->setUDMapperRefs(UDMappers);
12574 SmallVector<ValueDecl *, 16> Decls;
12575 Decls.reserve(UniqueDecls);
12576 for (unsigned i = 0; i < UniqueDecls; ++i)
12577 Decls.push_back(Record.readDeclAs<ValueDecl>());
12578 C->setUniqueDecls(Decls);
12580 SmallVector<unsigned, 16> ListsPerDecl;
12581 ListsPerDecl.reserve(UniqueDecls);
12582 for (unsigned i = 0; i < UniqueDecls; ++i)
12583 ListsPerDecl.push_back(Record.readInt());
12584 C->setDeclNumLists(ListsPerDecl);
12586 SmallVector<unsigned, 32> ListSizes;
12587 ListSizes.reserve(TotalLists);
12588 for (unsigned i = 0; i < TotalLists; ++i)
12589 ListSizes.push_back(Record.readInt());
12590 C->setComponentListSizes(ListSizes);
12592 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12593 Components.reserve(TotalComponents);
12594 for (unsigned i = 0; i < TotalComponents; ++i) {
12595 Expr *AssociatedExprPr = Record.readExpr();
12596 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12597 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
12598 /*IsNonContiguous=*/false);
12600 C->setComponents(Components, ListSizes);
12603 void OMPClauseReader::VisitOMPAllocateClause(OMPAllocateClause *C) {
12604 C->setLParenLoc(Record.readSourceLocation());
12605 C->setColonLoc(Record.readSourceLocation());
12606 C->setAllocator(Record.readSubExpr());
12607 unsigned NumVars = C->varlist_size();
12608 SmallVector<Expr *, 16> Vars;
12609 Vars.reserve(NumVars);
12610 for (unsigned i = 0; i != NumVars; ++i)
12611 Vars.push_back(Record.readSubExpr());
12612 C->setVarRefs(Vars);
12615 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
12616 VisitOMPClauseWithPreInit(C);
12617 C->setNumTeams(Record.readSubExpr());
12618 C->setLParenLoc(Record.readSourceLocation());
12621 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
12622 VisitOMPClauseWithPreInit(C);
12623 C->setThreadLimit(Record.readSubExpr());
12624 C->setLParenLoc(Record.readSourceLocation());
12627 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
12628 VisitOMPClauseWithPreInit(C);
12629 C->setPriority(Record.readSubExpr());
12630 C->setLParenLoc(Record.readSourceLocation());
12633 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
12634 VisitOMPClauseWithPreInit(C);
12635 C->setGrainsize(Record.readSubExpr());
12636 C->setLParenLoc(Record.readSourceLocation());
12639 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
12640 VisitOMPClauseWithPreInit(C);
12641 C->setNumTasks(Record.readSubExpr());
12642 C->setLParenLoc(Record.readSourceLocation());
12645 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
12646 C->setHint(Record.readSubExpr());
12647 C->setLParenLoc(Record.readSourceLocation());
12650 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
12651 VisitOMPClauseWithPreInit(C);
12652 C->setDistScheduleKind(
12653 static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
12654 C->setChunkSize(Record.readSubExpr());
12655 C->setLParenLoc(Record.readSourceLocation());
12656 C->setDistScheduleKindLoc(Record.readSourceLocation());
12657 C->setCommaLoc(Record.readSourceLocation());
12660 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
12661 C->setDefaultmapKind(
12662 static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
12663 C->setDefaultmapModifier(
12664 static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
12665 C->setLParenLoc(Record.readSourceLocation());
12666 C->setDefaultmapModifierLoc(Record.readSourceLocation());
12667 C->setDefaultmapKindLoc(Record.readSourceLocation());
12670 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
12671 C->setLParenLoc(Record.readSourceLocation());
12672 for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
12673 C->setMotionModifier(
12674 I, static_cast<OpenMPMotionModifierKind>(Record.readInt()));
12675 C->setMotionModifierLoc(I, Record.readSourceLocation());
12677 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12678 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12679 C->setColonLoc(Record.readSourceLocation());
12680 auto NumVars = C->varlist_size();
12681 auto UniqueDecls = C->getUniqueDeclarationsNum();
12682 auto TotalLists = C->getTotalComponentListNum();
12683 auto TotalComponents = C->getTotalComponentsNum();
12685 SmallVector<Expr *, 16> Vars;
12686 Vars.reserve(NumVars);
12687 for (unsigned i = 0; i != NumVars; ++i)
12688 Vars.push_back(Record.readSubExpr());
12689 C->setVarRefs(Vars);
12691 SmallVector<Expr *, 16> UDMappers;
12692 UDMappers.reserve(NumVars);
12693 for (unsigned I = 0; I < NumVars; ++I)
12694 UDMappers.push_back(Record.readSubExpr());
12695 C->setUDMapperRefs(UDMappers);
12697 SmallVector<ValueDecl *, 16> Decls;
12698 Decls.reserve(UniqueDecls);
12699 for (unsigned i = 0; i < UniqueDecls; ++i)
12700 Decls.push_back(Record.readDeclAs<ValueDecl>());
12701 C->setUniqueDecls(Decls);
12703 SmallVector<unsigned, 16> ListsPerDecl;
12704 ListsPerDecl.reserve(UniqueDecls);
12705 for (unsigned i = 0; i < UniqueDecls; ++i)
12706 ListsPerDecl.push_back(Record.readInt());
12707 C->setDeclNumLists(ListsPerDecl);
12709 SmallVector<unsigned, 32> ListSizes;
12710 ListSizes.reserve(TotalLists);
12711 for (unsigned i = 0; i < TotalLists; ++i)
12712 ListSizes.push_back(Record.readInt());
12713 C->setComponentListSizes(ListSizes);
12715 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12716 Components.reserve(TotalComponents);
12717 for (unsigned i = 0; i < TotalComponents; ++i) {
12718 Expr *AssociatedExprPr = Record.readSubExpr();
12719 bool IsNonContiguous = Record.readBool();
12720 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12721 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
12723 C->setComponents(Components, ListSizes);
12726 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
12727 C->setLParenLoc(Record.readSourceLocation());
12728 for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
12729 C->setMotionModifier(
12730 I, static_cast<OpenMPMotionModifierKind>(Record.readInt()));
12731 C->setMotionModifierLoc(I, Record.readSourceLocation());
12733 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12734 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12735 C->setColonLoc(Record.readSourceLocation());
12736 auto NumVars = C->varlist_size();
12737 auto UniqueDecls = C->getUniqueDeclarationsNum();
12738 auto TotalLists = C->getTotalComponentListNum();
12739 auto TotalComponents = C->getTotalComponentsNum();
12741 SmallVector<Expr *, 16> Vars;
12742 Vars.reserve(NumVars);
12743 for (unsigned i = 0; i != NumVars; ++i)
12744 Vars.push_back(Record.readSubExpr());
12745 C->setVarRefs(Vars);
12747 SmallVector<Expr *, 16> UDMappers;
12748 UDMappers.reserve(NumVars);
12749 for (unsigned I = 0; I < NumVars; ++I)
12750 UDMappers.push_back(Record.readSubExpr());
12751 C->setUDMapperRefs(UDMappers);
12753 SmallVector<ValueDecl *, 16> Decls;
12754 Decls.reserve(UniqueDecls);
12755 for (unsigned i = 0; i < UniqueDecls; ++i)
12756 Decls.push_back(Record.readDeclAs<ValueDecl>());
12757 C->setUniqueDecls(Decls);
12759 SmallVector<unsigned, 16> ListsPerDecl;
12760 ListsPerDecl.reserve(UniqueDecls);
12761 for (unsigned i = 0; i < UniqueDecls; ++i)
12762 ListsPerDecl.push_back(Record.readInt());
12763 C->setDeclNumLists(ListsPerDecl);
12765 SmallVector<unsigned, 32> ListSizes;
12766 ListSizes.reserve(TotalLists);
12767 for (unsigned i = 0; i < TotalLists; ++i)
12768 ListSizes.push_back(Record.readInt());
12769 C->setComponentListSizes(ListSizes);
12771 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12772 Components.reserve(TotalComponents);
12773 for (unsigned i = 0; i < TotalComponents; ++i) {
12774 Expr *AssociatedExprPr = Record.readSubExpr();
12775 bool IsNonContiguous = Record.readBool();
12776 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12777 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
12779 C->setComponents(Components, ListSizes);
12782 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
12783 C->setLParenLoc(Record.readSourceLocation());
12784 auto NumVars = C->varlist_size();
12785 auto UniqueDecls = C->getUniqueDeclarationsNum();
12786 auto TotalLists = C->getTotalComponentListNum();
12787 auto TotalComponents = C->getTotalComponentsNum();
12789 SmallVector<Expr *, 16> Vars;
12790 Vars.reserve(NumVars);
12791 for (unsigned i = 0; i != NumVars; ++i)
12792 Vars.push_back(Record.readSubExpr());
12793 C->setVarRefs(Vars);
12795 for (unsigned i = 0; i != NumVars; ++i)
12796 Vars.push_back(Record.readSubExpr());
12797 C->setPrivateCopies(Vars);
12799 for (unsigned i = 0; i != NumVars; ++i)
12800 Vars.push_back(Record.readSubExpr());
12803 SmallVector<ValueDecl *, 16> Decls;
12804 Decls.reserve(UniqueDecls);
12805 for (unsigned i = 0; i < UniqueDecls; ++i)
12806 Decls.push_back(Record.readDeclAs<ValueDecl>());
12807 C->setUniqueDecls(Decls);
12809 SmallVector<unsigned, 16> ListsPerDecl;
12810 ListsPerDecl.reserve(UniqueDecls);
12811 for (unsigned i = 0; i < UniqueDecls; ++i)
12812 ListsPerDecl.push_back(Record.readInt());
12813 C->setDeclNumLists(ListsPerDecl);
12815 SmallVector<unsigned, 32> ListSizes;
12816 ListSizes.reserve(TotalLists);
12817 for (unsigned i = 0; i < TotalLists; ++i)
12818 ListSizes.push_back(Record.readInt());
12819 C->setComponentListSizes(ListSizes);
12821 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12822 Components.reserve(TotalComponents);
12823 for (unsigned i = 0; i < TotalComponents; ++i) {
12824 auto *AssociatedExprPr = Record.readSubExpr();
12825 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12826 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
12827 /*IsNonContiguous=*/false);
12829 C->setComponents(Components, ListSizes);
12832 void OMPClauseReader::VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C) {
12833 C->setLParenLoc(Record.readSourceLocation());
12834 auto NumVars = C->varlist_size();
12835 auto UniqueDecls = C->getUniqueDeclarationsNum();
12836 auto TotalLists = C->getTotalComponentListNum();
12837 auto TotalComponents = C->getTotalComponentsNum();
12839 SmallVector<Expr *, 16> Vars;
12840 Vars.reserve(NumVars);
12841 for (unsigned i = 0; i != NumVars; ++i)
12842 Vars.push_back(Record.readSubExpr());
12843 C->setVarRefs(Vars);
12845 SmallVector<ValueDecl *, 16> Decls;
12846 Decls.reserve(UniqueDecls);
12847 for (unsigned i = 0; i < UniqueDecls; ++i)
12848 Decls.push_back(Record.readDeclAs<ValueDecl>());
12849 C->setUniqueDecls(Decls);
12851 SmallVector<unsigned, 16> ListsPerDecl;
12852 ListsPerDecl.reserve(UniqueDecls);
12853 for (unsigned i = 0; i < UniqueDecls; ++i)
12854 ListsPerDecl.push_back(Record.readInt());
12855 C->setDeclNumLists(ListsPerDecl);
12857 SmallVector<unsigned, 32> ListSizes;
12858 ListSizes.reserve(TotalLists);
12859 for (unsigned i = 0; i < TotalLists; ++i)
12860 ListSizes.push_back(Record.readInt());
12861 C->setComponentListSizes(ListSizes);
12863 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12864 Components.reserve(TotalComponents);
12865 for (unsigned i = 0; i < TotalComponents; ++i) {
12866 Expr *AssociatedExpr = Record.readSubExpr();
12867 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12868 Components.emplace_back(AssociatedExpr, AssociatedDecl,
12869 /*IsNonContiguous*/ false);
12871 C->setComponents(Components, ListSizes);
12874 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12875 C->setLParenLoc(Record.readSourceLocation());
12876 auto NumVars = C->varlist_size();
12877 auto UniqueDecls = C->getUniqueDeclarationsNum();
12878 auto TotalLists = C->getTotalComponentListNum();
12879 auto TotalComponents = C->getTotalComponentsNum();
12881 SmallVector<Expr *, 16> Vars;
12882 Vars.reserve(NumVars);
12883 for (unsigned i = 0; i != NumVars; ++i)
12884 Vars.push_back(Record.readSubExpr());
12885 C->setVarRefs(Vars);
12888 SmallVector<ValueDecl *, 16> Decls;
12889 Decls.reserve(UniqueDecls);
12890 for (unsigned i = 0; i < UniqueDecls; ++i)
12891 Decls.push_back(Record.readDeclAs<ValueDecl>());
12892 C->setUniqueDecls(Decls);
12894 SmallVector<unsigned, 16> ListsPerDecl;
12895 ListsPerDecl.reserve(UniqueDecls);
12896 for (unsigned i = 0; i < UniqueDecls; ++i)
12897 ListsPerDecl.push_back(Record.readInt());
12898 C->setDeclNumLists(ListsPerDecl);
12900 SmallVector<unsigned, 32> ListSizes;
12901 ListSizes.reserve(TotalLists);
12902 for (unsigned i = 0; i < TotalLists; ++i)
12903 ListSizes.push_back(Record.readInt());
12904 C->setComponentListSizes(ListSizes);
12906 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12907 Components.reserve(TotalComponents);
12908 for (unsigned i = 0; i < TotalComponents; ++i) {
12909 Expr *AssociatedExpr = Record.readSubExpr();
12910 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12911 Components.emplace_back(AssociatedExpr, AssociatedDecl,
12912 /*IsNonContiguous=*/false);
12914 C->setComponents(Components, ListSizes);
12917 void OMPClauseReader::VisitOMPNontemporalClause(OMPNontemporalClause *C) {
12918 C->setLParenLoc(Record.readSourceLocation());
12919 unsigned NumVars = C->varlist_size();
12920 SmallVector<Expr *, 16> Vars;
12921 Vars.reserve(NumVars);
12922 for (unsigned i = 0; i != NumVars; ++i)
12923 Vars.push_back(Record.readSubExpr());
12924 C->setVarRefs(Vars);
12926 Vars.reserve(NumVars);
12927 for (unsigned i = 0; i != NumVars; ++i)
12928 Vars.push_back(Record.readSubExpr());
12929 C->setPrivateRefs(Vars);
12932 void OMPClauseReader::VisitOMPInclusiveClause(OMPInclusiveClause *C) {
12933 C->setLParenLoc(Record.readSourceLocation());
12934 unsigned NumVars = C->varlist_size();
12935 SmallVector<Expr *, 16> Vars;
12936 Vars.reserve(NumVars);
12937 for (unsigned i = 0; i != NumVars; ++i)
12938 Vars.push_back(Record.readSubExpr());
12939 C->setVarRefs(Vars);
12942 void OMPClauseReader::VisitOMPExclusiveClause(OMPExclusiveClause *C) {
12943 C->setLParenLoc(Record.readSourceLocation());
12944 unsigned NumVars = C->varlist_size();
12945 SmallVector<Expr *, 16> Vars;
12946 Vars.reserve(NumVars);
12947 for (unsigned i = 0; i != NumVars; ++i)
12948 Vars.push_back(Record.readSubExpr());
12949 C->setVarRefs(Vars);
12952 void OMPClauseReader::VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C) {
12953 C->setLParenLoc(Record.readSourceLocation());
12954 unsigned NumOfAllocators = C->getNumberOfAllocators();
12955 SmallVector<OMPUsesAllocatorsClause::Data, 4> Data;
12956 Data.reserve(NumOfAllocators);
12957 for (unsigned I = 0; I != NumOfAllocators; ++I) {
12958 OMPUsesAllocatorsClause::Data &D = Data.emplace_back();
12959 D.Allocator = Record.readSubExpr();
12960 D.AllocatorTraits = Record.readSubExpr();
12961 D.LParenLoc = Record.readSourceLocation();
12962 D.RParenLoc = Record.readSourceLocation();
12964 C->setAllocatorsData(Data);
12967 void OMPClauseReader::VisitOMPAffinityClause(OMPAffinityClause *C) {
12968 C->setLParenLoc(Record.readSourceLocation());
12969 C->setModifier(Record.readSubExpr());
12970 C->setColonLoc(Record.readSourceLocation());
12971 unsigned NumOfLocators = C->varlist_size();
12972 SmallVector<Expr *, 4> Locators;
12973 Locators.reserve(NumOfLocators);
12974 for (unsigned I = 0; I != NumOfLocators; ++I)
12975 Locators.push_back(Record.readSubExpr());
12976 C->setVarRefs(Locators);
12979 void OMPClauseReader::VisitOMPOrderClause(OMPOrderClause *C) {
12980 C->setKind(Record.readEnum<OpenMPOrderClauseKind>());
12981 C->setLParenLoc(Record.readSourceLocation());
12982 C->setKindKwLoc(Record.readSourceLocation());
12985 void OMPClauseReader::VisitOMPFilterClause(OMPFilterClause *C) {
12986 VisitOMPClauseWithPreInit(C);
12987 C->setThreadID(Record.readSubExpr());
12988 C->setLParenLoc(Record.readSourceLocation());
12991 OMPTraitInfo *ASTRecordReader::readOMPTraitInfo() {
12992 OMPTraitInfo &TI = getContext().getNewOMPTraitInfo();
12993 TI.Sets.resize(readUInt32());
12994 for (auto &Set : TI.Sets) {
12995 Set.Kind = readEnum<llvm::omp::TraitSet>();
12996 Set.Selectors.resize(readUInt32());
12997 for (auto &Selector : Set.Selectors) {
12998 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
12999 Selector.ScoreOrCondition = nullptr;
13001 Selector.ScoreOrCondition = readExprRef();
13002 Selector.Properties.resize(readUInt32());
13003 for (auto &Property : Selector.Properties)
13004 Property.Kind = readEnum<llvm::omp::TraitProperty>();
13010 void ASTRecordReader::readOMPChildren(OMPChildren *Data) {
13013 if (Reader->ReadingKind == ASTReader::Read_Stmt) {
13014 // Skip NumClauses, NumChildren and HasAssociatedStmt fields.
13017 SmallVector<OMPClause *, 4> Clauses(Data->getNumClauses());
13018 for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
13019 Clauses[I] = readOMPClause();
13020 Data->setClauses(Clauses);
13021 if (Data->hasAssociatedStmt())
13022 Data->setAssociatedStmt(readStmt());
13023 for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
13024 Data->getChildren()[I] = readStmt();