1 //===-- ASTReader.cpp - AST File Reader ----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTReader class, which reads AST files.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/Frontend/PCHContainerOperations.h"
23 #include "clang/AST/ASTMutationListener.h"
24 #include "clang/AST/NestedNameSpecifier.h"
25 #include "clang/AST/Type.h"
26 #include "clang/AST/TypeLocVisitor.h"
27 #include "clang/Basic/DiagnosticOptions.h"
28 #include "clang/Basic/FileManager.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/SourceManagerInternals.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "clang/Basic/TargetOptions.h"
33 #include "clang/Basic/Version.h"
34 #include "clang/Basic/VersionTuple.h"
35 #include "clang/Frontend/Utils.h"
36 #include "clang/Lex/HeaderSearch.h"
37 #include "clang/Lex/HeaderSearchOptions.h"
38 #include "clang/Lex/MacroInfo.h"
39 #include "clang/Lex/PreprocessingRecord.h"
40 #include "clang/Lex/Preprocessor.h"
41 #include "clang/Lex/PreprocessorOptions.h"
42 #include "clang/Sema/Scope.h"
43 #include "clang/Sema/Sema.h"
44 #include "clang/Serialization/ASTDeserializationListener.h"
45 #include "clang/Serialization/GlobalModuleIndex.h"
46 #include "clang/Serialization/ModuleManager.h"
47 #include "clang/Serialization/SerializationDiagnostic.h"
48 #include "llvm/ADT/Hashing.h"
49 #include "llvm/ADT/StringExtras.h"
50 #include "llvm/Bitcode/BitstreamReader.h"
51 #include "llvm/Support/ErrorHandling.h"
52 #include "llvm/Support/FileSystem.h"
53 #include "llvm/Support/MemoryBuffer.h"
54 #include "llvm/Support/Path.h"
55 #include "llvm/Support/SaveAndRestore.h"
56 #include "llvm/Support/raw_ostream.h"
60 #include <system_error>
62 using namespace clang;
63 using namespace clang::serialization;
64 using namespace clang::serialization::reader;
65 using llvm::BitstreamCursor;
68 //===----------------------------------------------------------------------===//
69 // ChainedASTReaderListener implementation
70 //===----------------------------------------------------------------------===//
73 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
74 return First->ReadFullVersionInformation(FullVersion) ||
75 Second->ReadFullVersionInformation(FullVersion);
77 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
78 First->ReadModuleName(ModuleName);
79 Second->ReadModuleName(ModuleName);
81 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
82 First->ReadModuleMapFile(ModuleMapPath);
83 Second->ReadModuleMapFile(ModuleMapPath);
86 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
88 bool AllowCompatibleDifferences) {
89 return First->ReadLanguageOptions(LangOpts, Complain,
90 AllowCompatibleDifferences) ||
91 Second->ReadLanguageOptions(LangOpts, Complain,
92 AllowCompatibleDifferences);
94 bool ChainedASTReaderListener::ReadTargetOptions(
95 const TargetOptions &TargetOpts, bool Complain,
96 bool AllowCompatibleDifferences) {
97 return First->ReadTargetOptions(TargetOpts, Complain,
98 AllowCompatibleDifferences) ||
99 Second->ReadTargetOptions(TargetOpts, Complain,
100 AllowCompatibleDifferences);
102 bool ChainedASTReaderListener::ReadDiagnosticOptions(
103 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
104 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
105 Second->ReadDiagnosticOptions(DiagOpts, Complain);
108 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
110 return First->ReadFileSystemOptions(FSOpts, Complain) ||
111 Second->ReadFileSystemOptions(FSOpts, Complain);
114 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
115 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
117 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
119 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
122 bool ChainedASTReaderListener::ReadPreprocessorOptions(
123 const PreprocessorOptions &PPOpts, bool Complain,
124 std::string &SuggestedPredefines) {
125 return First->ReadPreprocessorOptions(PPOpts, Complain,
126 SuggestedPredefines) ||
127 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
129 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
131 First->ReadCounter(M, Value);
132 Second->ReadCounter(M, Value);
134 bool ChainedASTReaderListener::needsInputFileVisitation() {
135 return First->needsInputFileVisitation() ||
136 Second->needsInputFileVisitation();
138 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
139 return First->needsSystemInputFileVisitation() ||
140 Second->needsSystemInputFileVisitation();
142 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
144 First->visitModuleFile(Filename, Kind);
145 Second->visitModuleFile(Filename, Kind);
147 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
150 bool isExplicitModule) {
151 bool Continue = false;
152 if (First->needsInputFileVisitation() &&
153 (!isSystem || First->needsSystemInputFileVisitation()))
154 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
156 if (Second->needsInputFileVisitation() &&
157 (!isSystem || Second->needsSystemInputFileVisitation()))
158 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
163 void ChainedASTReaderListener::readModuleFileExtension(
164 const ModuleFileExtensionMetadata &Metadata) {
165 First->readModuleFileExtension(Metadata);
166 Second->readModuleFileExtension(Metadata);
169 //===----------------------------------------------------------------------===//
170 // PCH validator implementation
171 //===----------------------------------------------------------------------===//
173 ASTReaderListener::~ASTReaderListener() {}
175 /// \brief Compare the given set of language options against an existing set of
176 /// language options.
178 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
179 /// \param AllowCompatibleDifferences If true, differences between compatible
180 /// language options will be permitted.
182 /// \returns true if the languagae options mis-match, false otherwise.
183 static bool checkLanguageOptions(const LangOptions &LangOpts,
184 const LangOptions &ExistingLangOpts,
185 DiagnosticsEngine *Diags,
186 bool AllowCompatibleDifferences = true) {
187 #define LANGOPT(Name, Bits, Default, Description) \
188 if (ExistingLangOpts.Name != LangOpts.Name) { \
190 Diags->Report(diag::err_pch_langopt_mismatch) \
191 << Description << LangOpts.Name << ExistingLangOpts.Name; \
195 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
196 if (ExistingLangOpts.Name != LangOpts.Name) { \
198 Diags->Report(diag::err_pch_langopt_value_mismatch) \
203 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
204 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
206 Diags->Report(diag::err_pch_langopt_value_mismatch) \
211 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
212 if (!AllowCompatibleDifferences) \
213 LANGOPT(Name, Bits, Default, Description)
215 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
216 if (!AllowCompatibleDifferences) \
217 ENUM_LANGOPT(Name, Bits, Default, Description)
219 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
220 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
221 #include "clang/Basic/LangOptions.def"
223 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
225 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
229 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
231 Diags->Report(diag::err_pch_langopt_value_mismatch)
232 << "target Objective-C runtime";
236 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
237 LangOpts.CommentOpts.BlockCommandNames) {
239 Diags->Report(diag::err_pch_langopt_value_mismatch)
240 << "block command names";
247 /// \brief Compare the given set of target options against an existing set of
250 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
252 /// \returns true if the target options mis-match, false otherwise.
253 static bool checkTargetOptions(const TargetOptions &TargetOpts,
254 const TargetOptions &ExistingTargetOpts,
255 DiagnosticsEngine *Diags,
256 bool AllowCompatibleDifferences = true) {
257 #define CHECK_TARGET_OPT(Field, Name) \
258 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
260 Diags->Report(diag::err_pch_targetopt_mismatch) \
261 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
265 // The triple and ABI must match exactly.
266 CHECK_TARGET_OPT(Triple, "target");
267 CHECK_TARGET_OPT(ABI, "target ABI");
269 // We can tolerate different CPUs in many cases, notably when one CPU
270 // supports a strict superset of another. When allowing compatible
271 // differences skip this check.
272 if (!AllowCompatibleDifferences)
273 CHECK_TARGET_OPT(CPU, "target CPU");
275 #undef CHECK_TARGET_OPT
277 // Compare feature sets.
278 SmallVector<StringRef, 4> ExistingFeatures(
279 ExistingTargetOpts.FeaturesAsWritten.begin(),
280 ExistingTargetOpts.FeaturesAsWritten.end());
281 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
282 TargetOpts.FeaturesAsWritten.end());
283 std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
284 std::sort(ReadFeatures.begin(), ReadFeatures.end());
286 // We compute the set difference in both directions explicitly so that we can
287 // diagnose the differences differently.
288 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
290 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
291 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
292 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
293 ExistingFeatures.begin(), ExistingFeatures.end(),
294 std::back_inserter(UnmatchedReadFeatures));
296 // If we are allowing compatible differences and the read feature set is
297 // a strict subset of the existing feature set, there is nothing to diagnose.
298 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
302 for (StringRef Feature : UnmatchedReadFeatures)
303 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
304 << /* is-existing-feature */ false << Feature;
305 for (StringRef Feature : UnmatchedExistingFeatures)
306 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
307 << /* is-existing-feature */ true << Feature;
310 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
314 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
316 bool AllowCompatibleDifferences) {
317 const LangOptions &ExistingLangOpts = PP.getLangOpts();
318 return checkLanguageOptions(LangOpts, ExistingLangOpts,
319 Complain ? &Reader.Diags : nullptr,
320 AllowCompatibleDifferences);
323 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
325 bool AllowCompatibleDifferences) {
326 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
327 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
328 Complain ? &Reader.Diags : nullptr,
329 AllowCompatibleDifferences);
333 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
335 typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
339 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
340 DiagnosticsEngine &Diags,
342 typedef DiagnosticsEngine::Level Level;
344 // Check current mappings for new -Werror mappings, and the stored mappings
345 // for cases that were explicitly mapped to *not* be errors that are now
346 // errors because of options like -Werror.
347 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
349 for (DiagnosticsEngine *MappingSource : MappingSources) {
350 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
351 diag::kind DiagID = DiagIDMappingPair.first;
352 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
353 if (CurLevel < DiagnosticsEngine::Error)
354 continue; // not significant
356 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
357 if (StoredLevel < DiagnosticsEngine::Error) {
359 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
360 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
369 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
370 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
371 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
373 return Ext >= diag::Severity::Error;
376 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
377 DiagnosticsEngine &Diags,
378 bool IsSystem, bool Complain) {
381 if (Diags.getSuppressSystemWarnings())
383 // If -Wsystem-headers was not enabled before, be conservative
384 if (StoredDiags.getSuppressSystemWarnings()) {
386 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
391 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
393 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
397 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
398 !StoredDiags.getEnableAllWarnings()) {
400 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
404 if (isExtHandlingFromDiagsError(Diags) &&
405 !isExtHandlingFromDiagsError(StoredDiags)) {
407 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
411 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
414 bool PCHValidator::ReadDiagnosticOptions(
415 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
416 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
417 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
418 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
419 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
420 // This should never fail, because we would have processed these options
421 // before writing them to an ASTFile.
422 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
424 ModuleManager &ModuleMgr = Reader.getModuleManager();
425 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
427 // If the original import came from a file explicitly generated by the user,
428 // don't check the diagnostic mappings.
429 // FIXME: currently this is approximated by checking whether this is not a
430 // module import of an implicitly-loaded module file.
431 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
432 // the transitive closure of its imports, since unrelated modules cannot be
433 // imported until after this module finishes validation.
434 ModuleFile *TopImport = *ModuleMgr.rbegin();
435 while (!TopImport->ImportedBy.empty())
436 TopImport = TopImport->ImportedBy[0];
437 if (TopImport->Kind != MK_ImplicitModule)
440 StringRef ModuleName = TopImport->ModuleName;
441 assert(!ModuleName.empty() && "diagnostic options read before module name");
443 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
444 assert(M && "missing module");
446 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
447 // contains the union of their flags.
448 return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
451 /// \brief Collect the macro definitions provided by the given preprocessor
454 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
455 MacroDefinitionsMap &Macros,
456 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
457 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
458 StringRef Macro = PPOpts.Macros[I].first;
459 bool IsUndef = PPOpts.Macros[I].second;
461 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
462 StringRef MacroName = MacroPair.first;
463 StringRef MacroBody = MacroPair.second;
465 // For an #undef'd macro, we only care about the name.
467 if (MacroNames && !Macros.count(MacroName))
468 MacroNames->push_back(MacroName);
470 Macros[MacroName] = std::make_pair("", true);
474 // For a #define'd macro, figure out the actual definition.
475 if (MacroName.size() == Macro.size())
478 // Note: GCC drops anything following an end-of-line character.
479 StringRef::size_type End = MacroBody.find_first_of("\n\r");
480 MacroBody = MacroBody.substr(0, End);
483 if (MacroNames && !Macros.count(MacroName))
484 MacroNames->push_back(MacroName);
485 Macros[MacroName] = std::make_pair(MacroBody, false);
489 /// \brief Check the preprocessor options deserialized from the control block
490 /// against the preprocessor options in an existing preprocessor.
492 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
493 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
494 const PreprocessorOptions &ExistingPPOpts,
495 DiagnosticsEngine *Diags,
496 FileManager &FileMgr,
497 std::string &SuggestedPredefines,
498 const LangOptions &LangOpts) {
499 // Check macro definitions.
500 MacroDefinitionsMap ASTFileMacros;
501 collectMacroDefinitions(PPOpts, ASTFileMacros);
502 MacroDefinitionsMap ExistingMacros;
503 SmallVector<StringRef, 4> ExistingMacroNames;
504 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
506 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
507 // Dig out the macro definition in the existing preprocessor options.
508 StringRef MacroName = ExistingMacroNames[I];
509 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
511 // Check whether we know anything about this macro name or not.
512 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
513 = ASTFileMacros.find(MacroName);
514 if (Known == ASTFileMacros.end()) {
515 // FIXME: Check whether this identifier was referenced anywhere in the
516 // AST file. If so, we should reject the AST file. Unfortunately, this
517 // information isn't in the control block. What shall we do about it?
519 if (Existing.second) {
520 SuggestedPredefines += "#undef ";
521 SuggestedPredefines += MacroName.str();
522 SuggestedPredefines += '\n';
524 SuggestedPredefines += "#define ";
525 SuggestedPredefines += MacroName.str();
526 SuggestedPredefines += ' ';
527 SuggestedPredefines += Existing.first.str();
528 SuggestedPredefines += '\n';
533 // If the macro was defined in one but undef'd in the other, we have a
535 if (Existing.second != Known->second.second) {
537 Diags->Report(diag::err_pch_macro_def_undef)
538 << MacroName << Known->second.second;
543 // If the macro was #undef'd in both, or if the macro bodies are identical,
545 if (Existing.second || Existing.first == Known->second.first)
548 // The macro bodies differ; complain.
550 Diags->Report(diag::err_pch_macro_def_conflict)
551 << MacroName << Known->second.first << Existing.first;
556 // Check whether we're using predefines.
557 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {
559 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
564 // Detailed record is important since it is used for the module cache hash.
565 if (LangOpts.Modules &&
566 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) {
568 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
573 // Compute the #include and #include_macros lines we need.
574 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
575 StringRef File = ExistingPPOpts.Includes[I];
576 if (File == ExistingPPOpts.ImplicitPCHInclude)
579 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
580 != PPOpts.Includes.end())
583 SuggestedPredefines += "#include \"";
584 SuggestedPredefines += File;
585 SuggestedPredefines += "\"\n";
588 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
589 StringRef File = ExistingPPOpts.MacroIncludes[I];
590 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
592 != PPOpts.MacroIncludes.end())
595 SuggestedPredefines += "#__include_macros \"";
596 SuggestedPredefines += File;
597 SuggestedPredefines += "\"\n##\n";
603 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
605 std::string &SuggestedPredefines) {
606 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
608 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
609 Complain? &Reader.Diags : nullptr,
615 /// Check the header search options deserialized from the control block
616 /// against the header search options in an existing preprocessor.
618 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
619 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
620 StringRef SpecificModuleCachePath,
621 StringRef ExistingModuleCachePath,
622 DiagnosticsEngine *Diags,
623 const LangOptions &LangOpts) {
624 if (LangOpts.Modules) {
625 if (SpecificModuleCachePath != ExistingModuleCachePath) {
627 Diags->Report(diag::err_pch_modulecache_mismatch)
628 << SpecificModuleCachePath << ExistingModuleCachePath;
636 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
637 StringRef SpecificModuleCachePath,
639 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
640 PP.getHeaderSearchInfo().getModuleCachePath(),
641 Complain ? &Reader.Diags : nullptr,
645 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
646 PP.setCounterValue(Value);
649 //===----------------------------------------------------------------------===//
650 // AST reader implementation
651 //===----------------------------------------------------------------------===//
653 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
654 bool TakeOwnership) {
655 DeserializationListener = Listener;
656 OwnsDeserializationListener = TakeOwnership;
661 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
662 return serialization::ComputeHash(Sel);
666 std::pair<unsigned, unsigned>
667 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
668 using namespace llvm::support;
669 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
670 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
671 return std::make_pair(KeyLen, DataLen);
674 ASTSelectorLookupTrait::internal_key_type
675 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
676 using namespace llvm::support;
677 SelectorTable &SelTable = Reader.getContext().Selectors;
678 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
679 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
680 F, endian::readNext<uint32_t, little, unaligned>(d));
682 return SelTable.getNullarySelector(FirstII);
684 return SelTable.getUnarySelector(FirstII);
686 SmallVector<IdentifierInfo *, 16> Args;
687 Args.push_back(FirstII);
688 for (unsigned I = 1; I != N; ++I)
689 Args.push_back(Reader.getLocalIdentifier(
690 F, endian::readNext<uint32_t, little, unaligned>(d)));
692 return SelTable.getSelector(N, Args.data());
695 ASTSelectorLookupTrait::data_type
696 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
698 using namespace llvm::support;
702 Result.ID = Reader.getGlobalSelectorID(
703 F, endian::readNext<uint32_t, little, unaligned>(d));
704 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
705 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
706 Result.InstanceBits = FullInstanceBits & 0x3;
707 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
708 Result.FactoryBits = FullFactoryBits & 0x3;
709 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
710 unsigned NumInstanceMethods = FullInstanceBits >> 3;
711 unsigned NumFactoryMethods = FullFactoryBits >> 3;
713 // Load instance methods
714 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
715 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
716 F, endian::readNext<uint32_t, little, unaligned>(d)))
717 Result.Instance.push_back(Method);
720 // Load factory methods
721 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
722 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
723 F, endian::readNext<uint32_t, little, unaligned>(d)))
724 Result.Factory.push_back(Method);
730 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
731 return llvm::HashString(a);
734 std::pair<unsigned, unsigned>
735 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
736 using namespace llvm::support;
737 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
738 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
739 return std::make_pair(KeyLen, DataLen);
742 ASTIdentifierLookupTraitBase::internal_key_type
743 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
744 assert(n >= 2 && d[n-1] == '\0');
745 return StringRef((const char*) d, n-1);
748 /// \brief Whether the given identifier is "interesting".
749 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
751 return II.hadMacroDefinition() ||
753 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
754 II.hasRevertedTokenIDToIdentifier() ||
755 (!(IsModule && Reader.getContext().getLangOpts().CPlusPlus) &&
756 II.getFETokenInfo<void>());
759 static bool readBit(unsigned &Bits) {
760 bool Value = Bits & 0x1;
765 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
766 using namespace llvm::support;
767 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
768 return Reader.getGlobalIdentifierID(F, RawID >> 1);
771 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
772 const unsigned char* d,
774 using namespace llvm::support;
775 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
776 bool IsInteresting = RawID & 0x01;
778 // Wipe out the "is interesting" bit.
781 // Build the IdentifierInfo and link the identifier ID with it.
782 IdentifierInfo *II = KnownII;
784 II = &Reader.getIdentifierTable().getOwn(k);
787 if (!II->isFromAST()) {
789 bool IsModule = Reader.PP.getCurrentModule() != nullptr;
790 if (isInterestingIdentifier(Reader, *II, IsModule))
791 II->setChangedSinceDeserialization();
793 Reader.markIdentifierUpToDate(II);
795 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
796 if (!IsInteresting) {
797 // For uninteresting identifiers, there's nothing else to do. Just notify
798 // the reader that we've finished loading this identifier.
799 Reader.SetIdentifierInfo(ID, II);
803 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
804 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
805 bool CPlusPlusOperatorKeyword = readBit(Bits);
806 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
807 bool HasRevertedBuiltin = readBit(Bits);
808 bool Poisoned = readBit(Bits);
809 bool ExtensionToken = readBit(Bits);
810 bool HadMacroDefinition = readBit(Bits);
812 assert(Bits == 0 && "Extra bits in the identifier?");
815 // Set or check the various bits in the IdentifierInfo structure.
816 // Token IDs are read-only.
817 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
818 II->revertTokenIDToIdentifier();
820 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
821 else if (HasRevertedBuiltin && II->getBuiltinID()) {
823 assert((II->hasRevertedBuiltin() ||
824 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
825 "Incorrect ObjC keyword or builtin ID");
827 assert(II->isExtensionToken() == ExtensionToken &&
828 "Incorrect extension token flag");
829 (void)ExtensionToken;
831 II->setIsPoisoned(true);
832 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
833 "Incorrect C++ operator keyword flag");
834 (void)CPlusPlusOperatorKeyword;
836 // If this identifier is a macro, deserialize the macro
838 if (HadMacroDefinition) {
839 uint32_t MacroDirectivesOffset =
840 endian::readNext<uint32_t, little, unaligned>(d);
843 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
846 Reader.SetIdentifierInfo(ID, II);
848 // Read all of the declarations visible at global scope with this
851 SmallVector<uint32_t, 4> DeclIDs;
852 for (; DataLen > 0; DataLen -= 4)
853 DeclIDs.push_back(Reader.getGlobalDeclID(
854 F, endian::readNext<uint32_t, little, unaligned>(d)));
855 Reader.SetGloballyVisibleDecls(II, DeclIDs);
861 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
862 : Kind(Name.getNameKind()) {
864 case DeclarationName::Identifier:
865 Data = (uint64_t)Name.getAsIdentifierInfo();
867 case DeclarationName::ObjCZeroArgSelector:
868 case DeclarationName::ObjCOneArgSelector:
869 case DeclarationName::ObjCMultiArgSelector:
870 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
872 case DeclarationName::CXXOperatorName:
873 Data = Name.getCXXOverloadedOperator();
875 case DeclarationName::CXXLiteralOperatorName:
876 Data = (uint64_t)Name.getCXXLiteralIdentifier();
878 case DeclarationName::CXXConstructorName:
879 case DeclarationName::CXXDestructorName:
880 case DeclarationName::CXXConversionFunctionName:
881 case DeclarationName::CXXUsingDirective:
887 unsigned DeclarationNameKey::getHash() const {
888 llvm::FoldingSetNodeID ID;
892 case DeclarationName::Identifier:
893 case DeclarationName::CXXLiteralOperatorName:
894 ID.AddString(((IdentifierInfo*)Data)->getName());
896 case DeclarationName::ObjCZeroArgSelector:
897 case DeclarationName::ObjCOneArgSelector:
898 case DeclarationName::ObjCMultiArgSelector:
899 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
901 case DeclarationName::CXXOperatorName:
902 ID.AddInteger((OverloadedOperatorKind)Data);
904 case DeclarationName::CXXConstructorName:
905 case DeclarationName::CXXDestructorName:
906 case DeclarationName::CXXConversionFunctionName:
907 case DeclarationName::CXXUsingDirective:
911 return ID.ComputeHash();
915 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
916 using namespace llvm::support;
917 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
918 return Reader.getLocalModuleFile(F, ModuleFileID);
921 std::pair<unsigned, unsigned>
922 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
923 using namespace llvm::support;
924 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
925 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
926 return std::make_pair(KeyLen, DataLen);
929 ASTDeclContextNameLookupTrait::internal_key_type
930 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
931 using namespace llvm::support;
933 auto Kind = (DeclarationName::NameKind)*d++;
936 case DeclarationName::Identifier:
937 Data = (uint64_t)Reader.getLocalIdentifier(
938 F, endian::readNext<uint32_t, little, unaligned>(d));
940 case DeclarationName::ObjCZeroArgSelector:
941 case DeclarationName::ObjCOneArgSelector:
942 case DeclarationName::ObjCMultiArgSelector:
944 (uint64_t)Reader.getLocalSelector(
945 F, endian::readNext<uint32_t, little, unaligned>(
946 d)).getAsOpaquePtr();
948 case DeclarationName::CXXOperatorName:
949 Data = *d++; // OverloadedOperatorKind
951 case DeclarationName::CXXLiteralOperatorName:
952 Data = (uint64_t)Reader.getLocalIdentifier(
953 F, endian::readNext<uint32_t, little, unaligned>(d));
955 case DeclarationName::CXXConstructorName:
956 case DeclarationName::CXXDestructorName:
957 case DeclarationName::CXXConversionFunctionName:
958 case DeclarationName::CXXUsingDirective:
963 return DeclarationNameKey(Kind, Data);
966 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
967 const unsigned char *d,
969 data_type_builder &Val) {
970 using namespace llvm::support;
971 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
972 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
973 Val.insert(Reader.getGlobalDeclID(F, LocalID));
977 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
978 BitstreamCursor &Cursor,
983 SavedStreamPosition SavedPosition(Cursor);
984 Cursor.JumpToBit(Offset);
988 unsigned Code = Cursor.ReadCode();
989 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
990 if (RecCode != DECL_CONTEXT_LEXICAL) {
991 Error("Expected lexical block");
995 assert(!isa<TranslationUnitDecl>(DC) &&
996 "expected a TU_UPDATE_LEXICAL record for TU");
997 // If we are handling a C++ class template instantiation, we can see multiple
998 // lexical updates for the same record. It's important that we select only one
999 // of them, so that field numbering works properly. Just pick the first one we
1001 auto &Lex = LexicalDecls[DC];
1003 Lex = std::make_pair(
1004 &M, llvm::makeArrayRef(
1005 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1009 DC->setHasExternalLexicalStorage(true);
1013 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1014 BitstreamCursor &Cursor,
1017 assert(Offset != 0);
1019 SavedStreamPosition SavedPosition(Cursor);
1020 Cursor.JumpToBit(Offset);
1024 unsigned Code = Cursor.ReadCode();
1025 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1026 if (RecCode != DECL_CONTEXT_VISIBLE) {
1027 Error("Expected visible lookup table block");
1031 // We can't safely determine the primary context yet, so delay attaching the
1032 // lookup table until we're done with recursive deserialization.
1033 auto *Data = (const unsigned char*)Blob.data();
1034 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1038 void ASTReader::Error(StringRef Msg) {
1039 Error(diag::err_fe_pch_malformed, Msg);
1040 if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1041 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1042 Diag(diag::note_module_cache_path)
1043 << PP.getHeaderSearchInfo().getModuleCachePath();
1047 void ASTReader::Error(unsigned DiagID,
1048 StringRef Arg1, StringRef Arg2) {
1049 if (Diags.isDiagnosticInFlight())
1050 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1052 Diag(DiagID) << Arg1 << Arg2;
1055 //===----------------------------------------------------------------------===//
1056 // Source Manager Deserialization
1057 //===----------------------------------------------------------------------===//
1059 /// \brief Read the line table in the source manager block.
1060 /// \returns true if there was an error.
1061 bool ASTReader::ParseLineTable(ModuleFile &F,
1062 const RecordData &Record) {
1064 LineTableInfo &LineTable = SourceMgr.getLineTable();
1066 // Parse the file names
1067 std::map<int, int> FileIDs;
1068 for (unsigned I = 0; Record[Idx]; ++I) {
1069 // Extract the file name
1070 auto Filename = ReadPath(F, Record, Idx);
1071 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1075 // Parse the line entries
1076 std::vector<LineEntry> Entries;
1077 while (Idx < Record.size()) {
1078 int FID = Record[Idx++];
1079 assert(FID >= 0 && "Serialized line entries for non-local file.");
1080 // Remap FileID from 1-based old view.
1081 FID += F.SLocEntryBaseID - 1;
1083 // Extract the line entries
1084 unsigned NumEntries = Record[Idx++];
1085 assert(NumEntries && "no line entries for file ID");
1087 Entries.reserve(NumEntries);
1088 for (unsigned I = 0; I != NumEntries; ++I) {
1089 unsigned FileOffset = Record[Idx++];
1090 unsigned LineNo = Record[Idx++];
1091 int FilenameID = FileIDs[Record[Idx++]];
1092 SrcMgr::CharacteristicKind FileKind
1093 = (SrcMgr::CharacteristicKind)Record[Idx++];
1094 unsigned IncludeOffset = Record[Idx++];
1095 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1096 FileKind, IncludeOffset));
1098 LineTable.AddEntry(FileID::get(FID), Entries);
1104 /// \brief Read a source manager block
1105 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1106 using namespace SrcMgr;
1108 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1110 // Set the source-location entry cursor to the current position in
1111 // the stream. This cursor will be used to read the contents of the
1112 // source manager block initially, and then lazily read
1113 // source-location entries as needed.
1114 SLocEntryCursor = F.Stream;
1116 // The stream itself is going to skip over the source manager block.
1117 if (F.Stream.SkipBlock()) {
1118 Error("malformed block record in AST file");
1122 // Enter the source manager block.
1123 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1124 Error("malformed source manager block record in AST file");
1130 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1133 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1134 case llvm::BitstreamEntry::Error:
1135 Error("malformed block record in AST file");
1137 case llvm::BitstreamEntry::EndBlock:
1139 case llvm::BitstreamEntry::Record:
1140 // The interesting case.
1147 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1148 default: // Default behavior: ignore.
1151 case SM_SLOC_FILE_ENTRY:
1152 case SM_SLOC_BUFFER_ENTRY:
1153 case SM_SLOC_EXPANSION_ENTRY:
1154 // Once we hit one of the source location entries, we're done.
1160 /// \brief If a header file is not found at the path that we expect it to be
1161 /// and the PCH file was moved from its original location, try to resolve the
1162 /// file by assuming that header+PCH were moved together and the header is in
1163 /// the same place relative to the PCH.
1165 resolveFileRelativeToOriginalDir(const std::string &Filename,
1166 const std::string &OriginalDir,
1167 const std::string &CurrDir) {
1168 assert(OriginalDir != CurrDir &&
1169 "No point trying to resolve the file if the PCH dir didn't change");
1170 using namespace llvm::sys;
1171 SmallString<128> filePath(Filename);
1172 fs::make_absolute(filePath);
1173 assert(path::is_absolute(OriginalDir));
1174 SmallString<128> currPCHPath(CurrDir);
1176 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1177 fileDirE = path::end(path::parent_path(filePath));
1178 path::const_iterator origDirI = path::begin(OriginalDir),
1179 origDirE = path::end(OriginalDir);
1180 // Skip the common path components from filePath and OriginalDir.
1181 while (fileDirI != fileDirE && origDirI != origDirE &&
1182 *fileDirI == *origDirI) {
1186 for (; origDirI != origDirE; ++origDirI)
1187 path::append(currPCHPath, "..");
1188 path::append(currPCHPath, fileDirI, fileDirE);
1189 path::append(currPCHPath, path::filename(Filename));
1190 return currPCHPath.str();
1193 bool ASTReader::ReadSLocEntry(int ID) {
1197 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1198 Error("source location entry ID out-of-range for AST file");
1202 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1203 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1204 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1205 unsigned BaseOffset = F->SLocEntryBaseOffset;
1207 ++NumSLocEntriesRead;
1208 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1209 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1210 Error("incorrectly-formatted source location entry in AST file");
1216 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1218 Error("incorrectly-formatted source location entry in AST file");
1221 case SM_SLOC_FILE_ENTRY: {
1222 // We will detect whether a file changed and return 'Failure' for it, but
1223 // we will also try to fail gracefully by setting up the SLocEntry.
1224 unsigned InputID = Record[4];
1225 InputFile IF = getInputFile(*F, InputID);
1226 const FileEntry *File = IF.getFile();
1227 bool OverriddenBuffer = IF.isOverridden();
1229 // Note that we only check if a File was returned. If it was out-of-date
1230 // we have complained but we will continue creating a FileID to recover
1235 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1236 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1237 // This is the module's main file.
1238 IncludeLoc = getImportLocation(F);
1240 SrcMgr::CharacteristicKind
1241 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1242 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1243 ID, BaseOffset + Record[0]);
1244 SrcMgr::FileInfo &FileInfo =
1245 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1246 FileInfo.NumCreatedFIDs = Record[5];
1248 FileInfo.setHasLineDirectives();
1250 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1251 unsigned NumFileDecls = Record[7];
1253 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1254 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1258 const SrcMgr::ContentCache *ContentCache
1259 = SourceMgr.getOrCreateContentCache(File,
1260 /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
1261 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1262 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1263 !ContentCache->getRawBuffer()) {
1264 unsigned Code = SLocEntryCursor.ReadCode();
1266 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1268 if (RecCode != SM_SLOC_BUFFER_BLOB) {
1269 Error("AST record has invalid code");
1273 std::unique_ptr<llvm::MemoryBuffer> Buffer
1274 = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName());
1275 SourceMgr.overrideFileContents(File, std::move(Buffer));
1281 case SM_SLOC_BUFFER_ENTRY: {
1282 const char *Name = Blob.data();
1283 unsigned Offset = Record[0];
1284 SrcMgr::CharacteristicKind
1285 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1286 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1287 if (IncludeLoc.isInvalid() &&
1288 (F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) {
1289 IncludeLoc = getImportLocation(F);
1291 unsigned Code = SLocEntryCursor.ReadCode();
1294 = SLocEntryCursor.readRecord(Code, Record, &Blob);
1296 if (RecCode != SM_SLOC_BUFFER_BLOB) {
1297 Error("AST record has invalid code");
1301 std::unique_ptr<llvm::MemoryBuffer> Buffer =
1302 llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name);
1303 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1304 BaseOffset + Offset, IncludeLoc);
1308 case SM_SLOC_EXPANSION_ENTRY: {
1309 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1310 SourceMgr.createExpansionLoc(SpellingLoc,
1311 ReadSourceLocation(*F, Record[2]),
1312 ReadSourceLocation(*F, Record[3]),
1315 BaseOffset + Record[0]);
1323 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1325 return std::make_pair(SourceLocation(), "");
1327 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1328 Error("source location entry ID out-of-range for AST file");
1329 return std::make_pair(SourceLocation(), "");
1332 // Find which module file this entry lands in.
1333 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1334 if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule)
1335 return std::make_pair(SourceLocation(), "");
1337 // FIXME: Can we map this down to a particular submodule? That would be
1339 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1342 /// \brief Find the location where the module F is imported.
1343 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1344 if (F->ImportLoc.isValid())
1345 return F->ImportLoc;
1347 // Otherwise we have a PCH. It's considered to be "imported" at the first
1348 // location of its includer.
1349 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1350 // Main file is the importer.
1351 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1352 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1354 return F->ImportedBy[0]->FirstLoc;
1357 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1358 /// specified cursor. Read the abbreviations that are at the top of the block
1359 /// and then leave the cursor pointing into the block.
1360 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1361 if (Cursor.EnterSubBlock(BlockID))
1365 uint64_t Offset = Cursor.GetCurrentBitNo();
1366 unsigned Code = Cursor.ReadCode();
1368 // We expect all abbrevs to be at the start of the block.
1369 if (Code != llvm::bitc::DEFINE_ABBREV) {
1370 Cursor.JumpToBit(Offset);
1373 Cursor.ReadAbbrevRecord();
1377 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1381 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1382 Tok.setLength(Record[Idx++]);
1383 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1384 Tok.setIdentifierInfo(II);
1385 Tok.setKind((tok::TokenKind)Record[Idx++]);
1386 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1390 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1391 BitstreamCursor &Stream = F.MacroCursor;
1393 // Keep track of where we are in the stream, then jump back there
1394 // after reading this macro.
1395 SavedStreamPosition SavedPosition(Stream);
1397 Stream.JumpToBit(Offset);
1399 SmallVector<IdentifierInfo*, 16> MacroArgs;
1400 MacroInfo *Macro = nullptr;
1403 // Advance to the next record, but if we get to the end of the block, don't
1404 // pop it (removing all the abbreviations from the cursor) since we want to
1405 // be able to reseek within the block and read entries.
1406 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1407 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1409 switch (Entry.Kind) {
1410 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1411 case llvm::BitstreamEntry::Error:
1412 Error("malformed block record in AST file");
1414 case llvm::BitstreamEntry::EndBlock:
1416 case llvm::BitstreamEntry::Record:
1417 // The interesting case.
1423 PreprocessorRecordTypes RecType =
1424 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1426 case PP_MODULE_MACRO:
1427 case PP_MACRO_DIRECTIVE_HISTORY:
1430 case PP_MACRO_OBJECT_LIKE:
1431 case PP_MACRO_FUNCTION_LIKE: {
1432 // If we already have a macro, that means that we've hit the end
1433 // of the definition of the macro we were looking for. We're
1438 unsigned NextIndex = 1; // Skip identifier ID.
1439 SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
1440 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1441 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
1442 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1443 MI->setIsUsed(Record[NextIndex++]);
1444 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1446 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1447 // Decode function-like macro info.
1448 bool isC99VarArgs = Record[NextIndex++];
1449 bool isGNUVarArgs = Record[NextIndex++];
1450 bool hasCommaPasting = Record[NextIndex++];
1452 unsigned NumArgs = Record[NextIndex++];
1453 for (unsigned i = 0; i != NumArgs; ++i)
1454 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1456 // Install function-like macro info.
1457 MI->setIsFunctionLike();
1458 if (isC99VarArgs) MI->setIsC99Varargs();
1459 if (isGNUVarArgs) MI->setIsGNUVarargs();
1460 if (hasCommaPasting) MI->setHasCommaPasting();
1461 MI->setArgumentList(MacroArgs, PP.getPreprocessorAllocator());
1464 // Remember that we saw this macro last so that we add the tokens that
1465 // form its body to it.
1468 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1469 Record[NextIndex]) {
1470 // We have a macro definition. Register the association
1471 PreprocessedEntityID
1472 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1473 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1474 PreprocessingRecord::PPEntityID PPID =
1475 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1476 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1477 PPRec.getPreprocessedEntity(PPID));
1479 PPRec.RegisterMacroDefinition(Macro, PPDef);
1487 // If we see a TOKEN before a PP_MACRO_*, then the file is
1488 // erroneous, just pretend we didn't see this.
1492 Token Tok = ReadToken(F, Record, Idx);
1493 Macro->AddTokenToBody(Tok);
1500 PreprocessedEntityID
1501 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1502 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1503 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1504 assert(I != M.PreprocessedEntityRemap.end()
1505 && "Invalid index into preprocessed entity index remap");
1507 return LocalID + I->second;
1510 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1511 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1514 HeaderFileInfoTrait::internal_key_type
1515 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1516 internal_key_type ikey = {FE->getSize(),
1517 M.HasTimestamps ? FE->getModificationTime() : 0,
1518 FE->getName(), /*Imported*/ false};
1522 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1523 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1526 if (llvm::sys::path::is_absolute(a.Filename) &&
1527 strcmp(a.Filename, b.Filename) == 0)
1530 // Determine whether the actual files are equivalent.
1531 FileManager &FileMgr = Reader.getFileManager();
1532 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1534 return FileMgr.getFile(Key.Filename);
1536 std::string Resolved = Key.Filename;
1537 Reader.ResolveImportedPath(M, Resolved);
1538 return FileMgr.getFile(Resolved);
1541 const FileEntry *FEA = GetFile(a);
1542 const FileEntry *FEB = GetFile(b);
1543 return FEA && FEA == FEB;
1546 std::pair<unsigned, unsigned>
1547 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1548 using namespace llvm::support;
1549 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1550 unsigned DataLen = (unsigned) *d++;
1551 return std::make_pair(KeyLen, DataLen);
1554 HeaderFileInfoTrait::internal_key_type
1555 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1556 using namespace llvm::support;
1557 internal_key_type ikey;
1558 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1559 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1560 ikey.Filename = (const char *)d;
1561 ikey.Imported = true;
1565 HeaderFileInfoTrait::data_type
1566 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1568 const unsigned char *End = d + DataLen;
1569 using namespace llvm::support;
1571 unsigned Flags = *d++;
1572 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1573 HFI.isImport |= (Flags >> 4) & 0x01;
1574 HFI.isPragmaOnce |= (Flags >> 3) & 0x01;
1575 HFI.DirInfo = (Flags >> 1) & 0x03;
1576 HFI.IndexHeaderMapHeader = Flags & 0x01;
1577 // FIXME: Find a better way to handle this. Maybe just store a
1578 // "has been included" flag?
1579 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1581 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1582 M, endian::readNext<uint32_t, little, unaligned>(d));
1583 if (unsigned FrameworkOffset =
1584 endian::readNext<uint32_t, little, unaligned>(d)) {
1585 // The framework offset is 1 greater than the actual offset,
1586 // since 0 is used as an indicator for "no framework name".
1587 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1588 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1591 assert((End - d) % 4 == 0 &&
1592 "Wrong data length in HeaderFileInfo deserialization");
1594 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1595 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1598 // This header is part of a module. Associate it with the module to enable
1599 // implicit module import.
1600 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1601 Module *Mod = Reader.getSubmodule(GlobalSMID);
1602 FileManager &FileMgr = Reader.getFileManager();
1604 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1606 std::string Filename = key.Filename;
1608 Reader.ResolveImportedPath(M, Filename);
1609 // FIXME: This is not always the right filename-as-written, but we're not
1610 // going to use this information to rebuild the module, so it doesn't make
1611 // a lot of difference.
1612 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1613 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1614 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1617 // This HeaderFileInfo was externally loaded.
1618 HFI.External = true;
1623 void ASTReader::addPendingMacro(IdentifierInfo *II,
1625 uint64_t MacroDirectivesOffset) {
1626 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1627 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1630 void ASTReader::ReadDefinedMacros() {
1631 // Note that we are loading defined macros.
1632 Deserializing Macros(this);
1634 for (auto &I : llvm::reverse(ModuleMgr)) {
1635 BitstreamCursor &MacroCursor = I->MacroCursor;
1637 // If there was no preprocessor block, skip this file.
1638 if (!MacroCursor.getBitStreamReader())
1641 BitstreamCursor Cursor = MacroCursor;
1642 Cursor.JumpToBit(I->MacroStartOffset);
1646 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1649 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1650 case llvm::BitstreamEntry::Error:
1651 Error("malformed block record in AST file");
1653 case llvm::BitstreamEntry::EndBlock:
1656 case llvm::BitstreamEntry::Record:
1658 switch (Cursor.readRecord(E.ID, Record)) {
1659 default: // Default behavior: ignore.
1662 case PP_MACRO_OBJECT_LIKE:
1663 case PP_MACRO_FUNCTION_LIKE:
1664 getLocalIdentifier(*I, Record[0]);
1679 /// \brief Visitor class used to look up identifirs in an AST file.
1680 class IdentifierLookupVisitor {
1683 unsigned PriorGeneration;
1684 unsigned &NumIdentifierLookups;
1685 unsigned &NumIdentifierLookupHits;
1686 IdentifierInfo *Found;
1689 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1690 unsigned &NumIdentifierLookups,
1691 unsigned &NumIdentifierLookupHits)
1692 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1693 PriorGeneration(PriorGeneration),
1694 NumIdentifierLookups(NumIdentifierLookups),
1695 NumIdentifierLookupHits(NumIdentifierLookupHits),
1700 bool operator()(ModuleFile &M) {
1701 // If we've already searched this module file, skip it now.
1702 if (M.Generation <= PriorGeneration)
1705 ASTIdentifierLookupTable *IdTable
1706 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1710 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1712 ++NumIdentifierLookups;
1713 ASTIdentifierLookupTable::iterator Pos =
1714 IdTable->find_hashed(Name, NameHash, &Trait);
1715 if (Pos == IdTable->end())
1718 // Dereferencing the iterator has the effect of building the
1719 // IdentifierInfo node and populating it with the various
1720 // declarations it needs.
1721 ++NumIdentifierLookupHits;
1726 // \brief Retrieve the identifier info found within the module
1728 IdentifierInfo *getIdentifierInfo() const { return Found; }
1732 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1733 // Note that we are loading an identifier.
1734 Deserializing AnIdentifier(this);
1736 unsigned PriorGeneration = 0;
1737 if (getContext().getLangOpts().Modules)
1738 PriorGeneration = IdentifierGeneration[&II];
1740 // If there is a global index, look there first to determine which modules
1741 // provably do not have any results for this identifier.
1742 GlobalModuleIndex::HitSet Hits;
1743 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1744 if (!loadGlobalIndex()) {
1745 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1750 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1751 NumIdentifierLookups,
1752 NumIdentifierLookupHits);
1753 ModuleMgr.visit(Visitor, HitsPtr);
1754 markIdentifierUpToDate(&II);
1757 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1761 II->setOutOfDate(false);
1763 // Update the generation for this identifier.
1764 if (getContext().getLangOpts().Modules)
1765 IdentifierGeneration[II] = getGeneration();
1768 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1769 const PendingMacroInfo &PMInfo) {
1770 ModuleFile &M = *PMInfo.M;
1772 BitstreamCursor &Cursor = M.MacroCursor;
1773 SavedStreamPosition SavedPosition(Cursor);
1774 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1776 struct ModuleMacroRecord {
1777 SubmoduleID SubModID;
1779 SmallVector<SubmoduleID, 8> Overrides;
1781 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1783 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1784 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1788 llvm::BitstreamEntry Entry =
1789 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1790 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1791 Error("malformed block record in AST file");
1796 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1797 case PP_MACRO_DIRECTIVE_HISTORY:
1800 case PP_MODULE_MACRO: {
1801 ModuleMacros.push_back(ModuleMacroRecord());
1802 auto &Info = ModuleMacros.back();
1803 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1804 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1805 for (int I = 2, N = Record.size(); I != N; ++I)
1806 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1811 Error("malformed block record in AST file");
1815 // We found the macro directive history; that's the last record
1820 // Module macros are listed in reverse dependency order.
1822 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
1823 llvm::SmallVector<ModuleMacro*, 8> Overrides;
1824 for (auto &MMR : ModuleMacros) {
1826 for (unsigned ModID : MMR.Overrides) {
1827 Module *Mod = getSubmodule(ModID);
1828 auto *Macro = PP.getModuleMacro(Mod, II);
1829 assert(Macro && "missing definition for overridden macro");
1830 Overrides.push_back(Macro);
1833 bool Inserted = false;
1834 Module *Owner = getSubmodule(MMR.SubModID);
1835 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
1839 // Don't read the directive history for a module; we don't have anywhere
1841 if (M.Kind == MK_ImplicitModule || M.Kind == MK_ExplicitModule)
1844 // Deserialize the macro directives history in reverse source-order.
1845 MacroDirective *Latest = nullptr, *Earliest = nullptr;
1846 unsigned Idx = 0, N = Record.size();
1848 MacroDirective *MD = nullptr;
1849 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
1850 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1852 case MacroDirective::MD_Define: {
1853 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
1854 MD = PP.AllocateDefMacroDirective(MI, Loc);
1857 case MacroDirective::MD_Undefine: {
1858 MD = PP.AllocateUndefMacroDirective(Loc);
1861 case MacroDirective::MD_Visibility:
1862 bool isPublic = Record[Idx++];
1863 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1870 Earliest->setPrevious(MD);
1875 PP.setLoadedMacroDirective(II, Latest);
1878 ASTReader::InputFileInfo
1879 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
1880 // Go find this input file.
1881 BitstreamCursor &Cursor = F.InputFilesCursor;
1882 SavedStreamPosition SavedPosition(Cursor);
1883 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1885 unsigned Code = Cursor.ReadCode();
1889 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
1890 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
1891 "invalid record type for input file");
1894 assert(Record[0] == ID && "Bogus stored ID or offset");
1896 R.StoredSize = static_cast<off_t>(Record[1]);
1897 R.StoredTime = static_cast<time_t>(Record[2]);
1898 R.Overridden = static_cast<bool>(Record[3]);
1899 R.Transient = static_cast<bool>(Record[4]);
1901 ResolveImportedPath(F, R.Filename);
1905 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
1906 // If this ID is bogus, just return an empty input file.
1907 if (ID == 0 || ID > F.InputFilesLoaded.size())
1910 // If we've already loaded this input file, return it.
1911 if (F.InputFilesLoaded[ID-1].getFile())
1912 return F.InputFilesLoaded[ID-1];
1914 if (F.InputFilesLoaded[ID-1].isNotFound())
1917 // Go find this input file.
1918 BitstreamCursor &Cursor = F.InputFilesCursor;
1919 SavedStreamPosition SavedPosition(Cursor);
1920 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1922 InputFileInfo FI = readInputFileInfo(F, ID);
1923 off_t StoredSize = FI.StoredSize;
1924 time_t StoredTime = FI.StoredTime;
1925 bool Overridden = FI.Overridden;
1926 bool Transient = FI.Transient;
1927 StringRef Filename = FI.Filename;
1929 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
1931 // If we didn't find the file, resolve it relative to the
1932 // original directory from which this AST file was created.
1933 if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
1934 F.OriginalDir != CurrentDir) {
1935 std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
1938 if (!Resolved.empty())
1939 File = FileMgr.getFile(Resolved);
1942 // For an overridden file, create a virtual file with the stored
1944 if ((Overridden || Transient) && File == nullptr)
1945 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
1947 if (File == nullptr) {
1949 std::string ErrorStr = "could not find file '";
1950 ErrorStr += Filename;
1951 ErrorStr += "' referenced by AST file '";
1952 ErrorStr += F.FileName;
1954 Error(ErrorStr.c_str());
1956 // Record that we didn't find the file.
1957 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
1961 // Check if there was a request to override the contents of the file
1962 // that was part of the precompiled header. Overridding such a file
1963 // can lead to problems when lexing using the source locations from the
1965 SourceManager &SM = getSourceManager();
1966 // FIXME: Reject if the overrides are different.
1967 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
1969 Error(diag::err_fe_pch_file_overridden, Filename);
1970 // After emitting the diagnostic, recover by disabling the override so
1971 // that the original file will be used.
1973 // FIXME: This recovery is just as broken as the original state; there may
1974 // be another precompiled module that's using the overridden contents, or
1975 // we might be half way through parsing it. Instead, we should treat the
1976 // overridden contents as belonging to a separate FileEntry.
1977 SM.disableFileContentsOverride(File);
1978 // The FileEntry is a virtual file entry with the size of the contents
1979 // that would override the original contents. Set it to the original's
1981 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
1982 StoredSize, StoredTime);
1985 bool IsOutOfDate = false;
1987 // For an overridden file, there is nothing to validate.
1988 if (!Overridden && //
1989 (StoredSize != File->getSize() ||
1990 #if defined(LLVM_ON_WIN32)
1993 // In our regression testing, the Windows file system seems to
1994 // have inconsistent modification times that sometimes
1995 // erroneously trigger this error-handling path.
1997 // FIXME: This probably also breaks HeaderFileInfo lookups on Windows.
1998 (StoredTime && StoredTime != File->getModificationTime() &&
2003 // Build a list of the PCH imports that got us here (in reverse).
2004 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2005 while (ImportStack.back()->ImportedBy.size() > 0)
2006 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2008 // The top-level PCH is stale.
2009 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2010 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2012 // Print the import stack.
2013 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2014 Diag(diag::note_pch_required_by)
2015 << Filename << ImportStack[0]->FileName;
2016 for (unsigned I = 1; I < ImportStack.size(); ++I)
2017 Diag(diag::note_pch_required_by)
2018 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2021 if (!Diags.isDiagnosticInFlight())
2022 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2027 // FIXME: If the file is overridden and we've already opened it,
2028 // issue an error (or split it into a separate FileEntry).
2030 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2032 // Note that we've loaded this input file.
2033 F.InputFilesLoaded[ID-1] = IF;
2037 /// \brief If we are loading a relocatable PCH or module file, and the filename
2038 /// is not an absolute path, add the system or module root to the beginning of
2040 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2041 // Resolve relative to the base directory, if we have one.
2042 if (!M.BaseDirectory.empty())
2043 return ResolveImportedPath(Filename, M.BaseDirectory);
2046 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2047 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2050 SmallString<128> Buffer;
2051 llvm::sys::path::append(Buffer, Prefix, Filename);
2052 Filename.assign(Buffer.begin(), Buffer.end());
2055 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2057 case ASTReader::Failure: return true;
2058 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2059 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2060 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2061 case ASTReader::ConfigurationMismatch:
2062 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2063 case ASTReader::HadErrors: return true;
2064 case ASTReader::Success: return false;
2067 llvm_unreachable("unknown ASTReadResult");
2070 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2071 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2072 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2073 std::string &SuggestedPredefines) {
2074 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2077 // Read all of the records in the options block.
2079 ASTReadResult Result = Success;
2081 llvm::BitstreamEntry Entry = Stream.advance();
2083 switch (Entry.Kind) {
2084 case llvm::BitstreamEntry::Error:
2085 case llvm::BitstreamEntry::SubBlock:
2088 case llvm::BitstreamEntry::EndBlock:
2091 case llvm::BitstreamEntry::Record:
2092 // The interesting case.
2096 // Read and process a record.
2098 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2099 case LANGUAGE_OPTIONS: {
2100 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2101 if (ParseLanguageOptions(Record, Complain, Listener,
2102 AllowCompatibleConfigurationMismatch))
2103 Result = ConfigurationMismatch;
2107 case TARGET_OPTIONS: {
2108 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2109 if (ParseTargetOptions(Record, Complain, Listener,
2110 AllowCompatibleConfigurationMismatch))
2111 Result = ConfigurationMismatch;
2115 case DIAGNOSTIC_OPTIONS: {
2116 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2117 if (!AllowCompatibleConfigurationMismatch &&
2118 ParseDiagnosticOptions(Record, Complain, Listener))
2123 case FILE_SYSTEM_OPTIONS: {
2124 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2125 if (!AllowCompatibleConfigurationMismatch &&
2126 ParseFileSystemOptions(Record, Complain, Listener))
2127 Result = ConfigurationMismatch;
2131 case HEADER_SEARCH_OPTIONS: {
2132 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2133 if (!AllowCompatibleConfigurationMismatch &&
2134 ParseHeaderSearchOptions(Record, Complain, Listener))
2135 Result = ConfigurationMismatch;
2139 case PREPROCESSOR_OPTIONS:
2140 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2141 if (!AllowCompatibleConfigurationMismatch &&
2142 ParsePreprocessorOptions(Record, Complain, Listener,
2143 SuggestedPredefines))
2144 Result = ConfigurationMismatch;
2150 ASTReader::ASTReadResult
2151 ASTReader::ReadControlBlock(ModuleFile &F,
2152 SmallVectorImpl<ImportedModule> &Loaded,
2153 const ModuleFile *ImportedBy,
2154 unsigned ClientLoadCapabilities) {
2155 BitstreamCursor &Stream = F.Stream;
2156 ASTReadResult Result = Success;
2158 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2159 Error("malformed block record in AST file");
2163 // Read all of the records and blocks in the control block.
2165 unsigned NumInputs = 0;
2166 unsigned NumUserInputs = 0;
2168 llvm::BitstreamEntry Entry = Stream.advance();
2170 switch (Entry.Kind) {
2171 case llvm::BitstreamEntry::Error:
2172 Error("malformed block record in AST file");
2174 case llvm::BitstreamEntry::EndBlock: {
2175 // Validate input files.
2176 const HeaderSearchOptions &HSOpts =
2177 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2179 // All user input files reside at the index range [0, NumUserInputs), and
2180 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2181 // loaded module files, ignore missing inputs.
2182 if (!DisableValidation && F.Kind != MK_ExplicitModule) {
2183 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2185 // If we are reading a module, we will create a verification timestamp,
2186 // so we verify all input files. Otherwise, verify only user input
2189 unsigned N = NumUserInputs;
2190 if (ValidateSystemInputs ||
2191 (HSOpts.ModulesValidateOncePerBuildSession &&
2192 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2193 F.Kind == MK_ImplicitModule))
2196 for (unsigned I = 0; I < N; ++I) {
2197 InputFile IF = getInputFile(F, I+1, Complain);
2198 if (!IF.getFile() || IF.isOutOfDate())
2204 Listener->visitModuleFile(F.FileName, F.Kind);
2206 if (Listener && Listener->needsInputFileVisitation()) {
2207 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2209 for (unsigned I = 0; I < N; ++I) {
2210 bool IsSystem = I >= NumUserInputs;
2211 InputFileInfo FI = readInputFileInfo(F, I+1);
2212 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2213 F.Kind == MK_ExplicitModule);
2220 case llvm::BitstreamEntry::SubBlock:
2222 case INPUT_FILES_BLOCK_ID:
2223 F.InputFilesCursor = Stream;
2224 if (Stream.SkipBlock() || // Skip with the main cursor
2225 // Read the abbreviations
2226 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2227 Error("malformed block record in AST file");
2232 case OPTIONS_BLOCK_ID:
2233 // If we're reading the first module for this group, check its options
2234 // are compatible with ours. For modules it imports, no further checking
2235 // is required, because we checked them when we built it.
2236 if (Listener && !ImportedBy) {
2237 // Should we allow the configuration of the module file to differ from
2238 // the configuration of the current translation unit in a compatible
2241 // FIXME: Allow this for files explicitly specified with -include-pch.
2242 bool AllowCompatibleConfigurationMismatch =
2243 F.Kind == MK_ExplicitModule;
2245 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2246 AllowCompatibleConfigurationMismatch,
2247 *Listener, SuggestedPredefines);
2248 if (Result == Failure) {
2249 Error("malformed block record in AST file");
2253 if (DisableValidation ||
2254 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2257 // If we've diagnosed a problem, we're done.
2258 if (Result != Success &&
2259 isDiagnosedResult(Result, ClientLoadCapabilities))
2261 } else if (Stream.SkipBlock()) {
2262 Error("malformed block record in AST file");
2268 if (Stream.SkipBlock()) {
2269 Error("malformed block record in AST file");
2275 case llvm::BitstreamEntry::Record:
2276 // The interesting case.
2280 // Read and process a record.
2283 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2285 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2286 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2287 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2288 : diag::err_pch_version_too_new);
2289 return VersionMismatch;
2292 bool hasErrors = Record[6];
2293 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2294 Diag(diag::err_pch_with_compiler_errors);
2298 F.RelocatablePCH = Record[4];
2299 // Relative paths in a relocatable PCH are relative to our sysroot.
2300 if (F.RelocatablePCH)
2301 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2303 F.HasTimestamps = Record[5];
2305 const std::string &CurBranch = getClangFullRepositoryVersion();
2306 StringRef ASTBranch = Blob;
2307 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2308 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2309 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2310 return VersionMismatch;
2316 assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
2317 F.Signature = Record[0];
2321 // Load each of the imported PCH files.
2322 unsigned Idx = 0, N = Record.size();
2324 // Read information about the AST file.
2325 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2326 // The import location will be the local one for now; we will adjust
2327 // all import locations of module imports after the global source
2328 // location info are setup.
2329 SourceLocation ImportLoc =
2330 SourceLocation::getFromRawEncoding(Record[Idx++]);
2331 off_t StoredSize = (off_t)Record[Idx++];
2332 time_t StoredModTime = (time_t)Record[Idx++];
2333 ASTFileSignature StoredSignature = Record[Idx++];
2334 auto ImportedFile = ReadPath(F, Record, Idx);
2336 // If our client can't cope with us being out of date, we can't cope with
2337 // our dependency being missing.
2338 unsigned Capabilities = ClientLoadCapabilities;
2339 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2340 Capabilities &= ~ARR_Missing;
2342 // Load the AST file.
2343 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2344 Loaded, StoredSize, StoredModTime,
2345 StoredSignature, Capabilities);
2347 // If we diagnosed a problem, produce a backtrace.
2348 if (isDiagnosedResult(Result, Capabilities))
2349 Diag(diag::note_module_file_imported_by)
2350 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2353 case Failure: return Failure;
2354 // If we have to ignore the dependency, we'll have to ignore this too.
2356 case OutOfDate: return OutOfDate;
2357 case VersionMismatch: return VersionMismatch;
2358 case ConfigurationMismatch: return ConfigurationMismatch;
2359 case HadErrors: return HadErrors;
2360 case Success: break;
2367 F.OriginalSourceFileID = FileID::get(Record[0]);
2368 F.ActualOriginalSourceFileName = Blob;
2369 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2370 ResolveImportedPath(F, F.OriginalSourceFileName);
2373 case ORIGINAL_FILE_ID:
2374 F.OriginalSourceFileID = FileID::get(Record[0]);
2377 case ORIGINAL_PCH_DIR:
2378 F.OriginalDir = Blob;
2382 F.ModuleName = Blob;
2384 Listener->ReadModuleName(F.ModuleName);
2387 case MODULE_DIRECTORY: {
2388 assert(!F.ModuleName.empty() &&
2389 "MODULE_DIRECTORY found before MODULE_NAME");
2390 // If we've already loaded a module map file covering this module, we may
2391 // have a better path for it (relative to the current build).
2392 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2393 if (M && M->Directory) {
2394 // If we're implicitly loading a module, the base directory can't
2395 // change between the build and use.
2396 if (F.Kind != MK_ExplicitModule) {
2397 const DirectoryEntry *BuildDir =
2398 PP.getFileManager().getDirectory(Blob);
2399 if (!BuildDir || BuildDir != M->Directory) {
2400 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2401 Diag(diag::err_imported_module_relocated)
2402 << F.ModuleName << Blob << M->Directory->getName();
2406 F.BaseDirectory = M->Directory->getName();
2408 F.BaseDirectory = Blob;
2413 case MODULE_MAP_FILE:
2414 if (ASTReadResult Result =
2415 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2419 case INPUT_FILE_OFFSETS:
2420 NumInputs = Record[0];
2421 NumUserInputs = Record[1];
2422 F.InputFileOffsets =
2423 (const llvm::support::unaligned_uint64_t *)Blob.data();
2424 F.InputFilesLoaded.resize(NumInputs);
2430 ASTReader::ASTReadResult
2431 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2432 BitstreamCursor &Stream = F.Stream;
2434 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2435 Error("malformed block record in AST file");
2439 // Read all of the records and blocks for the AST file.
2442 llvm::BitstreamEntry Entry = Stream.advance();
2444 switch (Entry.Kind) {
2445 case llvm::BitstreamEntry::Error:
2446 Error("error at end of module block in AST file");
2448 case llvm::BitstreamEntry::EndBlock: {
2449 // Outside of C++, we do not store a lookup map for the translation unit.
2450 // Instead, mark it as needing a lookup map to be built if this module
2451 // contains any declarations lexically within it (which it always does!).
2452 // This usually has no cost, since we very rarely need the lookup map for
2453 // the translation unit outside C++.
2454 DeclContext *DC = Context.getTranslationUnitDecl();
2455 if (DC->hasExternalLexicalStorage() &&
2456 !getContext().getLangOpts().CPlusPlus)
2457 DC->setMustBuildLookupTable();
2461 case llvm::BitstreamEntry::SubBlock:
2463 case DECLTYPES_BLOCK_ID:
2464 // We lazily load the decls block, but we want to set up the
2465 // DeclsCursor cursor to point into it. Clone our current bitcode
2466 // cursor to it, enter the block and read the abbrevs in that block.
2467 // With the main cursor, we just skip over it.
2468 F.DeclsCursor = Stream;
2469 if (Stream.SkipBlock() || // Skip with the main cursor.
2470 // Read the abbrevs.
2471 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2472 Error("malformed block record in AST file");
2477 case PREPROCESSOR_BLOCK_ID:
2478 F.MacroCursor = Stream;
2479 if (!PP.getExternalSource())
2480 PP.setExternalSource(this);
2482 if (Stream.SkipBlock() ||
2483 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2484 Error("malformed block record in AST file");
2487 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2490 case PREPROCESSOR_DETAIL_BLOCK_ID:
2491 F.PreprocessorDetailCursor = Stream;
2492 if (Stream.SkipBlock() ||
2493 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2494 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2495 Error("malformed preprocessor detail record in AST file");
2498 F.PreprocessorDetailStartOffset
2499 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2501 if (!PP.getPreprocessingRecord())
2502 PP.createPreprocessingRecord();
2503 if (!PP.getPreprocessingRecord()->getExternalSource())
2504 PP.getPreprocessingRecord()->SetExternalSource(*this);
2507 case SOURCE_MANAGER_BLOCK_ID:
2508 if (ReadSourceManagerBlock(F))
2512 case SUBMODULE_BLOCK_ID:
2513 if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
2517 case COMMENTS_BLOCK_ID: {
2518 BitstreamCursor C = Stream;
2519 if (Stream.SkipBlock() ||
2520 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2521 Error("malformed comments block in AST file");
2524 CommentsCursors.push_back(std::make_pair(C, &F));
2529 if (Stream.SkipBlock()) {
2530 Error("malformed block record in AST file");
2537 case llvm::BitstreamEntry::Record:
2538 // The interesting case.
2542 // Read and process a record.
2545 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2546 default: // Default behavior: ignore.
2550 if (F.LocalNumTypes != 0) {
2551 Error("duplicate TYPE_OFFSET record in AST file");
2554 F.TypeOffsets = (const uint32_t *)Blob.data();
2555 F.LocalNumTypes = Record[0];
2556 unsigned LocalBaseTypeIndex = Record[1];
2557 F.BaseTypeIndex = getTotalNumTypes();
2559 if (F.LocalNumTypes > 0) {
2560 // Introduce the global -> local mapping for types within this module.
2561 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2563 // Introduce the local -> global mapping for types within this module.
2564 F.TypeRemap.insertOrReplace(
2565 std::make_pair(LocalBaseTypeIndex,
2566 F.BaseTypeIndex - LocalBaseTypeIndex));
2568 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2574 if (F.LocalNumDecls != 0) {
2575 Error("duplicate DECL_OFFSET record in AST file");
2578 F.DeclOffsets = (const DeclOffset *)Blob.data();
2579 F.LocalNumDecls = Record[0];
2580 unsigned LocalBaseDeclID = Record[1];
2581 F.BaseDeclID = getTotalNumDecls();
2583 if (F.LocalNumDecls > 0) {
2584 // Introduce the global -> local mapping for declarations within this
2586 GlobalDeclMap.insert(
2587 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2589 // Introduce the local -> global mapping for declarations within this
2591 F.DeclRemap.insertOrReplace(
2592 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2594 // Introduce the global -> local mapping for declarations within this
2596 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2598 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2603 case TU_UPDATE_LEXICAL: {
2604 DeclContext *TU = Context.getTranslationUnitDecl();
2605 LexicalContents Contents(
2606 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2608 static_cast<unsigned int>(Blob.size() / 4));
2609 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2610 TU->setHasExternalLexicalStorage(true);
2614 case UPDATE_VISIBLE: {
2616 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2617 auto *Data = (const unsigned char*)Blob.data();
2618 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2619 // If we've already loaded the decl, perform the updates when we finish
2620 // loading this block.
2621 if (Decl *D = GetExistingDecl(ID))
2622 PendingUpdateRecords.push_back(std::make_pair(ID, D));
2626 case IDENTIFIER_TABLE:
2627 F.IdentifierTableData = Blob.data();
2629 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2630 (const unsigned char *)F.IdentifierTableData + Record[0],
2631 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2632 (const unsigned char *)F.IdentifierTableData,
2633 ASTIdentifierLookupTrait(*this, F));
2635 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2639 case IDENTIFIER_OFFSET: {
2640 if (F.LocalNumIdentifiers != 0) {
2641 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2644 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2645 F.LocalNumIdentifiers = Record[0];
2646 unsigned LocalBaseIdentifierID = Record[1];
2647 F.BaseIdentifierID = getTotalNumIdentifiers();
2649 if (F.LocalNumIdentifiers > 0) {
2650 // Introduce the global -> local mapping for identifiers within this
2652 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2655 // Introduce the local -> global mapping for identifiers within this
2657 F.IdentifierRemap.insertOrReplace(
2658 std::make_pair(LocalBaseIdentifierID,
2659 F.BaseIdentifierID - LocalBaseIdentifierID));
2661 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2662 + F.LocalNumIdentifiers);
2667 case INTERESTING_IDENTIFIERS:
2668 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2671 case EAGERLY_DESERIALIZED_DECLS:
2672 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2673 // about "interesting" decls (for instance, if we're building a module).
2674 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2675 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2679 if (SpecialTypes.empty()) {
2680 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2681 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2685 if (SpecialTypes.size() != Record.size()) {
2686 Error("invalid special-types record");
2690 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2691 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2692 if (!SpecialTypes[I])
2693 SpecialTypes[I] = ID;
2694 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2700 TotalNumStatements += Record[0];
2701 TotalNumMacros += Record[1];
2702 TotalLexicalDeclContexts += Record[2];
2703 TotalVisibleDeclContexts += Record[3];
2706 case UNUSED_FILESCOPED_DECLS:
2707 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2708 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2711 case DELEGATING_CTORS:
2712 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2713 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2716 case WEAK_UNDECLARED_IDENTIFIERS:
2717 if (Record.size() % 4 != 0) {
2718 Error("invalid weak identifiers record");
2722 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2723 // files. This isn't the way to do it :)
2724 WeakUndeclaredIdentifiers.clear();
2726 // Translate the weak, undeclared identifiers into global IDs.
2727 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2728 WeakUndeclaredIdentifiers.push_back(
2729 getGlobalIdentifierID(F, Record[I++]));
2730 WeakUndeclaredIdentifiers.push_back(
2731 getGlobalIdentifierID(F, Record[I++]));
2732 WeakUndeclaredIdentifiers.push_back(
2733 ReadSourceLocation(F, Record, I).getRawEncoding());
2734 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2738 case SELECTOR_OFFSETS: {
2739 F.SelectorOffsets = (const uint32_t *)Blob.data();
2740 F.LocalNumSelectors = Record[0];
2741 unsigned LocalBaseSelectorID = Record[1];
2742 F.BaseSelectorID = getTotalNumSelectors();
2744 if (F.LocalNumSelectors > 0) {
2745 // Introduce the global -> local mapping for selectors within this
2747 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2749 // Introduce the local -> global mapping for selectors within this
2751 F.SelectorRemap.insertOrReplace(
2752 std::make_pair(LocalBaseSelectorID,
2753 F.BaseSelectorID - LocalBaseSelectorID));
2755 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2761 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
2763 F.SelectorLookupTable
2764 = ASTSelectorLookupTable::Create(
2765 F.SelectorLookupTableData + Record[0],
2766 F.SelectorLookupTableData,
2767 ASTSelectorLookupTrait(*this, F));
2768 TotalNumMethodPoolEntries += Record[1];
2771 case REFERENCED_SELECTOR_POOL:
2772 if (!Record.empty()) {
2773 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2774 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2776 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2782 case PP_COUNTER_VALUE:
2783 if (!Record.empty() && Listener)
2784 Listener->ReadCounter(F, Record[0]);
2787 case FILE_SORTED_DECLS:
2788 F.FileSortedDecls = (const DeclID *)Blob.data();
2789 F.NumFileSortedDecls = Record[0];
2792 case SOURCE_LOCATION_OFFSETS: {
2793 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
2794 F.LocalNumSLocEntries = Record[0];
2795 unsigned SLocSpaceSize = Record[1];
2796 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2797 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2799 if (!F.SLocEntryBaseID) {
2800 Error("ran out of source locations");
2803 // Make our entry in the range map. BaseID is negative and growing, so
2804 // we invert it. Because we invert it, though, we need the other end of
2806 unsigned RangeStart =
2807 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2808 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2809 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2811 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2812 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2813 GlobalSLocOffsetMap.insert(
2814 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2815 - SLocSpaceSize,&F));
2817 // Initialize the remapping table.
2818 // Invalid stays invalid.
2819 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
2820 // This module. Base was 2 when being compiled.
2821 F.SLocRemap.insertOrReplace(std::make_pair(2U,
2822 static_cast<int>(F.SLocEntryBaseOffset - 2)));
2824 TotalNumSLocEntries += F.LocalNumSLocEntries;
2828 case MODULE_OFFSET_MAP: {
2829 // Additional remapping information.
2830 const unsigned char *Data = (const unsigned char*)Blob.data();
2831 const unsigned char *DataEnd = Data + Blob.size();
2833 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
2834 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
2835 F.SLocRemap.insert(std::make_pair(0U, 0));
2836 F.SLocRemap.insert(std::make_pair(2U, 1));
2839 // Continuous range maps we may be updating in our module.
2840 typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
2842 RemapBuilder SLocRemap(F.SLocRemap);
2843 RemapBuilder IdentifierRemap(F.IdentifierRemap);
2844 RemapBuilder MacroRemap(F.MacroRemap);
2845 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2846 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
2847 RemapBuilder SelectorRemap(F.SelectorRemap);
2848 RemapBuilder DeclRemap(F.DeclRemap);
2849 RemapBuilder TypeRemap(F.TypeRemap);
2851 while (Data < DataEnd) {
2852 using namespace llvm::support;
2853 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
2854 StringRef Name = StringRef((const char*)Data, Len);
2856 ModuleFile *OM = ModuleMgr.lookup(Name);
2858 Error("SourceLocation remap refers to unknown module");
2862 uint32_t SLocOffset =
2863 endian::readNext<uint32_t, little, unaligned>(Data);
2864 uint32_t IdentifierIDOffset =
2865 endian::readNext<uint32_t, little, unaligned>(Data);
2866 uint32_t MacroIDOffset =
2867 endian::readNext<uint32_t, little, unaligned>(Data);
2868 uint32_t PreprocessedEntityIDOffset =
2869 endian::readNext<uint32_t, little, unaligned>(Data);
2870 uint32_t SubmoduleIDOffset =
2871 endian::readNext<uint32_t, little, unaligned>(Data);
2872 uint32_t SelectorIDOffset =
2873 endian::readNext<uint32_t, little, unaligned>(Data);
2874 uint32_t DeclIDOffset =
2875 endian::readNext<uint32_t, little, unaligned>(Data);
2876 uint32_t TypeIndexOffset =
2877 endian::readNext<uint32_t, little, unaligned>(Data);
2879 uint32_t None = std::numeric_limits<uint32_t>::max();
2881 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
2882 RemapBuilder &Remap) {
2884 Remap.insert(std::make_pair(Offset,
2885 static_cast<int>(BaseOffset - Offset)));
2887 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
2888 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
2889 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
2890 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
2891 PreprocessedEntityRemap);
2892 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
2893 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
2894 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
2895 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
2897 // Global -> local mappings.
2898 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2903 case SOURCE_MANAGER_LINE_TABLE:
2904 if (ParseLineTable(F, Record))
2908 case SOURCE_LOCATION_PRELOADS: {
2909 // Need to transform from the local view (1-based IDs) to the global view,
2910 // which is based off F.SLocEntryBaseID.
2911 if (!F.PreloadSLocEntries.empty()) {
2912 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
2916 F.PreloadSLocEntries.swap(Record);
2920 case EXT_VECTOR_DECLS:
2921 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2922 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2926 if (Record.size() % 3 != 0) {
2927 Error("Invalid VTABLE_USES record");
2931 // Later tables overwrite earlier ones.
2932 // FIXME: Modules will have some trouble with this. This is clearly not
2933 // the right way to do this.
2936 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2937 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2938 VTableUses.push_back(
2939 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2940 VTableUses.push_back(Record[Idx++]);
2944 case PENDING_IMPLICIT_INSTANTIATIONS:
2945 if (PendingInstantiations.size() % 2 != 0) {
2946 Error("Invalid existing PendingInstantiations");
2950 if (Record.size() % 2 != 0) {
2951 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2955 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2956 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2957 PendingInstantiations.push_back(
2958 ReadSourceLocation(F, Record, I).getRawEncoding());
2962 case SEMA_DECL_REFS:
2963 if (Record.size() != 2) {
2964 Error("Invalid SEMA_DECL_REFS block");
2967 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2968 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2971 case PPD_ENTITIES_OFFSETS: {
2972 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
2973 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
2974 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
2976 unsigned LocalBasePreprocessedEntityID = Record[0];
2978 unsigned StartingID;
2979 if (!PP.getPreprocessingRecord())
2980 PP.createPreprocessingRecord();
2981 if (!PP.getPreprocessingRecord()->getExternalSource())
2982 PP.getPreprocessingRecord()->SetExternalSource(*this);
2984 = PP.getPreprocessingRecord()
2985 ->allocateLoadedEntities(F.NumPreprocessedEntities);
2986 F.BasePreprocessedEntityID = StartingID;
2988 if (F.NumPreprocessedEntities > 0) {
2989 // Introduce the global -> local mapping for preprocessed entities in
2991 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2993 // Introduce the local -> global mapping for preprocessed entities in
2995 F.PreprocessedEntityRemap.insertOrReplace(
2996 std::make_pair(LocalBasePreprocessedEntityID,
2997 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3003 case DECL_UPDATE_OFFSETS: {
3004 if (Record.size() % 2 != 0) {
3005 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3008 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3009 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3010 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3012 // If we've already loaded the decl, perform the updates when we finish
3013 // loading this block.
3014 if (Decl *D = GetExistingDecl(ID))
3015 PendingUpdateRecords.push_back(std::make_pair(ID, D));
3020 case DECL_REPLACEMENTS: {
3021 if (Record.size() % 3 != 0) {
3022 Error("invalid DECL_REPLACEMENTS block in AST file");
3025 for (unsigned I = 0, N = Record.size(); I != N; I += 3)
3026 ReplacedDecls[getGlobalDeclID(F, Record[I])]
3027 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
3031 case OBJC_CATEGORIES_MAP: {
3032 if (F.LocalNumObjCCategoriesInMap != 0) {
3033 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3037 F.LocalNumObjCCategoriesInMap = Record[0];
3038 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3042 case OBJC_CATEGORIES:
3043 F.ObjCCategories.swap(Record);
3046 case CXX_BASE_SPECIFIER_OFFSETS: {
3047 if (F.LocalNumCXXBaseSpecifiers != 0) {
3048 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
3052 F.LocalNumCXXBaseSpecifiers = Record[0];
3053 F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data();
3057 case CXX_CTOR_INITIALIZERS_OFFSETS: {
3058 if (F.LocalNumCXXCtorInitializers != 0) {
3059 Error("duplicate CXX_CTOR_INITIALIZERS_OFFSETS record in AST file");
3063 F.LocalNumCXXCtorInitializers = Record[0];
3064 F.CXXCtorInitializersOffsets = (const uint32_t *)Blob.data();
3068 case DIAG_PRAGMA_MAPPINGS:
3069 if (F.PragmaDiagMappings.empty())
3070 F.PragmaDiagMappings.swap(Record);
3072 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3073 Record.begin(), Record.end());
3076 case CUDA_SPECIAL_DECL_REFS:
3077 // Later tables overwrite earlier ones.
3078 // FIXME: Modules will have trouble with this.
3079 CUDASpecialDeclRefs.clear();
3080 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3081 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3084 case HEADER_SEARCH_TABLE: {
3085 F.HeaderFileInfoTableData = Blob.data();
3086 F.LocalNumHeaderFileInfos = Record[1];
3088 F.HeaderFileInfoTable
3089 = HeaderFileInfoLookupTable::Create(
3090 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3091 (const unsigned char *)F.HeaderFileInfoTableData,
3092 HeaderFileInfoTrait(*this, F,
3093 &PP.getHeaderSearchInfo(),
3094 Blob.data() + Record[2]));
3096 PP.getHeaderSearchInfo().SetExternalSource(this);
3097 if (!PP.getHeaderSearchInfo().getExternalLookup())
3098 PP.getHeaderSearchInfo().SetExternalLookup(this);
3103 case FP_PRAGMA_OPTIONS:
3104 // Later tables overwrite earlier ones.
3105 FPPragmaOptions.swap(Record);
3108 case OPENCL_EXTENSIONS:
3109 // Later tables overwrite earlier ones.
3110 OpenCLExtensions.swap(Record);
3113 case TENTATIVE_DEFINITIONS:
3114 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3115 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3118 case KNOWN_NAMESPACES:
3119 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3120 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3123 case UNDEFINED_BUT_USED:
3124 if (UndefinedButUsed.size() % 2 != 0) {
3125 Error("Invalid existing UndefinedButUsed");
3129 if (Record.size() % 2 != 0) {
3130 Error("invalid undefined-but-used record");
3133 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3134 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3135 UndefinedButUsed.push_back(
3136 ReadSourceLocation(F, Record, I).getRawEncoding());
3139 case DELETE_EXPRS_TO_ANALYZE:
3140 for (unsigned I = 0, N = Record.size(); I != N;) {
3141 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3142 const uint64_t Count = Record[I++];
3143 DelayedDeleteExprs.push_back(Count);
3144 for (uint64_t C = 0; C < Count; ++C) {
3145 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3146 bool IsArrayForm = Record[I++] == 1;
3147 DelayedDeleteExprs.push_back(IsArrayForm);
3152 case IMPORTED_MODULES: {
3153 if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
3154 // If we aren't loading a module (which has its own exports), make
3155 // all of the imported modules visible.
3156 // FIXME: Deal with macros-only imports.
3157 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3158 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3159 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3161 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3167 case MACRO_OFFSET: {
3168 if (F.LocalNumMacros != 0) {
3169 Error("duplicate MACRO_OFFSET record in AST file");
3172 F.MacroOffsets = (const uint32_t *)Blob.data();
3173 F.LocalNumMacros = Record[0];
3174 unsigned LocalBaseMacroID = Record[1];
3175 F.BaseMacroID = getTotalNumMacros();
3177 if (F.LocalNumMacros > 0) {
3178 // Introduce the global -> local mapping for macros within this module.
3179 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3181 // Introduce the local -> global mapping for macros within this module.
3182 F.MacroRemap.insertOrReplace(
3183 std::make_pair(LocalBaseMacroID,
3184 F.BaseMacroID - LocalBaseMacroID));
3186 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3191 case LATE_PARSED_TEMPLATE: {
3192 LateParsedTemplates.append(Record.begin(), Record.end());
3196 case OPTIMIZE_PRAGMA_OPTIONS:
3197 if (Record.size() != 1) {
3198 Error("invalid pragma optimize record");
3201 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3204 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3205 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3206 UnusedLocalTypedefNameCandidates.push_back(
3207 getGlobalDeclID(F, Record[I]));
3213 ASTReader::ASTReadResult
3214 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3215 const ModuleFile *ImportedBy,
3216 unsigned ClientLoadCapabilities) {
3218 F.ModuleMapPath = ReadPath(F, Record, Idx);
3220 if (F.Kind == MK_ExplicitModule) {
3221 // For an explicitly-loaded module, we don't care whether the original
3222 // module map file exists or matches.
3226 // Try to resolve ModuleName in the current header search context and
3227 // verify that it is found in the same module map file as we saved. If the
3228 // top-level AST file is a main file, skip this check because there is no
3229 // usable header search context.
3230 assert(!F.ModuleName.empty() &&
3231 "MODULE_NAME should come before MODULE_MAP_FILE");
3232 if (F.Kind == MK_ImplicitModule &&
3233 (*ModuleMgr.begin())->Kind != MK_MainFile) {
3234 // An implicitly-loaded module file should have its module listed in some
3235 // module map file that we've already loaded.
3236 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3237 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3238 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3240 assert(ImportedBy && "top-level import should be verified");
3241 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3242 if (auto *ASTFE = M ? M->getASTFile() : nullptr)
3243 // This module was defined by an imported (explicit) module.
3244 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3245 << ASTFE->getName();
3247 // This module was built with a different module map.
3248 Diag(diag::err_imported_module_not_found)
3249 << F.ModuleName << F.FileName << ImportedBy->FileName
3255 assert(M->Name == F.ModuleName && "found module with different name");
3257 // Check the primary module map file.
3258 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3259 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3260 assert(ModMap && "found module is missing module map file");
3261 assert(ImportedBy && "top-level import should be verified");
3262 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3263 Diag(diag::err_imported_module_modmap_changed)
3264 << F.ModuleName << ImportedBy->FileName
3265 << ModMap->getName() << F.ModuleMapPath;
3269 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3270 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3271 // FIXME: we should use input files rather than storing names.
3272 std::string Filename = ReadPath(F, Record, Idx);
3273 const FileEntry *F =
3274 FileMgr.getFile(Filename, false, false);
3276 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3277 Error("could not find file '" + Filename +"' referenced by AST file");
3280 AdditionalStoredMaps.insert(F);
3283 // Check any additional module map files (e.g. module.private.modulemap)
3284 // that are not in the pcm.
3285 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3286 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3287 // Remove files that match
3288 // Note: SmallPtrSet::erase is really remove
3289 if (!AdditionalStoredMaps.erase(ModMap)) {
3290 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3291 Diag(diag::err_module_different_modmap)
3292 << F.ModuleName << /*new*/0 << ModMap->getName();
3298 // Check any additional module map files that are in the pcm, but not
3299 // found in header search. Cases that match are already removed.
3300 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3301 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3302 Diag(diag::err_module_different_modmap)
3303 << F.ModuleName << /*not new*/1 << ModMap->getName();
3309 Listener->ReadModuleMapFile(F.ModuleMapPath);
3314 /// \brief Move the given method to the back of the global list of methods.
3315 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3316 // Find the entry for this selector in the method pool.
3317 Sema::GlobalMethodPool::iterator Known
3318 = S.MethodPool.find(Method->getSelector());
3319 if (Known == S.MethodPool.end())
3322 // Retrieve the appropriate method list.
3323 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3324 : Known->second.second;
3326 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3328 if (List->getMethod() == Method) {
3336 if (List->getNext())
3337 List->setMethod(List->getNext()->getMethod());
3339 List->setMethod(Method);
3343 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3344 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3345 for (Decl *D : Names) {
3346 bool wasHidden = D->Hidden;
3349 if (wasHidden && SemaObj) {
3350 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3351 moveMethodToBackOfGlobalList(*SemaObj, Method);
3357 void ASTReader::makeModuleVisible(Module *Mod,
3358 Module::NameVisibilityKind NameVisibility,
3359 SourceLocation ImportLoc) {
3360 llvm::SmallPtrSet<Module *, 4> Visited;
3361 SmallVector<Module *, 4> Stack;
3362 Stack.push_back(Mod);
3363 while (!Stack.empty()) {
3364 Mod = Stack.pop_back_val();
3366 if (NameVisibility <= Mod->NameVisibility) {
3367 // This module already has this level of visibility (or greater), so
3368 // there is nothing more to do.
3372 if (!Mod->isAvailable()) {
3373 // Modules that aren't available cannot be made visible.
3377 // Update the module's name visibility.
3378 Mod->NameVisibility = NameVisibility;
3380 // If we've already deserialized any names from this module,
3381 // mark them as visible.
3382 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3383 if (Hidden != HiddenNamesMap.end()) {
3384 auto HiddenNames = std::move(*Hidden);
3385 HiddenNamesMap.erase(Hidden);
3386 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3387 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3388 "making names visible added hidden names");
3391 // Push any exported modules onto the stack to be marked as visible.
3392 SmallVector<Module *, 16> Exports;
3393 Mod->getExportedModules(Exports);
3394 for (SmallVectorImpl<Module *>::iterator
3395 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3396 Module *Exported = *I;
3397 if (Visited.insert(Exported).second)
3398 Stack.push_back(Exported);
3403 bool ASTReader::loadGlobalIndex() {
3407 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3408 !Context.getLangOpts().Modules)
3411 // Try to load the global index.
3412 TriedLoadingGlobalIndex = true;
3413 StringRef ModuleCachePath
3414 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3415 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3416 = GlobalModuleIndex::readIndex(ModuleCachePath);
3420 GlobalIndex.reset(Result.first);
3421 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3425 bool ASTReader::isGlobalIndexUnavailable() const {
3426 return Context.getLangOpts().Modules && UseGlobalIndex &&
3427 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3430 static void updateModuleTimestamp(ModuleFile &MF) {
3431 // Overwrite the timestamp file contents so that file's mtime changes.
3432 std::string TimestampFilename = MF.getTimestampFilename();
3434 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3437 OS << "Timestamp file\n";
3440 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3441 /// cursor into the start of the given block ID, returning false on success and
3442 /// true on failure.
3443 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3445 llvm::BitstreamEntry Entry = Cursor.advance();
3446 switch (Entry.Kind) {
3447 case llvm::BitstreamEntry::Error:
3448 case llvm::BitstreamEntry::EndBlock:
3451 case llvm::BitstreamEntry::Record:
3452 // Ignore top-level records.
3453 Cursor.skipRecord(Entry.ID);
3456 case llvm::BitstreamEntry::SubBlock:
3457 if (Entry.ID == BlockID) {
3458 if (Cursor.EnterSubBlock(BlockID))
3464 if (Cursor.SkipBlock())
3470 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
3472 SourceLocation ImportLoc,
3473 unsigned ClientLoadCapabilities) {
3474 llvm::SaveAndRestore<SourceLocation>
3475 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3477 // Defer any pending actions until we get to the end of reading the AST file.
3478 Deserializing AnASTFile(this);
3480 // Bump the generation number.
3481 unsigned PreviousGeneration = incrementGeneration(Context);
3483 unsigned NumModules = ModuleMgr.size();
3484 SmallVector<ImportedModule, 4> Loaded;
3485 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
3486 /*ImportedBy=*/nullptr, Loaded,
3488 ClientLoadCapabilities)) {
3492 case VersionMismatch:
3493 case ConfigurationMismatch:
3495 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3496 for (const ImportedModule &IM : Loaded)
3497 LoadedSet.insert(IM.Mod);
3499 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
3501 Context.getLangOpts().Modules
3502 ? &PP.getHeaderSearchInfo().getModuleMap()
3505 // If we find that any modules are unusable, the global index is going
3506 // to be out-of-date. Just remove it.
3507 GlobalIndex.reset();
3508 ModuleMgr.setGlobalIndex(nullptr);
3515 // Here comes stuff that we only do once the entire chain is loaded.
3517 // Load the AST blocks of all of the modules that we loaded.
3518 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3519 MEnd = Loaded.end();
3521 ModuleFile &F = *M->Mod;
3523 // Read the AST block.
3524 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3527 // Read the extension blocks.
3528 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3529 if (ASTReadResult Result = ReadExtensionBlock(F))
3533 // Once read, set the ModuleFile bit base offset and update the size in
3534 // bits of all files we've seen.
3535 F.GlobalBitOffset = TotalModulesSizeInBits;
3536 TotalModulesSizeInBits += F.SizeInBits;
3537 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3539 // Preload SLocEntries.
3540 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3541 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3542 // Load it through the SourceManager and don't call ReadSLocEntry()
3543 // directly because the entry may have already been loaded in which case
3544 // calling ReadSLocEntry() directly would trigger an assertion in
3546 SourceMgr.getLoadedSLocEntryByID(Index);
3549 // Preload all the pending interesting identifiers by marking them out of
3551 for (auto Offset : F.PreloadIdentifierOffsets) {
3552 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3553 F.IdentifierTableData + Offset);
3555 ASTIdentifierLookupTrait Trait(*this, F);
3556 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3557 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3558 auto &II = PP.getIdentifierTable().getOwn(Key);
3559 II.setOutOfDate(true);
3561 // Mark this identifier as being from an AST file so that we can track
3562 // whether we need to serialize it.
3563 if (!II.isFromAST()) {
3565 bool IsModule = PP.getCurrentModule() != nullptr;
3566 if (isInterestingIdentifier(*this, II, IsModule))
3567 II.setChangedSinceDeserialization();
3570 // Associate the ID with the identifier so that the writer can reuse it.
3571 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3572 SetIdentifierInfo(ID, &II);
3576 // Setup the import locations and notify the module manager that we've
3577 // committed to these module files.
3578 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3579 MEnd = Loaded.end();
3581 ModuleFile &F = *M->Mod;
3583 ModuleMgr.moduleFileAccepted(&F);
3585 // Set the import location.
3586 F.DirectImportLoc = ImportLoc;
3588 F.ImportLoc = M->ImportLoc;
3590 F.ImportLoc = ReadSourceLocation(*M->ImportedBy,
3591 M->ImportLoc.getRawEncoding());
3594 if (!Context.getLangOpts().CPlusPlus ||
3595 (Type != MK_ImplicitModule && Type != MK_ExplicitModule)) {
3596 // Mark all of the identifiers in the identifier table as being out of date,
3597 // so that various accessors know to check the loaded modules when the
3598 // identifier is used.
3600 // For C++ modules, we don't need information on many identifiers (just
3601 // those that provide macros or are poisoned), so we mark all of
3602 // the interesting ones via PreloadIdentifierOffsets.
3603 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3604 IdEnd = PP.getIdentifierTable().end();
3606 Id->second->setOutOfDate(true);
3609 // Resolve any unresolved module exports.
3610 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3611 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3612 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3613 Module *ResolvedMod = getSubmodule(GlobalID);
3615 switch (Unresolved.Kind) {
3616 case UnresolvedModuleRef::Conflict:
3618 Module::Conflict Conflict;
3619 Conflict.Other = ResolvedMod;
3620 Conflict.Message = Unresolved.String.str();
3621 Unresolved.Mod->Conflicts.push_back(Conflict);
3625 case UnresolvedModuleRef::Import:
3627 Unresolved.Mod->Imports.insert(ResolvedMod);
3630 case UnresolvedModuleRef::Export:
3631 if (ResolvedMod || Unresolved.IsWildcard)
3632 Unresolved.Mod->Exports.push_back(
3633 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3637 UnresolvedModuleRefs.clear();
3639 // FIXME: How do we load the 'use'd modules? They may not be submodules.
3640 // Might be unnecessary as use declarations are only used to build the
3643 InitializeContext();
3648 if (DeserializationListener)
3649 DeserializationListener->ReaderInitialized(this);
3651 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3652 if (PrimaryModule.OriginalSourceFileID.isValid()) {
3653 PrimaryModule.OriginalSourceFileID
3654 = FileID::get(PrimaryModule.SLocEntryBaseID
3655 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3657 // If this AST file is a precompiled preamble, then set the
3658 // preamble file ID of the source manager to the file source file
3659 // from which the preamble was built.
3660 if (Type == MK_Preamble) {
3661 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3662 } else if (Type == MK_MainFile) {
3663 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3667 // For any Objective-C class definitions we have already loaded, make sure
3668 // that we load any additional categories.
3669 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3670 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3671 ObjCClassesLoaded[I],
3672 PreviousGeneration);
3675 if (PP.getHeaderSearchInfo()
3676 .getHeaderSearchOpts()
3677 .ModulesValidateOncePerBuildSession) {
3678 // Now we are certain that the module and all modules it depends on are
3679 // up to date. Create or update timestamp files for modules that are
3680 // located in the module cache (not for PCH files that could be anywhere
3681 // in the filesystem).
3682 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3683 ImportedModule &M = Loaded[I];
3684 if (M.Mod->Kind == MK_ImplicitModule) {
3685 updateModuleTimestamp(*M.Mod);
3693 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
3695 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
3696 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
3697 return Stream.Read(8) == 'C' &&
3698 Stream.Read(8) == 'P' &&
3699 Stream.Read(8) == 'C' &&
3700 Stream.Read(8) == 'H';
3703 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
3707 case MK_ImplicitModule:
3708 case MK_ExplicitModule:
3712 return 2; // main source file
3714 llvm_unreachable("unknown module kind");
3717 ASTReader::ASTReadResult
3718 ASTReader::ReadASTCore(StringRef FileName,
3720 SourceLocation ImportLoc,
3721 ModuleFile *ImportedBy,
3722 SmallVectorImpl<ImportedModule> &Loaded,
3723 off_t ExpectedSize, time_t ExpectedModTime,
3724 ASTFileSignature ExpectedSignature,
3725 unsigned ClientLoadCapabilities) {
3727 std::string ErrorStr;
3728 ModuleManager::AddModuleResult AddResult
3729 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
3730 getGeneration(), ExpectedSize, ExpectedModTime,
3731 ExpectedSignature, readASTFileSignature,
3734 switch (AddResult) {
3735 case ModuleManager::AlreadyLoaded:
3738 case ModuleManager::NewlyLoaded:
3739 // Load module file below.
3742 case ModuleManager::Missing:
3743 // The module file was missing; if the client can handle that, return
3745 if (ClientLoadCapabilities & ARR_Missing)
3748 // Otherwise, return an error.
3749 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
3750 << FileName << ErrorStr.empty()
3754 case ModuleManager::OutOfDate:
3755 // We couldn't load the module file because it is out-of-date. If the
3756 // client can handle out-of-date, return it.
3757 if (ClientLoadCapabilities & ARR_OutOfDate)
3760 // Otherwise, return an error.
3761 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
3762 << FileName << ErrorStr.empty()
3767 assert(M && "Missing module file");
3769 // FIXME: This seems rather a hack. Should CurrentDir be part of the
3771 if (FileName != "-") {
3772 CurrentDir = llvm::sys::path::parent_path(FileName);
3773 if (CurrentDir.empty()) CurrentDir = ".";
3777 BitstreamCursor &Stream = F.Stream;
3778 PCHContainerRdr.ExtractPCH(F.Buffer->getMemBufferRef(), F.StreamFile);
3779 Stream.init(&F.StreamFile);
3780 F.SizeInBits = F.Buffer->getBufferSize() * 8;
3782 // Sniff for the signature.
3783 if (!startsWithASTFileMagic(Stream)) {
3784 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
3789 // This is used for compatibility with older PCH formats.
3790 bool HaveReadControlBlock = false;
3792 llvm::BitstreamEntry Entry = Stream.advance();
3794 switch (Entry.Kind) {
3795 case llvm::BitstreamEntry::Error:
3796 case llvm::BitstreamEntry::Record:
3797 case llvm::BitstreamEntry::EndBlock:
3798 Error("invalid record at top-level of AST file");
3801 case llvm::BitstreamEntry::SubBlock:
3806 case CONTROL_BLOCK_ID:
3807 HaveReadControlBlock = true;
3808 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
3810 // Check that we didn't try to load a non-module AST file as a module.
3812 // FIXME: Should we also perform the converse check? Loading a module as
3813 // a PCH file sort of works, but it's a bit wonky.
3814 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule) &&
3815 F.ModuleName.empty()) {
3816 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
3817 if (Result != OutOfDate ||
3818 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
3819 Diag(diag::err_module_file_not_module) << FileName;
3824 case Failure: return Failure;
3825 case Missing: return Missing;
3826 case OutOfDate: return OutOfDate;
3827 case VersionMismatch: return VersionMismatch;
3828 case ConfigurationMismatch: return ConfigurationMismatch;
3829 case HadErrors: return HadErrors;
3834 if (!HaveReadControlBlock) {
3835 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3836 Diag(diag::err_pch_version_too_old);
3837 return VersionMismatch;
3840 // Record that we've loaded this module.
3841 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3845 if (Stream.SkipBlock()) {
3846 Error("malformed block record in AST file");
3856 /// Parse a record and blob containing module file extension metadata.
3857 static bool parseModuleFileExtensionMetadata(
3858 const SmallVectorImpl<uint64_t> &Record,
3860 ModuleFileExtensionMetadata &Metadata) {
3861 if (Record.size() < 4) return true;
3863 Metadata.MajorVersion = Record[0];
3864 Metadata.MinorVersion = Record[1];
3866 unsigned BlockNameLen = Record[2];
3867 unsigned UserInfoLen = Record[3];
3869 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
3871 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
3872 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
3873 Blob.data() + BlockNameLen + UserInfoLen);
3877 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
3878 BitstreamCursor &Stream = F.Stream;
3882 llvm::BitstreamEntry Entry = Stream.advance();
3883 switch (Entry.Kind) {
3884 case llvm::BitstreamEntry::SubBlock:
3885 if (Stream.SkipBlock())
3890 case llvm::BitstreamEntry::EndBlock:
3893 case llvm::BitstreamEntry::Error:
3896 case llvm::BitstreamEntry::Record:
3902 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
3904 case EXTENSION_METADATA: {
3905 ModuleFileExtensionMetadata Metadata;
3906 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
3909 // Find a module file extension with this block name.
3910 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
3911 if (Known == ModuleFileExtensions.end()) break;
3914 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
3916 F.ExtensionReaders.push_back(std::move(Reader));
3927 void ASTReader::InitializeContext() {
3928 // If there's a listener, notify them that we "read" the translation unit.
3929 if (DeserializationListener)
3930 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3931 Context.getTranslationUnitDecl());
3933 // FIXME: Find a better way to deal with collisions between these
3934 // built-in types. Right now, we just ignore the problem.
3936 // Load the special types.
3937 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
3938 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3939 if (!Context.CFConstantStringTypeDecl)
3940 Context.setCFConstantStringType(GetType(String));
3943 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3944 QualType FileType = GetType(File);
3945 if (FileType.isNull()) {
3946 Error("FILE type is NULL");
3950 if (!Context.FILEDecl) {
3951 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3952 Context.setFILEDecl(Typedef->getDecl());
3954 const TagType *Tag = FileType->getAs<TagType>();
3956 Error("Invalid FILE type in AST file");
3959 Context.setFILEDecl(Tag->getDecl());
3964 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
3965 QualType Jmp_bufType = GetType(Jmp_buf);
3966 if (Jmp_bufType.isNull()) {
3967 Error("jmp_buf type is NULL");
3971 if (!Context.jmp_bufDecl) {
3972 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3973 Context.setjmp_bufDecl(Typedef->getDecl());
3975 const TagType *Tag = Jmp_bufType->getAs<TagType>();
3977 Error("Invalid jmp_buf type in AST file");
3980 Context.setjmp_bufDecl(Tag->getDecl());
3985 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
3986 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3987 if (Sigjmp_bufType.isNull()) {
3988 Error("sigjmp_buf type is NULL");
3992 if (!Context.sigjmp_bufDecl) {
3993 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3994 Context.setsigjmp_bufDecl(Typedef->getDecl());
3996 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3997 assert(Tag && "Invalid sigjmp_buf type in AST file");
3998 Context.setsigjmp_bufDecl(Tag->getDecl());
4003 if (unsigned ObjCIdRedef
4004 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4005 if (Context.ObjCIdRedefinitionType.isNull())
4006 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4009 if (unsigned ObjCClassRedef
4010 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4011 if (Context.ObjCClassRedefinitionType.isNull())
4012 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4015 if (unsigned ObjCSelRedef
4016 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4017 if (Context.ObjCSelRedefinitionType.isNull())
4018 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4021 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4022 QualType Ucontext_tType = GetType(Ucontext_t);
4023 if (Ucontext_tType.isNull()) {
4024 Error("ucontext_t type is NULL");
4028 if (!Context.ucontext_tDecl) {
4029 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4030 Context.setucontext_tDecl(Typedef->getDecl());
4032 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4033 assert(Tag && "Invalid ucontext_t type in AST file");
4034 Context.setucontext_tDecl(Tag->getDecl());
4040 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4042 // If there were any CUDA special declarations, deserialize them.
4043 if (!CUDASpecialDeclRefs.empty()) {
4044 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4045 Context.setcudaConfigureCallDecl(
4046 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4049 // Re-export any modules that were imported by a non-module AST file.
4050 // FIXME: This does not make macro-only imports visible again.
4051 for (auto &Import : ImportedModules) {
4052 if (Module *Imported = getSubmodule(Import.ID)) {
4053 makeModuleVisible(Imported, Module::AllVisible,
4054 /*ImportLoc=*/Import.ImportLoc);
4055 PP.makeModuleVisible(Imported, Import.ImportLoc);
4058 ImportedModules.clear();
4061 void ASTReader::finalizeForWriting() {
4062 // Nothing to do for now.
4065 /// \brief Reads and return the signature record from \p StreamFile's control
4066 /// block, or else returns 0.
4067 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){
4068 BitstreamCursor Stream(StreamFile);
4069 if (!startsWithASTFileMagic(Stream))
4072 // Scan for the CONTROL_BLOCK_ID block.
4073 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4076 // Scan for SIGNATURE inside the control block.
4077 ASTReader::RecordData Record;
4079 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4080 if (Entry.Kind == llvm::BitstreamEntry::EndBlock ||
4081 Entry.Kind != llvm::BitstreamEntry::Record)
4086 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4091 /// \brief Retrieve the name of the original source file name
4092 /// directly from the AST file, without actually loading the AST
4094 std::string ASTReader::getOriginalSourceFile(
4095 const std::string &ASTFileName, FileManager &FileMgr,
4096 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4097 // Open the AST file.
4098 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4100 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4101 << ASTFileName << Buffer.getError().message();
4102 return std::string();
4105 // Initialize the stream
4106 llvm::BitstreamReader StreamFile;
4107 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
4108 BitstreamCursor Stream(StreamFile);
4110 // Sniff for the signature.
4111 if (!startsWithASTFileMagic(Stream)) {
4112 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4113 return std::string();
4116 // Scan for the CONTROL_BLOCK_ID block.
4117 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4118 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4119 return std::string();
4122 // Scan for ORIGINAL_FILE inside the control block.
4125 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4126 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4127 return std::string();
4129 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4130 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4131 return std::string();
4136 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4142 class SimplePCHValidator : public ASTReaderListener {
4143 const LangOptions &ExistingLangOpts;
4144 const TargetOptions &ExistingTargetOpts;
4145 const PreprocessorOptions &ExistingPPOpts;
4146 std::string ExistingModuleCachePath;
4147 FileManager &FileMgr;
4150 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4151 const TargetOptions &ExistingTargetOpts,
4152 const PreprocessorOptions &ExistingPPOpts,
4153 StringRef ExistingModuleCachePath,
4154 FileManager &FileMgr)
4155 : ExistingLangOpts(ExistingLangOpts),
4156 ExistingTargetOpts(ExistingTargetOpts),
4157 ExistingPPOpts(ExistingPPOpts),
4158 ExistingModuleCachePath(ExistingModuleCachePath),
4163 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4164 bool AllowCompatibleDifferences) override {
4165 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4166 AllowCompatibleDifferences);
4168 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4169 bool AllowCompatibleDifferences) override {
4170 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4171 AllowCompatibleDifferences);
4173 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4174 StringRef SpecificModuleCachePath,
4175 bool Complain) override {
4176 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4177 ExistingModuleCachePath,
4178 nullptr, ExistingLangOpts);
4180 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4182 std::string &SuggestedPredefines) override {
4183 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4184 SuggestedPredefines, ExistingLangOpts);
4189 bool ASTReader::readASTFileControlBlock(
4190 StringRef Filename, FileManager &FileMgr,
4191 const PCHContainerReader &PCHContainerRdr,
4192 bool FindModuleFileExtensions,
4193 ASTReaderListener &Listener) {
4194 // Open the AST file.
4195 // FIXME: This allows use of the VFS; we do not allow use of the
4196 // VFS when actually loading a module.
4197 auto Buffer = FileMgr.getBufferForFile(Filename);
4202 // Initialize the stream
4203 llvm::BitstreamReader StreamFile;
4204 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
4205 BitstreamCursor Stream(StreamFile);
4207 // Sniff for the signature.
4208 if (!startsWithASTFileMagic(Stream))
4211 // Scan for the CONTROL_BLOCK_ID block.
4212 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4215 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4216 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4217 bool NeedsImports = Listener.needsImportVisitation();
4218 BitstreamCursor InputFilesCursor;
4221 std::string ModuleDir;
4222 bool DoneWithControlBlock = false;
4223 while (!DoneWithControlBlock) {
4224 llvm::BitstreamEntry Entry = Stream.advance();
4226 switch (Entry.Kind) {
4227 case llvm::BitstreamEntry::SubBlock: {
4229 case OPTIONS_BLOCK_ID: {
4230 std::string IgnoredSuggestedPredefines;
4231 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4232 /*AllowCompatibleConfigurationMismatch*/ false,
4233 Listener, IgnoredSuggestedPredefines) != Success)
4238 case INPUT_FILES_BLOCK_ID:
4239 InputFilesCursor = Stream;
4240 if (Stream.SkipBlock() ||
4242 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4247 if (Stream.SkipBlock())
4255 case llvm::BitstreamEntry::EndBlock:
4256 DoneWithControlBlock = true;
4259 case llvm::BitstreamEntry::Error:
4262 case llvm::BitstreamEntry::Record:
4266 if (DoneWithControlBlock) break;
4270 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4271 switch ((ControlRecordTypes)RecCode) {
4273 if (Record[0] != VERSION_MAJOR)
4276 if (Listener.ReadFullVersionInformation(Blob))
4282 Listener.ReadModuleName(Blob);
4284 case MODULE_DIRECTORY:
4287 case MODULE_MAP_FILE: {
4289 auto Path = ReadString(Record, Idx);
4290 ResolveImportedPath(Path, ModuleDir);
4291 Listener.ReadModuleMapFile(Path);
4294 case INPUT_FILE_OFFSETS: {
4295 if (!NeedsInputFiles)
4298 unsigned NumInputFiles = Record[0];
4299 unsigned NumUserFiles = Record[1];
4300 const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
4301 for (unsigned I = 0; I != NumInputFiles; ++I) {
4302 // Go find this input file.
4303 bool isSystemFile = I >= NumUserFiles;
4305 if (isSystemFile && !NeedsSystemInputFiles)
4306 break; // the rest are system input files
4308 BitstreamCursor &Cursor = InputFilesCursor;
4309 SavedStreamPosition SavedPosition(Cursor);
4310 Cursor.JumpToBit(InputFileOffs[I]);
4312 unsigned Code = Cursor.ReadCode();
4315 bool shouldContinue = false;
4316 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4318 bool Overridden = static_cast<bool>(Record[3]);
4319 std::string Filename = Blob;
4320 ResolveImportedPath(Filename, ModuleDir);
4321 shouldContinue = Listener.visitInputFile(
4322 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4325 if (!shouldContinue)
4335 unsigned Idx = 0, N = Record.size();
4337 // Read information about the AST file.
4338 Idx += 5; // ImportLoc, Size, ModTime, Signature
4339 std::string Filename = ReadString(Record, Idx);
4340 ResolveImportedPath(Filename, ModuleDir);
4341 Listener.visitImport(Filename);
4347 // No other validation to perform.
4352 // Look for module file extension blocks, if requested.
4353 if (FindModuleFileExtensions) {
4354 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4355 bool DoneWithExtensionBlock = false;
4356 while (!DoneWithExtensionBlock) {
4357 llvm::BitstreamEntry Entry = Stream.advance();
4359 switch (Entry.Kind) {
4360 case llvm::BitstreamEntry::SubBlock:
4361 if (Stream.SkipBlock())
4366 case llvm::BitstreamEntry::EndBlock:
4367 DoneWithExtensionBlock = true;
4370 case llvm::BitstreamEntry::Error:
4373 case llvm::BitstreamEntry::Record:
4379 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4381 case EXTENSION_METADATA: {
4382 ModuleFileExtensionMetadata Metadata;
4383 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4386 Listener.readModuleFileExtension(Metadata);
4397 bool ASTReader::isAcceptableASTFile(
4398 StringRef Filename, FileManager &FileMgr,
4399 const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts,
4400 const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts,
4401 std::string ExistingModuleCachePath) {
4402 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4403 ExistingModuleCachePath, FileMgr);
4404 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4405 /*FindModuleFileExtensions=*/false,
4409 ASTReader::ASTReadResult
4410 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4411 // Enter the submodule block.
4412 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4413 Error("malformed submodule block record in AST file");
4417 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4419 Module *CurrentModule = nullptr;
4422 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4424 switch (Entry.Kind) {
4425 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4426 case llvm::BitstreamEntry::Error:
4427 Error("malformed block record in AST file");
4429 case llvm::BitstreamEntry::EndBlock:
4431 case llvm::BitstreamEntry::Record:
4432 // The interesting case.
4439 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4441 if ((Kind == SUBMODULE_METADATA) != First) {
4442 Error("submodule metadata record should be at beginning of block");
4447 // Submodule information is only valid if we have a current module.
4448 // FIXME: Should we error on these cases?
4449 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4450 Kind != SUBMODULE_DEFINITION)
4454 default: // Default behavior: ignore.
4457 case SUBMODULE_DEFINITION: {
4458 if (Record.size() < 8) {
4459 Error("malformed module definition");
4463 StringRef Name = Blob;
4465 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4466 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4467 bool IsFramework = Record[Idx++];
4468 bool IsExplicit = Record[Idx++];
4469 bool IsSystem = Record[Idx++];
4470 bool IsExternC = Record[Idx++];
4471 bool InferSubmodules = Record[Idx++];
4472 bool InferExplicitSubmodules = Record[Idx++];
4473 bool InferExportWildcard = Record[Idx++];
4474 bool ConfigMacrosExhaustive = Record[Idx++];
4476 Module *ParentModule = nullptr;
4478 ParentModule = getSubmodule(Parent);
4480 // Retrieve this (sub)module from the module map, creating it if
4482 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
4485 // FIXME: set the definition loc for CurrentModule, or call
4486 // ModMap.setInferredModuleAllowedBy()
4488 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4489 if (GlobalIndex >= SubmodulesLoaded.size() ||
4490 SubmodulesLoaded[GlobalIndex]) {
4491 Error("too many submodules");
4495 if (!ParentModule) {
4496 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4497 if (CurFile != F.File) {
4498 if (!Diags.isDiagnosticInFlight()) {
4499 Diag(diag::err_module_file_conflict)
4500 << CurrentModule->getTopLevelModuleName()
4501 << CurFile->getName()
4502 << F.File->getName();
4508 CurrentModule->setASTFile(F.File);
4511 CurrentModule->Signature = F.Signature;
4512 CurrentModule->IsFromModuleFile = true;
4513 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4514 CurrentModule->IsExternC = IsExternC;
4515 CurrentModule->InferSubmodules = InferSubmodules;
4516 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4517 CurrentModule->InferExportWildcard = InferExportWildcard;
4518 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4519 if (DeserializationListener)
4520 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4522 SubmodulesLoaded[GlobalIndex] = CurrentModule;
4524 // Clear out data that will be replaced by what is the module file.
4525 CurrentModule->LinkLibraries.clear();
4526 CurrentModule->ConfigMacros.clear();
4527 CurrentModule->UnresolvedConflicts.clear();
4528 CurrentModule->Conflicts.clear();
4532 case SUBMODULE_UMBRELLA_HEADER: {
4533 std::string Filename = Blob;
4534 ResolveImportedPath(F, Filename);
4535 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
4536 if (!CurrentModule->getUmbrellaHeader())
4537 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
4538 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
4539 // This can be a spurious difference caused by changing the VFS to
4540 // point to a different copy of the file, and it is too late to
4541 // to rebuild safely.
4542 // FIXME: If we wrote the virtual paths instead of the 'real' paths,
4543 // after input file validation only real problems would remain and we
4544 // could just error. For now, assume it's okay.
4551 case SUBMODULE_HEADER:
4552 case SUBMODULE_EXCLUDED_HEADER:
4553 case SUBMODULE_PRIVATE_HEADER:
4554 // We lazily associate headers with their modules via the HeaderInfo table.
4555 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4556 // of complete filenames or remove it entirely.
4559 case SUBMODULE_TEXTUAL_HEADER:
4560 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
4561 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
4565 case SUBMODULE_TOPHEADER: {
4566 CurrentModule->addTopHeaderFilename(Blob);
4570 case SUBMODULE_UMBRELLA_DIR: {
4571 std::string Dirname = Blob;
4572 ResolveImportedPath(F, Dirname);
4573 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
4574 if (!CurrentModule->getUmbrellaDir())
4575 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
4576 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
4577 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4578 Error("mismatched umbrella directories in submodule");
4585 case SUBMODULE_METADATA: {
4586 F.BaseSubmoduleID = getTotalNumSubmodules();
4587 F.LocalNumSubmodules = Record[0];
4588 unsigned LocalBaseSubmoduleID = Record[1];
4589 if (F.LocalNumSubmodules > 0) {
4590 // Introduce the global -> local mapping for submodules within this
4592 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4594 // Introduce the local -> global mapping for submodules within this
4596 F.SubmoduleRemap.insertOrReplace(
4597 std::make_pair(LocalBaseSubmoduleID,
4598 F.BaseSubmoduleID - LocalBaseSubmoduleID));
4600 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
4605 case SUBMODULE_IMPORTS: {
4606 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
4607 UnresolvedModuleRef Unresolved;
4608 Unresolved.File = &F;
4609 Unresolved.Mod = CurrentModule;
4610 Unresolved.ID = Record[Idx];
4611 Unresolved.Kind = UnresolvedModuleRef::Import;
4612 Unresolved.IsWildcard = false;
4613 UnresolvedModuleRefs.push_back(Unresolved);
4618 case SUBMODULE_EXPORTS: {
4619 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
4620 UnresolvedModuleRef Unresolved;
4621 Unresolved.File = &F;
4622 Unresolved.Mod = CurrentModule;
4623 Unresolved.ID = Record[Idx];
4624 Unresolved.Kind = UnresolvedModuleRef::Export;
4625 Unresolved.IsWildcard = Record[Idx + 1];
4626 UnresolvedModuleRefs.push_back(Unresolved);
4629 // Once we've loaded the set of exports, there's no reason to keep
4630 // the parsed, unresolved exports around.
4631 CurrentModule->UnresolvedExports.clear();
4634 case SUBMODULE_REQUIRES: {
4635 CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
4636 Context.getTargetInfo());
4640 case SUBMODULE_LINK_LIBRARY:
4641 CurrentModule->LinkLibraries.push_back(
4642 Module::LinkLibrary(Blob, Record[0]));
4645 case SUBMODULE_CONFIG_MACRO:
4646 CurrentModule->ConfigMacros.push_back(Blob.str());
4649 case SUBMODULE_CONFLICT: {
4650 UnresolvedModuleRef Unresolved;
4651 Unresolved.File = &F;
4652 Unresolved.Mod = CurrentModule;
4653 Unresolved.ID = Record[0];
4654 Unresolved.Kind = UnresolvedModuleRef::Conflict;
4655 Unresolved.IsWildcard = false;
4656 Unresolved.String = Blob;
4657 UnresolvedModuleRefs.push_back(Unresolved);
4664 /// \brief Parse the record that corresponds to a LangOptions data
4667 /// This routine parses the language options from the AST file and then gives
4668 /// them to the AST listener if one is set.
4670 /// \returns true if the listener deems the file unacceptable, false otherwise.
4671 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4673 ASTReaderListener &Listener,
4674 bool AllowCompatibleDifferences) {
4675 LangOptions LangOpts;
4677 #define LANGOPT(Name, Bits, Default, Description) \
4678 LangOpts.Name = Record[Idx++];
4679 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4680 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4681 #include "clang/Basic/LangOptions.def"
4682 #define SANITIZER(NAME, ID) \
4683 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
4684 #include "clang/Basic/Sanitizers.def"
4686 for (unsigned N = Record[Idx++]; N; --N)
4687 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
4689 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4690 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4691 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
4693 LangOpts.CurrentModule = ReadString(Record, Idx);
4696 for (unsigned N = Record[Idx++]; N; --N) {
4697 LangOpts.CommentOpts.BlockCommandNames.push_back(
4698 ReadString(Record, Idx));
4700 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
4702 // OpenMP offloading options.
4703 for (unsigned N = Record[Idx++]; N; --N) {
4704 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
4707 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
4709 return Listener.ReadLanguageOptions(LangOpts, Complain,
4710 AllowCompatibleDifferences);
4713 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
4714 ASTReaderListener &Listener,
4715 bool AllowCompatibleDifferences) {
4717 TargetOptions TargetOpts;
4718 TargetOpts.Triple = ReadString(Record, Idx);
4719 TargetOpts.CPU = ReadString(Record, Idx);
4720 TargetOpts.ABI = ReadString(Record, Idx);
4721 for (unsigned N = Record[Idx++]; N; --N) {
4722 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4724 for (unsigned N = Record[Idx++]; N; --N) {
4725 TargetOpts.Features.push_back(ReadString(Record, Idx));
4728 return Listener.ReadTargetOptions(TargetOpts, Complain,
4729 AllowCompatibleDifferences);
4732 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4733 ASTReaderListener &Listener) {
4734 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
4736 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
4737 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4738 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
4739 #include "clang/Basic/DiagnosticOptions.def"
4741 for (unsigned N = Record[Idx++]; N; --N)
4742 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
4743 for (unsigned N = Record[Idx++]; N; --N)
4744 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
4746 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4749 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4750 ASTReaderListener &Listener) {
4751 FileSystemOptions FSOpts;
4753 FSOpts.WorkingDir = ReadString(Record, Idx);
4754 return Listener.ReadFileSystemOptions(FSOpts, Complain);
4757 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4759 ASTReaderListener &Listener) {
4760 HeaderSearchOptions HSOpts;
4762 HSOpts.Sysroot = ReadString(Record, Idx);
4765 for (unsigned N = Record[Idx++]; N; --N) {
4766 std::string Path = ReadString(Record, Idx);
4767 frontend::IncludeDirGroup Group
4768 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
4769 bool IsFramework = Record[Idx++];
4770 bool IgnoreSysRoot = Record[Idx++];
4771 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
4775 // System header prefixes.
4776 for (unsigned N = Record[Idx++]; N; --N) {
4777 std::string Prefix = ReadString(Record, Idx);
4778 bool IsSystemHeader = Record[Idx++];
4779 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
4782 HSOpts.ResourceDir = ReadString(Record, Idx);
4783 HSOpts.ModuleCachePath = ReadString(Record, Idx);
4784 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
4785 HSOpts.DisableModuleHash = Record[Idx++];
4786 HSOpts.UseBuiltinIncludes = Record[Idx++];
4787 HSOpts.UseStandardSystemIncludes = Record[Idx++];
4788 HSOpts.UseStandardCXXIncludes = Record[Idx++];
4789 HSOpts.UseLibcxx = Record[Idx++];
4790 std::string SpecificModuleCachePath = ReadString(Record, Idx);
4792 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4796 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4798 ASTReaderListener &Listener,
4799 std::string &SuggestedPredefines) {
4800 PreprocessorOptions PPOpts;
4803 // Macro definitions/undefs
4804 for (unsigned N = Record[Idx++]; N; --N) {
4805 std::string Macro = ReadString(Record, Idx);
4806 bool IsUndef = Record[Idx++];
4807 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4811 for (unsigned N = Record[Idx++]; N; --N) {
4812 PPOpts.Includes.push_back(ReadString(Record, Idx));
4816 for (unsigned N = Record[Idx++]; N; --N) {
4817 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4820 PPOpts.UsePredefines = Record[Idx++];
4821 PPOpts.DetailedRecord = Record[Idx++];
4822 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4823 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4824 PPOpts.ObjCXXARCStandardLibrary =
4825 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4826 SuggestedPredefines.clear();
4827 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4828 SuggestedPredefines);
4831 std::pair<ModuleFile *, unsigned>
4832 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4833 GlobalPreprocessedEntityMapType::iterator
4834 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4835 assert(I != GlobalPreprocessedEntityMap.end() &&
4836 "Corrupted global preprocessed entity map");
4837 ModuleFile *M = I->second;
4838 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4839 return std::make_pair(M, LocalIndex);
4842 llvm::iterator_range<PreprocessingRecord::iterator>
4843 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4844 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4845 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4846 Mod.NumPreprocessedEntities);
4848 return llvm::make_range(PreprocessingRecord::iterator(),
4849 PreprocessingRecord::iterator());
4852 llvm::iterator_range<ASTReader::ModuleDeclIterator>
4853 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
4854 return llvm::make_range(
4855 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4856 ModuleDeclIterator(this, &Mod,
4857 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
4860 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4861 PreprocessedEntityID PPID = Index+1;
4862 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4863 ModuleFile &M = *PPInfo.first;
4864 unsigned LocalIndex = PPInfo.second;
4865 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4867 if (!PP.getPreprocessingRecord()) {
4868 Error("no preprocessing record");
4872 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
4873 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
4875 llvm::BitstreamEntry Entry =
4876 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
4877 if (Entry.Kind != llvm::BitstreamEntry::Record)
4881 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
4882 ReadSourceLocation(M, PPOffs.End));
4883 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
4886 PreprocessorDetailRecordTypes RecType =
4887 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
4888 Entry.ID, Record, &Blob);
4890 case PPD_MACRO_EXPANSION: {
4891 bool isBuiltin = Record[0];
4892 IdentifierInfo *Name = nullptr;
4893 MacroDefinitionRecord *Def = nullptr;
4895 Name = getLocalIdentifier(M, Record[1]);
4897 PreprocessedEntityID GlobalID =
4898 getGlobalPreprocessedEntityID(M, Record[1]);
4899 Def = cast<MacroDefinitionRecord>(
4900 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
4905 ME = new (PPRec) MacroExpansion(Name, Range);
4907 ME = new (PPRec) MacroExpansion(Def, Range);
4912 case PPD_MACRO_DEFINITION: {
4913 // Decode the identifier info and then check again; if the macro is
4914 // still defined and associated with the identifier,
4915 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
4916 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
4918 if (DeserializationListener)
4919 DeserializationListener->MacroDefinitionRead(PPID, MD);
4924 case PPD_INCLUSION_DIRECTIVE: {
4925 const char *FullFileNameStart = Blob.data() + Record[0];
4926 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
4927 const FileEntry *File = nullptr;
4928 if (!FullFileName.empty())
4929 File = PP.getFileManager().getFile(FullFileName);
4931 // FIXME: Stable encoding
4932 InclusionDirective::InclusionKind Kind
4933 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
4934 InclusionDirective *ID
4935 = new (PPRec) InclusionDirective(PPRec, Kind,
4936 StringRef(Blob.data(), Record[0]),
4937 Record[1], Record[3],
4944 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
4947 /// \brief \arg SLocMapI points at a chunk of a module that contains no
4948 /// preprocessed entities or the entities it contains are not the ones we are
4949 /// looking for. Find the next module that contains entities and return the ID
4950 /// of the first entry.
4951 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
4952 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4954 for (GlobalSLocOffsetMapType::const_iterator
4955 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4956 ModuleFile &M = *SLocMapI->second;
4957 if (M.NumPreprocessedEntities)
4958 return M.BasePreprocessedEntityID;
4961 return getTotalNumPreprocessedEntities();
4966 template <unsigned PPEntityOffset::*PPLoc>
4967 struct PPEntityComp {
4968 const ASTReader &Reader;
4971 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4973 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4974 SourceLocation LHS = getLoc(L);
4975 SourceLocation RHS = getLoc(R);
4976 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4979 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4980 SourceLocation LHS = getLoc(L);
4981 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4984 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
4985 SourceLocation RHS = getLoc(R);
4986 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4989 SourceLocation getLoc(const PPEntityOffset &PPE) const {
4990 return Reader.ReadSourceLocation(M, PPE.*PPLoc);
4996 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
4997 bool EndsAfter) const {
4998 if (SourceMgr.isLocalSourceLocation(Loc))
4999 return getTotalNumPreprocessedEntities();
5001 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5002 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5003 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5004 "Corrupted global sloc offset map");
5006 if (SLocMapI->second->NumPreprocessedEntities == 0)
5007 return findNextPreprocessedEntity(SLocMapI);
5009 ModuleFile &M = *SLocMapI->second;
5010 typedef const PPEntityOffset *pp_iterator;
5011 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5012 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5014 size_t Count = M.NumPreprocessedEntities;
5016 pp_iterator First = pp_begin;
5020 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5021 PPEntityComp<&PPEntityOffset::Begin>(*this, M));
5023 // Do a binary search manually instead of using std::lower_bound because
5024 // The end locations of entities may be unordered (when a macro expansion
5025 // is inside another macro argument), but for this case it is not important
5026 // whether we get the first macro expansion or its containing macro.
5030 std::advance(PPI, Half);
5031 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
5035 Count = Count - Half - 1;
5042 return findNextPreprocessedEntity(SLocMapI);
5044 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5047 /// \brief Returns a pair of [Begin, End) indices of preallocated
5048 /// preprocessed entities that \arg Range encompasses.
5049 std::pair<unsigned, unsigned>
5050 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5051 if (Range.isInvalid())
5052 return std::make_pair(0,0);
5053 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5055 PreprocessedEntityID BeginID =
5056 findPreprocessedEntity(Range.getBegin(), false);
5057 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5058 return std::make_pair(BeginID, EndID);
5061 /// \brief Optionally returns true or false if the preallocated preprocessed
5062 /// entity with index \arg Index came from file \arg FID.
5063 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5065 if (FID.isInvalid())
5068 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5069 ModuleFile &M = *PPInfo.first;
5070 unsigned LocalIndex = PPInfo.second;
5071 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5073 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
5074 if (Loc.isInvalid())
5077 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5084 /// \brief Visitor used to search for information about a header file.
5085 class HeaderFileInfoVisitor {
5086 const FileEntry *FE;
5088 Optional<HeaderFileInfo> HFI;
5091 explicit HeaderFileInfoVisitor(const FileEntry *FE)
5094 bool operator()(ModuleFile &M) {
5095 HeaderFileInfoLookupTable *Table
5096 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5100 // Look in the on-disk hash table for an entry for this file name.
5101 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5102 if (Pos == Table->end())
5109 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5113 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5114 HeaderFileInfoVisitor Visitor(FE);
5115 ModuleMgr.visit(Visitor);
5116 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5119 return HeaderFileInfo();
5122 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5123 // FIXME: Make it work properly with modules.
5124 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
5125 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5126 ModuleFile &F = *(*I);
5129 assert(!Diag.DiagStates.empty());
5130 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5131 while (Idx < F.PragmaDiagMappings.size()) {
5132 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5133 unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5134 if (DiagStateID != 0) {
5135 Diag.DiagStatePoints.push_back(
5136 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5137 FullSourceLoc(Loc, SourceMgr)));
5141 assert(DiagStateID == 0);
5142 // A new DiagState was created here.
5143 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5144 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5145 DiagStates.push_back(NewState);
5146 Diag.DiagStatePoints.push_back(
5147 DiagnosticsEngine::DiagStatePoint(NewState,
5148 FullSourceLoc(Loc, SourceMgr)));
5150 assert(Idx < F.PragmaDiagMappings.size() &&
5151 "Invalid data, didn't find '-1' marking end of diag/map pairs");
5152 if (Idx >= F.PragmaDiagMappings.size()) {
5153 break; // Something is messed up but at least avoid infinite loop in
5156 unsigned DiagID = F.PragmaDiagMappings[Idx++];
5157 if (DiagID == (unsigned)-1) {
5158 break; // no more diag/map pairs for this location.
5160 diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5161 DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5162 Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
5168 /// \brief Get the correct cursor and offset for loading a type.
5169 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5170 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5171 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5172 ModuleFile *M = I->second;
5173 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5176 /// \brief Read and return the type with the given index..
5178 /// The index is the type ID, shifted and minus the number of predefs. This
5179 /// routine actually reads the record corresponding to the type at the given
5180 /// location. It is a helper routine for GetType, which deals with reading type
5182 QualType ASTReader::readTypeRecord(unsigned Index) {
5183 RecordLocation Loc = TypeCursorForIndex(Index);
5184 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5186 // Keep track of where we are in the stream, then jump back there
5187 // after reading this type.
5188 SavedStreamPosition SavedPosition(DeclsCursor);
5190 ReadingKindTracker ReadingKind(Read_Type, *this);
5192 // Note that we are loading a type record.
5193 Deserializing AType(this);
5196 DeclsCursor.JumpToBit(Loc.Offset);
5198 unsigned Code = DeclsCursor.ReadCode();
5199 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5200 case TYPE_EXT_QUAL: {
5201 if (Record.size() != 2) {
5202 Error("Incorrect encoding of extended qualifier type");
5205 QualType Base = readType(*Loc.F, Record, Idx);
5206 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5207 return Context.getQualifiedType(Base, Quals);
5210 case TYPE_COMPLEX: {
5211 if (Record.size() != 1) {
5212 Error("Incorrect encoding of complex type");
5215 QualType ElemType = readType(*Loc.F, Record, Idx);
5216 return Context.getComplexType(ElemType);
5219 case TYPE_POINTER: {
5220 if (Record.size() != 1) {
5221 Error("Incorrect encoding of pointer type");
5224 QualType PointeeType = readType(*Loc.F, Record, Idx);
5225 return Context.getPointerType(PointeeType);
5228 case TYPE_DECAYED: {
5229 if (Record.size() != 1) {
5230 Error("Incorrect encoding of decayed type");
5233 QualType OriginalType = readType(*Loc.F, Record, Idx);
5234 QualType DT = Context.getAdjustedParameterType(OriginalType);
5235 if (!isa<DecayedType>(DT))
5236 Error("Decayed type does not decay");
5240 case TYPE_ADJUSTED: {
5241 if (Record.size() != 2) {
5242 Error("Incorrect encoding of adjusted type");
5245 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5246 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5247 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5250 case TYPE_BLOCK_POINTER: {
5251 if (Record.size() != 1) {
5252 Error("Incorrect encoding of block pointer type");
5255 QualType PointeeType = readType(*Loc.F, Record, Idx);
5256 return Context.getBlockPointerType(PointeeType);
5259 case TYPE_LVALUE_REFERENCE: {
5260 if (Record.size() != 2) {
5261 Error("Incorrect encoding of lvalue reference type");
5264 QualType PointeeType = readType(*Loc.F, Record, Idx);
5265 return Context.getLValueReferenceType(PointeeType, Record[1]);
5268 case TYPE_RVALUE_REFERENCE: {
5269 if (Record.size() != 1) {
5270 Error("Incorrect encoding of rvalue reference type");
5273 QualType PointeeType = readType(*Loc.F, Record, Idx);
5274 return Context.getRValueReferenceType(PointeeType);
5277 case TYPE_MEMBER_POINTER: {
5278 if (Record.size() != 2) {
5279 Error("Incorrect encoding of member pointer type");
5282 QualType PointeeType = readType(*Loc.F, Record, Idx);
5283 QualType ClassType = readType(*Loc.F, Record, Idx);
5284 if (PointeeType.isNull() || ClassType.isNull())
5287 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5290 case TYPE_CONSTANT_ARRAY: {
5291 QualType ElementType = readType(*Loc.F, Record, Idx);
5292 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5293 unsigned IndexTypeQuals = Record[2];
5295 llvm::APInt Size = ReadAPInt(Record, Idx);
5296 return Context.getConstantArrayType(ElementType, Size,
5297 ASM, IndexTypeQuals);
5300 case TYPE_INCOMPLETE_ARRAY: {
5301 QualType ElementType = readType(*Loc.F, Record, Idx);
5302 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5303 unsigned IndexTypeQuals = Record[2];
5304 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5307 case TYPE_VARIABLE_ARRAY: {
5308 QualType ElementType = readType(*Loc.F, Record, Idx);
5309 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5310 unsigned IndexTypeQuals = Record[2];
5311 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5312 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5313 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5314 ASM, IndexTypeQuals,
5315 SourceRange(LBLoc, RBLoc));
5319 if (Record.size() != 3) {
5320 Error("incorrect encoding of vector type in AST file");
5324 QualType ElementType = readType(*Loc.F, Record, Idx);
5325 unsigned NumElements = Record[1];
5326 unsigned VecKind = Record[2];
5327 return Context.getVectorType(ElementType, NumElements,
5328 (VectorType::VectorKind)VecKind);
5331 case TYPE_EXT_VECTOR: {
5332 if (Record.size() != 3) {
5333 Error("incorrect encoding of extended vector type in AST file");
5337 QualType ElementType = readType(*Loc.F, Record, Idx);
5338 unsigned NumElements = Record[1];
5339 return Context.getExtVectorType(ElementType, NumElements);
5342 case TYPE_FUNCTION_NO_PROTO: {
5343 if (Record.size() != 6) {
5344 Error("incorrect encoding of no-proto function type");
5347 QualType ResultType = readType(*Loc.F, Record, Idx);
5348 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5349 (CallingConv)Record[4], Record[5]);
5350 return Context.getFunctionNoProtoType(ResultType, Info);
5353 case TYPE_FUNCTION_PROTO: {
5354 QualType ResultType = readType(*Loc.F, Record, Idx);
5356 FunctionProtoType::ExtProtoInfo EPI;
5357 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5358 /*hasregparm*/ Record[2],
5359 /*regparm*/ Record[3],
5360 static_cast<CallingConv>(Record[4]),
5361 /*produces*/ Record[5]);
5365 EPI.Variadic = Record[Idx++];
5366 EPI.HasTrailingReturn = Record[Idx++];
5367 EPI.TypeQuals = Record[Idx++];
5368 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5369 SmallVector<QualType, 8> ExceptionStorage;
5370 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5372 unsigned NumParams = Record[Idx++];
5373 SmallVector<QualType, 16> ParamTypes;
5374 for (unsigned I = 0; I != NumParams; ++I)
5375 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5377 return Context.getFunctionType(ResultType, ParamTypes, EPI);
5380 case TYPE_UNRESOLVED_USING: {
5382 return Context.getTypeDeclType(
5383 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5386 case TYPE_TYPEDEF: {
5387 if (Record.size() != 2) {
5388 Error("incorrect encoding of typedef type");
5392 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5393 QualType Canonical = readType(*Loc.F, Record, Idx);
5394 if (!Canonical.isNull())
5395 Canonical = Context.getCanonicalType(Canonical);
5396 return Context.getTypedefType(Decl, Canonical);
5399 case TYPE_TYPEOF_EXPR:
5400 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5403 if (Record.size() != 1) {
5404 Error("incorrect encoding of typeof(type) in AST file");
5407 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5408 return Context.getTypeOfType(UnderlyingType);
5411 case TYPE_DECLTYPE: {
5412 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5413 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5416 case TYPE_UNARY_TRANSFORM: {
5417 QualType BaseType = readType(*Loc.F, Record, Idx);
5418 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5419 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5420 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5424 QualType Deduced = readType(*Loc.F, Record, Idx);
5425 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
5426 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5427 return Context.getAutoType(Deduced, Keyword, IsDependent);
5431 if (Record.size() != 2) {
5432 Error("incorrect encoding of record type");
5436 bool IsDependent = Record[Idx++];
5437 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5438 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5439 QualType T = Context.getRecordType(RD);
5440 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5445 if (Record.size() != 2) {
5446 Error("incorrect encoding of enum type");
5450 bool IsDependent = Record[Idx++];
5452 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5453 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5457 case TYPE_ATTRIBUTED: {
5458 if (Record.size() != 3) {
5459 Error("incorrect encoding of attributed type");
5462 QualType modifiedType = readType(*Loc.F, Record, Idx);
5463 QualType equivalentType = readType(*Loc.F, Record, Idx);
5464 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5465 return Context.getAttributedType(kind, modifiedType, equivalentType);
5469 if (Record.size() != 1) {
5470 Error("incorrect encoding of paren type");
5473 QualType InnerType = readType(*Loc.F, Record, Idx);
5474 return Context.getParenType(InnerType);
5477 case TYPE_PACK_EXPANSION: {
5478 if (Record.size() != 2) {
5479 Error("incorrect encoding of pack expansion type");
5482 QualType Pattern = readType(*Loc.F, Record, Idx);
5483 if (Pattern.isNull())
5485 Optional<unsigned> NumExpansions;
5487 NumExpansions = Record[1] - 1;
5488 return Context.getPackExpansionType(Pattern, NumExpansions);
5491 case TYPE_ELABORATED: {
5493 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5494 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5495 QualType NamedType = readType(*Loc.F, Record, Idx);
5496 return Context.getElaboratedType(Keyword, NNS, NamedType);
5499 case TYPE_OBJC_INTERFACE: {
5501 ObjCInterfaceDecl *ItfD
5502 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5503 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5506 case TYPE_OBJC_OBJECT: {
5508 QualType Base = readType(*Loc.F, Record, Idx);
5509 unsigned NumTypeArgs = Record[Idx++];
5510 SmallVector<QualType, 4> TypeArgs;
5511 for (unsigned I = 0; I != NumTypeArgs; ++I)
5512 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
5513 unsigned NumProtos = Record[Idx++];
5514 SmallVector<ObjCProtocolDecl*, 4> Protos;
5515 for (unsigned I = 0; I != NumProtos; ++I)
5516 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5517 bool IsKindOf = Record[Idx++];
5518 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
5521 case TYPE_OBJC_OBJECT_POINTER: {
5523 QualType Pointee = readType(*Loc.F, Record, Idx);
5524 return Context.getObjCObjectPointerType(Pointee);
5527 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5529 QualType Parm = readType(*Loc.F, Record, Idx);
5530 QualType Replacement = readType(*Loc.F, Record, Idx);
5531 return Context.getSubstTemplateTypeParmType(
5532 cast<TemplateTypeParmType>(Parm),
5533 Context.getCanonicalType(Replacement));
5536 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5538 QualType Parm = readType(*Loc.F, Record, Idx);
5539 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5540 return Context.getSubstTemplateTypeParmPackType(
5541 cast<TemplateTypeParmType>(Parm),
5545 case TYPE_INJECTED_CLASS_NAME: {
5546 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5547 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5548 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5549 // for AST reading, too much interdependencies.
5550 const Type *T = nullptr;
5551 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
5552 if (const Type *Existing = DI->getTypeForDecl()) {
5558 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
5559 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
5560 DI->setTypeForDecl(T);
5562 return QualType(T, 0);
5565 case TYPE_TEMPLATE_TYPE_PARM: {
5567 unsigned Depth = Record[Idx++];
5568 unsigned Index = Record[Idx++];
5569 bool Pack = Record[Idx++];
5570 TemplateTypeParmDecl *D
5571 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5572 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5575 case TYPE_DEPENDENT_NAME: {
5577 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5578 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5579 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5580 QualType Canon = readType(*Loc.F, Record, Idx);
5581 if (!Canon.isNull())
5582 Canon = Context.getCanonicalType(Canon);
5583 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5586 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5588 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5589 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5590 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5591 unsigned NumArgs = Record[Idx++];
5592 SmallVector<TemplateArgument, 8> Args;
5593 Args.reserve(NumArgs);
5595 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5596 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5597 Args.size(), Args.data());
5600 case TYPE_DEPENDENT_SIZED_ARRAY: {
5604 QualType ElementType = readType(*Loc.F, Record, Idx);
5605 ArrayType::ArraySizeModifier ASM
5606 = (ArrayType::ArraySizeModifier)Record[Idx++];
5607 unsigned IndexTypeQuals = Record[Idx++];
5609 // DependentSizedArrayType
5610 Expr *NumElts = ReadExpr(*Loc.F);
5611 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5613 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5614 IndexTypeQuals, Brackets);
5617 case TYPE_TEMPLATE_SPECIALIZATION: {
5619 bool IsDependent = Record[Idx++];
5620 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5621 SmallVector<TemplateArgument, 8> Args;
5622 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5623 QualType Underlying = readType(*Loc.F, Record, Idx);
5625 if (Underlying.isNull())
5626 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
5629 T = Context.getTemplateSpecializationType(Name, Args.data(),
5630 Args.size(), Underlying);
5631 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5636 if (Record.size() != 1) {
5637 Error("Incorrect encoding of atomic type");
5640 QualType ValueType = readType(*Loc.F, Record, Idx);
5641 return Context.getAtomicType(ValueType);
5644 llvm_unreachable("Invalid TypeCode!");
5647 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5648 SmallVectorImpl<QualType> &Exceptions,
5649 FunctionProtoType::ExceptionSpecInfo &ESI,
5650 const RecordData &Record, unsigned &Idx) {
5651 ExceptionSpecificationType EST =
5652 static_cast<ExceptionSpecificationType>(Record[Idx++]);
5654 if (EST == EST_Dynamic) {
5655 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
5656 Exceptions.push_back(readType(ModuleFile, Record, Idx));
5657 ESI.Exceptions = Exceptions;
5658 } else if (EST == EST_ComputedNoexcept) {
5659 ESI.NoexceptExpr = ReadExpr(ModuleFile);
5660 } else if (EST == EST_Uninstantiated) {
5661 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5662 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5663 } else if (EST == EST_Unevaluated) {
5664 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5668 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5671 const ASTReader::RecordData &Record;
5674 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
5676 return Reader.ReadSourceLocation(F, R, I);
5679 template<typename T>
5680 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
5681 return Reader.ReadDeclAs<T>(F, Record, Idx);
5685 TypeLocReader(ASTReader &Reader, ModuleFile &F,
5686 const ASTReader::RecordData &Record, unsigned &Idx)
5687 : Reader(Reader), F(F), Record(Record), Idx(Idx)
5690 // We want compile-time assurance that we've enumerated all of
5691 // these, so unfortunately we have to declare them first, then
5692 // define them out-of-line.
5693 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5694 #define TYPELOC(CLASS, PARENT) \
5695 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5696 #include "clang/AST/TypeLocNodes.def"
5698 void VisitFunctionTypeLoc(FunctionTypeLoc);
5699 void VisitArrayTypeLoc(ArrayTypeLoc);
5702 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5705 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5706 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
5707 if (TL.needsExtraLocalData()) {
5708 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
5709 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
5710 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
5711 TL.setModeAttr(Record[Idx++]);
5714 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5715 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5717 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5718 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5720 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5723 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5726 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5727 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
5729 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5730 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
5732 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5733 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
5735 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5736 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5737 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5739 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5740 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
5741 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
5743 TL.setSizeExpr(Reader.ReadExpr(F));
5745 TL.setSizeExpr(nullptr);
5747 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5748 VisitArrayTypeLoc(TL);
5750 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5751 VisitArrayTypeLoc(TL);
5753 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5754 VisitArrayTypeLoc(TL);
5756 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5757 DependentSizedArrayTypeLoc TL) {
5758 VisitArrayTypeLoc(TL);
5760 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5761 DependentSizedExtVectorTypeLoc TL) {
5762 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5764 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5765 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5767 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5768 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5770 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5771 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
5772 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5773 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5774 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
5775 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5776 TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
5779 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5780 VisitFunctionTypeLoc(TL);
5782 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5783 VisitFunctionTypeLoc(TL);
5785 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5786 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5788 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5789 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5791 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5792 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5793 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5794 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5796 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5797 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5798 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5799 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5800 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5802 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5803 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5805 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5806 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5807 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5808 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5809 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5811 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5812 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5814 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5815 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5817 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
5818 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5820 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5821 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
5822 if (TL.hasAttrOperand()) {
5824 range.setBegin(ReadSourceLocation(Record, Idx));
5825 range.setEnd(ReadSourceLocation(Record, Idx));
5826 TL.setAttrOperandParensRange(range);
5828 if (TL.hasAttrExprOperand()) {
5830 TL.setAttrExprOperand(Reader.ReadExpr(F));
5832 TL.setAttrExprOperand(nullptr);
5833 } else if (TL.hasAttrEnumOperand())
5834 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
5836 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
5837 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5839 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
5840 SubstTemplateTypeParmTypeLoc TL) {
5841 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5843 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
5844 SubstTemplateTypeParmPackTypeLoc TL) {
5845 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5847 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
5848 TemplateSpecializationTypeLoc TL) {
5849 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5850 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5851 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5852 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5853 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
5855 Reader.GetTemplateArgumentLocInfo(F,
5856 TL.getTypePtr()->getArg(i).getKind(),
5859 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
5860 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5861 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5863 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5864 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5865 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5867 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
5868 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5870 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5871 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5872 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5873 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5875 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
5876 DependentTemplateSpecializationTypeLoc TL) {
5877 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5878 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5879 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5880 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5881 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5882 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5883 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
5885 Reader.GetTemplateArgumentLocInfo(F,
5886 TL.getTypePtr()->getArg(I).getKind(),
5889 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
5890 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
5892 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5893 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5895 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5896 TL.setHasBaseTypeAsWritten(Record[Idx++]);
5897 TL.setTypeArgsLAngleLoc(ReadSourceLocation(Record, Idx));
5898 TL.setTypeArgsRAngleLoc(ReadSourceLocation(Record, Idx));
5899 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
5900 TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(F, Record, Idx));
5901 TL.setProtocolLAngleLoc(ReadSourceLocation(Record, Idx));
5902 TL.setProtocolRAngleLoc(ReadSourceLocation(Record, Idx));
5903 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
5904 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
5906 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5907 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5909 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5910 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5911 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5912 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5915 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
5916 const RecordData &Record,
5918 QualType InfoTy = readType(F, Record, Idx);
5919 if (InfoTy.isNull())
5922 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
5923 TypeLocReader TLR(*this, F, Record, Idx);
5924 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
5929 QualType ASTReader::GetType(TypeID ID) {
5930 unsigned FastQuals = ID & Qualifiers::FastMask;
5931 unsigned Index = ID >> Qualifiers::FastWidth;
5933 if (Index < NUM_PREDEF_TYPE_IDS) {
5935 switch ((PredefinedTypeIDs)Index) {
5936 case PREDEF_TYPE_NULL_ID:
5938 case PREDEF_TYPE_VOID_ID:
5941 case PREDEF_TYPE_BOOL_ID:
5945 case PREDEF_TYPE_CHAR_U_ID:
5946 case PREDEF_TYPE_CHAR_S_ID:
5947 // FIXME: Check that the signedness of CharTy is correct!
5951 case PREDEF_TYPE_UCHAR_ID:
5952 T = Context.UnsignedCharTy;
5954 case PREDEF_TYPE_USHORT_ID:
5955 T = Context.UnsignedShortTy;
5957 case PREDEF_TYPE_UINT_ID:
5958 T = Context.UnsignedIntTy;
5960 case PREDEF_TYPE_ULONG_ID:
5961 T = Context.UnsignedLongTy;
5963 case PREDEF_TYPE_ULONGLONG_ID:
5964 T = Context.UnsignedLongLongTy;
5966 case PREDEF_TYPE_UINT128_ID:
5967 T = Context.UnsignedInt128Ty;
5969 case PREDEF_TYPE_SCHAR_ID:
5970 T = Context.SignedCharTy;
5972 case PREDEF_TYPE_WCHAR_ID:
5973 T = Context.WCharTy;
5975 case PREDEF_TYPE_SHORT_ID:
5976 T = Context.ShortTy;
5978 case PREDEF_TYPE_INT_ID:
5981 case PREDEF_TYPE_LONG_ID:
5984 case PREDEF_TYPE_LONGLONG_ID:
5985 T = Context.LongLongTy;
5987 case PREDEF_TYPE_INT128_ID:
5988 T = Context.Int128Ty;
5990 case PREDEF_TYPE_HALF_ID:
5993 case PREDEF_TYPE_FLOAT_ID:
5994 T = Context.FloatTy;
5996 case PREDEF_TYPE_DOUBLE_ID:
5997 T = Context.DoubleTy;
5999 case PREDEF_TYPE_LONGDOUBLE_ID:
6000 T = Context.LongDoubleTy;
6002 case PREDEF_TYPE_OVERLOAD_ID:
6003 T = Context.OverloadTy;
6005 case PREDEF_TYPE_BOUND_MEMBER:
6006 T = Context.BoundMemberTy;
6008 case PREDEF_TYPE_PSEUDO_OBJECT:
6009 T = Context.PseudoObjectTy;
6011 case PREDEF_TYPE_DEPENDENT_ID:
6012 T = Context.DependentTy;
6014 case PREDEF_TYPE_UNKNOWN_ANY:
6015 T = Context.UnknownAnyTy;
6017 case PREDEF_TYPE_NULLPTR_ID:
6018 T = Context.NullPtrTy;
6020 case PREDEF_TYPE_CHAR16_ID:
6021 T = Context.Char16Ty;
6023 case PREDEF_TYPE_CHAR32_ID:
6024 T = Context.Char32Ty;
6026 case PREDEF_TYPE_OBJC_ID:
6027 T = Context.ObjCBuiltinIdTy;
6029 case PREDEF_TYPE_OBJC_CLASS:
6030 T = Context.ObjCBuiltinClassTy;
6032 case PREDEF_TYPE_OBJC_SEL:
6033 T = Context.ObjCBuiltinSelTy;
6035 case PREDEF_TYPE_IMAGE1D_ID:
6036 T = Context.OCLImage1dTy;
6038 case PREDEF_TYPE_IMAGE1D_ARR_ID:
6039 T = Context.OCLImage1dArrayTy;
6041 case PREDEF_TYPE_IMAGE1D_BUFF_ID:
6042 T = Context.OCLImage1dBufferTy;
6044 case PREDEF_TYPE_IMAGE2D_ID:
6045 T = Context.OCLImage2dTy;
6047 case PREDEF_TYPE_IMAGE2D_ARR_ID:
6048 T = Context.OCLImage2dArrayTy;
6050 case PREDEF_TYPE_IMAGE2D_DEP_ID:
6051 T = Context.OCLImage2dDepthTy;
6053 case PREDEF_TYPE_IMAGE2D_ARR_DEP_ID:
6054 T = Context.OCLImage2dArrayDepthTy;
6056 case PREDEF_TYPE_IMAGE2D_MSAA_ID:
6057 T = Context.OCLImage2dMSAATy;
6059 case PREDEF_TYPE_IMAGE2D_ARR_MSAA_ID:
6060 T = Context.OCLImage2dArrayMSAATy;
6062 case PREDEF_TYPE_IMAGE2D_MSAA_DEP_ID:
6063 T = Context.OCLImage2dMSAADepthTy;
6065 case PREDEF_TYPE_IMAGE2D_ARR_MSAA_DEPTH_ID:
6066 T = Context.OCLImage2dArrayMSAADepthTy;
6068 case PREDEF_TYPE_IMAGE3D_ID:
6069 T = Context.OCLImage3dTy;
6071 case PREDEF_TYPE_SAMPLER_ID:
6072 T = Context.OCLSamplerTy;
6074 case PREDEF_TYPE_EVENT_ID:
6075 T = Context.OCLEventTy;
6077 case PREDEF_TYPE_CLK_EVENT_ID:
6078 T = Context.OCLClkEventTy;
6080 case PREDEF_TYPE_QUEUE_ID:
6081 T = Context.OCLQueueTy;
6083 case PREDEF_TYPE_NDRANGE_ID:
6084 T = Context.OCLNDRangeTy;
6086 case PREDEF_TYPE_RESERVE_ID_ID:
6087 T = Context.OCLReserveIDTy;
6089 case PREDEF_TYPE_AUTO_DEDUCT:
6090 T = Context.getAutoDeductType();
6093 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
6094 T = Context.getAutoRRefDeductType();
6097 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
6098 T = Context.ARCUnbridgedCastTy;
6101 case PREDEF_TYPE_BUILTIN_FN:
6102 T = Context.BuiltinFnTy;
6105 case PREDEF_TYPE_OMP_ARRAY_SECTION:
6106 T = Context.OMPArraySectionTy;
6110 assert(!T.isNull() && "Unknown predefined type");
6111 return T.withFastQualifiers(FastQuals);
6114 Index -= NUM_PREDEF_TYPE_IDS;
6115 assert(Index < TypesLoaded.size() && "Type index out-of-range");
6116 if (TypesLoaded[Index].isNull()) {
6117 TypesLoaded[Index] = readTypeRecord(Index);
6118 if (TypesLoaded[Index].isNull())
6121 TypesLoaded[Index]->setFromAST();
6122 if (DeserializationListener)
6123 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6124 TypesLoaded[Index]);
6127 return TypesLoaded[Index].withFastQualifiers(FastQuals);
6130 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6131 return GetType(getGlobalTypeID(F, LocalID));
6134 serialization::TypeID
6135 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6136 unsigned FastQuals = LocalID & Qualifiers::FastMask;
6137 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6139 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6142 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6143 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6144 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6146 unsigned GlobalIndex = LocalIndex + I->second;
6147 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6150 TemplateArgumentLocInfo
6151 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
6152 TemplateArgument::ArgKind Kind,
6153 const RecordData &Record,
6156 case TemplateArgument::Expression:
6158 case TemplateArgument::Type:
6159 return GetTypeSourceInfo(F, Record, Index);
6160 case TemplateArgument::Template: {
6161 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6163 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6164 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6167 case TemplateArgument::TemplateExpansion: {
6168 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6170 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6171 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6172 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6175 case TemplateArgument::Null:
6176 case TemplateArgument::Integral:
6177 case TemplateArgument::Declaration:
6178 case TemplateArgument::NullPtr:
6179 case TemplateArgument::Pack:
6180 // FIXME: Is this right?
6181 return TemplateArgumentLocInfo();
6183 llvm_unreachable("unexpected template argument loc");
6187 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6188 const RecordData &Record, unsigned &Index) {
6189 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6191 if (Arg.getKind() == TemplateArgument::Expression) {
6192 if (Record[Index++]) // bool InfoHasSameExpr.
6193 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6195 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6199 const ASTTemplateArgumentListInfo*
6200 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6201 const RecordData &Record,
6203 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6204 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6205 unsigned NumArgsAsWritten = Record[Index++];
6206 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6207 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6208 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6209 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6212 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6216 template<typename TemplateSpecializationDecl>
6217 static void completeRedeclChainForTemplateSpecialization(Decl *D) {
6218 if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D))
6219 TSD->getSpecializedTemplate()->LoadLazySpecializations();
6222 void ASTReader::CompleteRedeclChain(const Decl *D) {
6223 if (NumCurrentElementsDeserializing) {
6224 // We arrange to not care about the complete redeclaration chain while we're
6225 // deserializing. Just remember that the AST has marked this one as complete
6226 // but that it's not actually complete yet, so we know we still need to
6227 // complete it later.
6228 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6232 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6234 // If this is a named declaration, complete it by looking it up
6235 // within its context.
6237 // FIXME: Merging a function definition should merge
6238 // all mergeable entities within it.
6239 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6240 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6241 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6242 if (!getContext().getLangOpts().CPlusPlus &&
6243 isa<TranslationUnitDecl>(DC)) {
6244 // Outside of C++, we don't have a lookup table for the TU, so update
6245 // the identifier instead. (For C++ modules, we don't store decls
6246 // in the serialized identifier table, so we do the lookup in the TU.)
6247 auto *II = Name.getAsIdentifierInfo();
6248 assert(II && "non-identifier name in C?");
6249 if (II->isOutOfDate())
6250 updateOutOfDateIdentifier(*II);
6253 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6254 // Find all declarations of this kind from the relevant context.
6255 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6256 auto *DC = cast<DeclContext>(DCDecl);
6257 SmallVector<Decl*, 8> Decls;
6258 FindExternalLexicalDecls(
6259 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
6264 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
6265 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
6266 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
6267 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
6268 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6269 if (auto *Template = FD->getPrimaryTemplate())
6270 Template->LoadLazySpecializations();
6274 uint64_t ASTReader::ReadCXXCtorInitializersRef(ModuleFile &M,
6275 const RecordData &Record,
6277 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXCtorInitializers) {
6278 Error("malformed AST file: missing C++ ctor initializers");
6282 unsigned LocalID = Record[Idx++];
6283 return getGlobalBitOffset(M, M.CXXCtorInitializersOffsets[LocalID - 1]);
6286 CXXCtorInitializer **
6287 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
6288 RecordLocation Loc = getLocalBitOffset(Offset);
6289 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6290 SavedStreamPosition SavedPosition(Cursor);
6291 Cursor.JumpToBit(Loc.Offset);
6292 ReadingKindTracker ReadingKind(Read_Decl, *this);
6295 unsigned Code = Cursor.ReadCode();
6296 unsigned RecCode = Cursor.readRecord(Code, Record);
6297 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
6298 Error("malformed AST file: missing C++ ctor initializers");
6303 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
6306 uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M,
6307 const RecordData &Record,
6309 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXBaseSpecifiers) {
6310 Error("malformed AST file: missing C++ base specifier");
6314 unsigned LocalID = Record[Idx++];
6315 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
6318 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
6319 RecordLocation Loc = getLocalBitOffset(Offset);
6320 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6321 SavedStreamPosition SavedPosition(Cursor);
6322 Cursor.JumpToBit(Loc.Offset);
6323 ReadingKindTracker ReadingKind(Read_Decl, *this);
6325 unsigned Code = Cursor.ReadCode();
6326 unsigned RecCode = Cursor.readRecord(Code, Record);
6327 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
6328 Error("malformed AST file: missing C++ base specifiers");
6333 unsigned NumBases = Record[Idx++];
6334 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6335 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6336 for (unsigned I = 0; I != NumBases; ++I)
6337 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6341 serialization::DeclID
6342 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6343 if (LocalID < NUM_PREDEF_DECL_IDS)
6346 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6347 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6348 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6350 return LocalID + I->second;
6353 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
6354 ModuleFile &M) const {
6355 // Predefined decls aren't from any module.
6356 if (ID < NUM_PREDEF_DECL_IDS)
6359 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
6360 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
6363 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
6364 if (!D->isFromASTFile())
6366 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6367 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6371 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
6372 if (ID < NUM_PREDEF_DECL_IDS)
6373 return SourceLocation();
6375 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6377 if (Index > DeclsLoaded.size()) {
6378 Error("declaration ID out-of-range for AST file");
6379 return SourceLocation();
6382 if (Decl *D = DeclsLoaded[Index])
6383 return D->getLocation();
6385 unsigned RawLocation = 0;
6386 RecordLocation Rec = DeclCursorForID(ID, RawLocation);
6387 return ReadSourceLocation(*Rec.F, RawLocation);
6390 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
6392 case PREDEF_DECL_NULL_ID:
6395 case PREDEF_DECL_TRANSLATION_UNIT_ID:
6396 return Context.getTranslationUnitDecl();
6398 case PREDEF_DECL_OBJC_ID_ID:
6399 return Context.getObjCIdDecl();
6401 case PREDEF_DECL_OBJC_SEL_ID:
6402 return Context.getObjCSelDecl();
6404 case PREDEF_DECL_OBJC_CLASS_ID:
6405 return Context.getObjCClassDecl();
6407 case PREDEF_DECL_OBJC_PROTOCOL_ID:
6408 return Context.getObjCProtocolDecl();
6410 case PREDEF_DECL_INT_128_ID:
6411 return Context.getInt128Decl();
6413 case PREDEF_DECL_UNSIGNED_INT_128_ID:
6414 return Context.getUInt128Decl();
6416 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
6417 return Context.getObjCInstanceTypeDecl();
6419 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
6420 return Context.getBuiltinVaListDecl();
6422 case PREDEF_DECL_VA_LIST_TAG:
6423 return Context.getVaListTagDecl();
6425 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
6426 return Context.getBuiltinMSVaListDecl();
6428 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
6429 return Context.getExternCContextDecl();
6431 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
6432 return Context.getMakeIntegerSeqDecl();
6434 llvm_unreachable("PredefinedDeclIDs unknown enum value");
6437 Decl *ASTReader::GetExistingDecl(DeclID ID) {
6438 if (ID < NUM_PREDEF_DECL_IDS) {
6439 Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID);
6441 // Track that we have merged the declaration with ID \p ID into the
6442 // pre-existing predefined declaration \p D.
6443 auto &Merged = KeyDecls[D->getCanonicalDecl()];
6445 Merged.push_back(ID);
6450 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6452 if (Index >= DeclsLoaded.size()) {
6453 assert(0 && "declaration ID out-of-range for AST file");
6454 Error("declaration ID out-of-range for AST file");
6458 return DeclsLoaded[Index];
6461 Decl *ASTReader::GetDecl(DeclID ID) {
6462 if (ID < NUM_PREDEF_DECL_IDS)
6463 return GetExistingDecl(ID);
6465 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6467 if (Index >= DeclsLoaded.size()) {
6468 assert(0 && "declaration ID out-of-range for AST file");
6469 Error("declaration ID out-of-range for AST file");
6473 if (!DeclsLoaded[Index]) {
6475 if (DeserializationListener)
6476 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
6479 return DeclsLoaded[Index];
6482 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
6484 if (GlobalID < NUM_PREDEF_DECL_IDS)
6487 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
6488 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6489 ModuleFile *Owner = I->second;
6491 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
6492 = M.GlobalToLocalDeclIDs.find(Owner);
6493 if (Pos == M.GlobalToLocalDeclIDs.end())
6496 return GlobalID - Owner->BaseDeclID + Pos->second;
6499 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
6500 const RecordData &Record,
6502 if (Idx >= Record.size()) {
6503 Error("Corrupted AST file");
6507 return getGlobalDeclID(F, Record[Idx++]);
6510 /// \brief Resolve the offset of a statement into a statement.
6512 /// This operation will read a new statement from the external
6513 /// source each time it is called, and is meant to be used via a
6514 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
6515 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
6516 // Switch case IDs are per Decl.
6517 ClearSwitchCaseIDs();
6519 // Offset here is a global offset across the entire chain.
6520 RecordLocation Loc = getLocalBitOffset(Offset);
6521 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
6522 return ReadStmtFromStream(*Loc.F);
6525 void ASTReader::FindExternalLexicalDecls(
6526 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
6527 SmallVectorImpl<Decl *> &Decls) {
6528 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
6530 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
6531 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
6532 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
6533 auto K = (Decl::Kind)+LexicalDecls[I];
6534 if (!IsKindWeWant(K))
6537 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
6539 // Don't add predefined declarations to the lexical context more
6541 if (ID < NUM_PREDEF_DECL_IDS) {
6542 if (PredefsVisited[ID])
6545 PredefsVisited[ID] = true;
6548 if (Decl *D = GetLocalDecl(*M, ID)) {
6549 assert(D->getKind() == K && "wrong kind for lexical decl");
6550 if (!DC->isDeclInLexicalTraversal(D))
6556 if (isa<TranslationUnitDecl>(DC)) {
6557 for (auto Lexical : TULexicalDecls)
6558 Visit(Lexical.first, Lexical.second);
6560 auto I = LexicalDecls.find(DC);
6561 if (I != LexicalDecls.end())
6562 Visit(I->second.first, I->second.second);
6565 ++NumLexicalDeclContextsRead;
6575 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
6577 bool operator()(LocalDeclID L, LocalDeclID R) const {
6578 SourceLocation LHS = getLocation(L);
6579 SourceLocation RHS = getLocation(R);
6580 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6583 bool operator()(SourceLocation LHS, LocalDeclID R) const {
6584 SourceLocation RHS = getLocation(R);
6585 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6588 bool operator()(LocalDeclID L, SourceLocation RHS) const {
6589 SourceLocation LHS = getLocation(L);
6590 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6593 SourceLocation getLocation(LocalDeclID ID) const {
6594 return Reader.getSourceManager().getFileLoc(
6595 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
6601 void ASTReader::FindFileRegionDecls(FileID File,
6602 unsigned Offset, unsigned Length,
6603 SmallVectorImpl<Decl *> &Decls) {
6604 SourceManager &SM = getSourceManager();
6606 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
6607 if (I == FileDeclIDs.end())
6610 FileDeclsInfo &DInfo = I->second;
6611 if (DInfo.Decls.empty())
6615 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
6616 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
6618 DeclIDComp DIDComp(*this, *DInfo.Mod);
6619 ArrayRef<serialization::LocalDeclID>::iterator
6620 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6622 if (BeginIt != DInfo.Decls.begin())
6625 // If we are pointing at a top-level decl inside an objc container, we need
6626 // to backtrack until we find it otherwise we will fail to report that the
6627 // region overlaps with an objc container.
6628 while (BeginIt != DInfo.Decls.begin() &&
6629 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
6630 ->isTopLevelDeclInObjCContainer())
6633 ArrayRef<serialization::LocalDeclID>::iterator
6634 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6636 if (EndIt != DInfo.Decls.end())
6639 for (ArrayRef<serialization::LocalDeclID>::iterator
6640 DIt = BeginIt; DIt != EndIt; ++DIt)
6641 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
6645 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
6646 DeclarationName Name) {
6647 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
6648 "DeclContext has no visible decls in storage");
6652 auto It = Lookups.find(DC);
6653 if (It == Lookups.end())
6656 Deserializing LookupResults(this);
6658 // Load the list of declarations.
6659 SmallVector<NamedDecl *, 64> Decls;
6660 for (DeclID ID : It->second.Table.find(Name)) {
6661 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6662 if (ND->getDeclName() == Name)
6663 Decls.push_back(ND);
6666 ++NumVisibleDeclContextsRead;
6667 SetExternalVisibleDeclsForName(DC, Name, Decls);
6668 return !Decls.empty();
6671 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
6672 if (!DC->hasExternalVisibleStorage())
6675 auto It = Lookups.find(DC);
6676 assert(It != Lookups.end() &&
6677 "have external visible storage but no lookup tables");
6681 for (DeclID ID : It->second.Table.findAll()) {
6682 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6683 Decls[ND->getDeclName()].push_back(ND);
6686 ++NumVisibleDeclContextsRead;
6688 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
6689 SetExternalVisibleDeclsForName(DC, I->first, I->second);
6691 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
6694 const serialization::reader::DeclContextLookupTable *
6695 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
6696 auto I = Lookups.find(Primary);
6697 return I == Lookups.end() ? nullptr : &I->second;
6700 /// \brief Under non-PCH compilation the consumer receives the objc methods
6701 /// before receiving the implementation, and codegen depends on this.
6702 /// We simulate this by deserializing and passing to consumer the methods of the
6703 /// implementation before passing the deserialized implementation decl.
6704 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
6705 ASTConsumer *Consumer) {
6706 assert(ImplD && Consumer);
6708 for (auto *I : ImplD->methods())
6709 Consumer->HandleInterestingDecl(DeclGroupRef(I));
6711 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
6714 void ASTReader::PassInterestingDeclsToConsumer() {
6717 if (PassingDeclsToConsumer)
6720 // Guard variable to avoid recursively redoing the process of passing
6721 // decls to consumer.
6722 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6725 // Ensure that we've loaded all potentially-interesting declarations
6726 // that need to be eagerly loaded.
6727 for (auto ID : EagerlyDeserializedDecls)
6729 EagerlyDeserializedDecls.clear();
6731 while (!InterestingDecls.empty()) {
6732 Decl *D = InterestingDecls.front();
6733 InterestingDecls.pop_front();
6735 PassInterestingDeclToConsumer(D);
6739 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
6740 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6741 PassObjCImplDeclToConsumer(ImplD, Consumer);
6743 Consumer->HandleInterestingDecl(DeclGroupRef(D));
6746 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
6747 this->Consumer = Consumer;
6750 PassInterestingDeclsToConsumer();
6752 if (DeserializationListener)
6753 DeserializationListener->ReaderInitialized(this);
6756 void ASTReader::PrintStats() {
6757 std::fprintf(stderr, "*** AST File Statistics:\n");
6759 unsigned NumTypesLoaded
6760 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
6762 unsigned NumDeclsLoaded
6763 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
6765 unsigned NumIdentifiersLoaded
6766 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
6767 IdentifiersLoaded.end(),
6768 (IdentifierInfo *)nullptr);
6769 unsigned NumMacrosLoaded
6770 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
6772 (MacroInfo *)nullptr);
6773 unsigned NumSelectorsLoaded
6774 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
6775 SelectorsLoaded.end(),
6778 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
6779 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
6780 NumSLocEntriesRead, TotalNumSLocEntries,
6781 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
6782 if (!TypesLoaded.empty())
6783 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
6784 NumTypesLoaded, (unsigned)TypesLoaded.size(),
6785 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
6786 if (!DeclsLoaded.empty())
6787 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
6788 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
6789 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
6790 if (!IdentifiersLoaded.empty())
6791 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
6792 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
6793 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
6794 if (!MacrosLoaded.empty())
6795 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6796 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
6797 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
6798 if (!SelectorsLoaded.empty())
6799 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
6800 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
6801 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
6802 if (TotalNumStatements)
6803 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
6804 NumStatementsRead, TotalNumStatements,
6805 ((float)NumStatementsRead/TotalNumStatements * 100));
6807 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6808 NumMacrosRead, TotalNumMacros,
6809 ((float)NumMacrosRead/TotalNumMacros * 100));
6810 if (TotalLexicalDeclContexts)
6811 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
6812 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
6813 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
6815 if (TotalVisibleDeclContexts)
6816 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
6817 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
6818 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
6820 if (TotalNumMethodPoolEntries) {
6821 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
6822 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
6823 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
6826 if (NumMethodPoolLookups) {
6827 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
6828 NumMethodPoolHits, NumMethodPoolLookups,
6829 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
6831 if (NumMethodPoolTableLookups) {
6832 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
6833 NumMethodPoolTableHits, NumMethodPoolTableLookups,
6834 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
6838 if (NumIdentifierLookupHits) {
6839 std::fprintf(stderr,
6840 " %u / %u identifier table lookups succeeded (%f%%)\n",
6841 NumIdentifierLookupHits, NumIdentifierLookups,
6842 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
6846 std::fprintf(stderr, "\n");
6847 GlobalIndex->printStats();
6850 std::fprintf(stderr, "\n");
6852 std::fprintf(stderr, "\n");
6855 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
6857 dumpModuleIDMap(StringRef Name,
6858 const ContinuousRangeMap<Key, ModuleFile *,
6859 InitialCapacity> &Map) {
6860 if (Map.begin() == Map.end())
6863 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
6864 llvm::errs() << Name << ":\n";
6865 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
6867 llvm::errs() << " " << I->first << " -> " << I->second->FileName
6872 void ASTReader::dump() {
6873 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
6874 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
6875 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
6876 dumpModuleIDMap("Global type map", GlobalTypeMap);
6877 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
6878 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
6879 dumpModuleIDMap("Global macro map", GlobalMacroMap);
6880 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
6881 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
6882 dumpModuleIDMap("Global preprocessed entity map",
6883 GlobalPreprocessedEntityMap);
6885 llvm::errs() << "\n*** PCH/Modules Loaded:";
6886 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
6887 MEnd = ModuleMgr.end();
6892 /// Return the amount of memory used by memory buffers, breaking down
6893 /// by heap-backed versus mmap'ed memory.
6894 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
6895 for (ModuleConstIterator I = ModuleMgr.begin(),
6896 E = ModuleMgr.end(); I != E; ++I) {
6897 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
6898 size_t bytes = buf->getBufferSize();
6899 switch (buf->getBufferKind()) {
6900 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
6901 sizes.malloc_bytes += bytes;
6903 case llvm::MemoryBuffer::MemoryBuffer_MMap:
6904 sizes.mmap_bytes += bytes;
6911 void ASTReader::InitializeSema(Sema &S) {
6913 S.addExternalSource(this);
6915 // Makes sure any declarations that were deserialized "too early"
6916 // still get added to the identifier's declaration chains.
6917 for (uint64_t ID : PreloadedDeclIDs) {
6918 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
6919 pushExternalDeclIntoScope(D, D->getDeclName());
6921 PreloadedDeclIDs.clear();
6923 // FIXME: What happens if these are changed by a module import?
6924 if (!FPPragmaOptions.empty()) {
6925 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
6926 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
6929 // FIXME: What happens if these are changed by a module import?
6930 if (!OpenCLExtensions.empty()) {
6932 #define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
6933 #include "clang/Basic/OpenCLExtensions.def"
6935 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
6941 void ASTReader::UpdateSema() {
6942 assert(SemaObj && "no Sema to update");
6944 // Load the offsets of the declarations that Sema references.
6945 // They will be lazily deserialized when needed.
6946 if (!SemaDeclRefs.empty()) {
6947 assert(SemaDeclRefs.size() % 2 == 0);
6948 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) {
6949 if (!SemaObj->StdNamespace)
6950 SemaObj->StdNamespace = SemaDeclRefs[I];
6951 if (!SemaObj->StdBadAlloc)
6952 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
6954 SemaDeclRefs.clear();
6957 // Update the state of 'pragma clang optimize'. Use the same API as if we had
6958 // encountered the pragma in the source.
6959 if(OptimizeOffPragmaLocation.isValid())
6960 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
6963 IdentifierInfo *ASTReader::get(StringRef Name) {
6964 // Note that we are loading an identifier.
6965 Deserializing AnIdentifier(this);
6967 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
6968 NumIdentifierLookups,
6969 NumIdentifierLookupHits);
6971 // We don't need to do identifier table lookups in C++ modules (we preload
6972 // all interesting declarations, and don't need to use the scope for name
6973 // lookups). Perform the lookup in PCH files, though, since we don't build
6974 // a complete initial identifier table if we're carrying on from a PCH.
6975 if (Context.getLangOpts().CPlusPlus) {
6976 for (auto F : ModuleMgr.pch_modules())
6980 // If there is a global index, look there first to determine which modules
6981 // provably do not have any results for this identifier.
6982 GlobalModuleIndex::HitSet Hits;
6983 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
6984 if (!loadGlobalIndex()) {
6985 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
6990 ModuleMgr.visit(Visitor, HitsPtr);
6993 IdentifierInfo *II = Visitor.getIdentifierInfo();
6994 markIdentifierUpToDate(II);
6999 /// \brief An identifier-lookup iterator that enumerates all of the
7000 /// identifiers stored within a set of AST files.
7001 class ASTIdentifierIterator : public IdentifierIterator {
7002 /// \brief The AST reader whose identifiers are being enumerated.
7003 const ASTReader &Reader;
7005 /// \brief The current index into the chain of AST files stored in
7009 /// \brief The current position within the identifier lookup table
7010 /// of the current AST file.
7011 ASTIdentifierLookupTable::key_iterator Current;
7013 /// \brief The end position within the identifier lookup table of
7014 /// the current AST file.
7015 ASTIdentifierLookupTable::key_iterator End;
7018 explicit ASTIdentifierIterator(const ASTReader &Reader);
7020 StringRef Next() override;
7024 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
7025 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
7026 ASTIdentifierLookupTable *IdTable
7027 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
7028 Current = IdTable->key_begin();
7029 End = IdTable->key_end();
7032 StringRef ASTIdentifierIterator::Next() {
7033 while (Current == End) {
7034 // If we have exhausted all of our AST files, we're done.
7039 ASTIdentifierLookupTable *IdTable
7040 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
7041 IdentifierLookupTable;
7042 Current = IdTable->key_begin();
7043 End = IdTable->key_end();
7046 // We have any identifiers remaining in the current AST file; return
7048 StringRef Result = *Current;
7053 IdentifierIterator *ASTReader::getIdentifiers() {
7054 if (!loadGlobalIndex())
7055 return GlobalIndex->createIdentifierIterator();
7057 return new ASTIdentifierIterator(*this);
7060 namespace clang { namespace serialization {
7061 class ReadMethodPoolVisitor {
7064 unsigned PriorGeneration;
7065 unsigned InstanceBits;
7066 unsigned FactoryBits;
7067 bool InstanceHasMoreThanOneDecl;
7068 bool FactoryHasMoreThanOneDecl;
7069 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7070 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7073 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
7074 unsigned PriorGeneration)
7075 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
7076 InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
7077 FactoryHasMoreThanOneDecl(false) {}
7079 bool operator()(ModuleFile &M) {
7080 if (!M.SelectorLookupTable)
7083 // If we've already searched this module file, skip it now.
7084 if (M.Generation <= PriorGeneration)
7087 ++Reader.NumMethodPoolTableLookups;
7088 ASTSelectorLookupTable *PoolTable
7089 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
7090 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
7091 if (Pos == PoolTable->end())
7094 ++Reader.NumMethodPoolTableHits;
7095 ++Reader.NumSelectorsRead;
7096 // FIXME: Not quite happy with the statistics here. We probably should
7097 // disable this tracking when called via LoadSelector.
7098 // Also, should entries without methods count as misses?
7099 ++Reader.NumMethodPoolEntriesRead;
7100 ASTSelectorLookupTrait::data_type Data = *Pos;
7101 if (Reader.DeserializationListener)
7102 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
7104 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7105 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7106 InstanceBits = Data.InstanceBits;
7107 FactoryBits = Data.FactoryBits;
7108 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7109 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
7113 /// \brief Retrieve the instance methods found by this visitor.
7114 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
7115 return InstanceMethods;
7118 /// \brief Retrieve the instance methods found by this visitor.
7119 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
7120 return FactoryMethods;
7123 unsigned getInstanceBits() const { return InstanceBits; }
7124 unsigned getFactoryBits() const { return FactoryBits; }
7125 bool instanceHasMoreThanOneDecl() const {
7126 return InstanceHasMoreThanOneDecl;
7128 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
7130 } } // end namespace clang::serialization
7132 /// \brief Add the given set of methods to the method list.
7133 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
7134 ObjCMethodList &List) {
7135 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7136 S.addMethodToGlobalList(&List, Methods[I]);
7140 void ASTReader::ReadMethodPool(Selector Sel) {
7141 // Get the selector generation and update it to the current generation.
7142 unsigned &Generation = SelectorGeneration[Sel];
7143 unsigned PriorGeneration = Generation;
7144 Generation = getGeneration();
7146 // Search for methods defined with this selector.
7147 ++NumMethodPoolLookups;
7148 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7149 ModuleMgr.visit(Visitor);
7151 if (Visitor.getInstanceMethods().empty() &&
7152 Visitor.getFactoryMethods().empty())
7155 ++NumMethodPoolHits;
7160 Sema &S = *getSema();
7161 Sema::GlobalMethodPool::iterator Pos
7162 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7164 Pos->second.first.setBits(Visitor.getInstanceBits());
7165 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
7166 Pos->second.second.setBits(Visitor.getFactoryBits());
7167 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
7169 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7170 // when building a module we keep every method individually and may need to
7171 // update hasMoreThanOneDecl as we add the methods.
7172 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7173 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7176 void ASTReader::ReadKnownNamespaces(
7177 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7180 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7181 if (NamespaceDecl *Namespace
7182 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7183 Namespaces.push_back(Namespace);
7187 void ASTReader::ReadUndefinedButUsed(
7188 llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) {
7189 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7190 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7191 SourceLocation Loc =
7192 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7193 Undefined.insert(std::make_pair(D, Loc));
7197 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
7198 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7200 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7201 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7202 uint64_t Count = DelayedDeleteExprs[Idx++];
7203 for (uint64_t C = 0; C < Count; ++C) {
7204 SourceLocation DeleteLoc =
7205 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7206 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7207 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7212 void ASTReader::ReadTentativeDefinitions(
7213 SmallVectorImpl<VarDecl *> &TentativeDefs) {
7214 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7215 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7217 TentativeDefs.push_back(Var);
7219 TentativeDefinitions.clear();
7222 void ASTReader::ReadUnusedFileScopedDecls(
7223 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
7224 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7226 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7230 UnusedFileScopedDecls.clear();
7233 void ASTReader::ReadDelegatingConstructors(
7234 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
7235 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7236 CXXConstructorDecl *D
7237 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7241 DelegatingCtorDecls.clear();
7244 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
7245 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7247 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7251 ExtVectorDecls.clear();
7254 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
7255 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
7256 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7258 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7259 GetDecl(UnusedLocalTypedefNameCandidates[I]));
7263 UnusedLocalTypedefNameCandidates.clear();
7266 void ASTReader::ReadReferencedSelectors(
7267 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7268 if (ReferencedSelectorsData.empty())
7271 // If there are @selector references added them to its pool. This is for
7272 // implementation of -Wselector.
7273 unsigned int DataSize = ReferencedSelectorsData.size()-1;
7275 while (I < DataSize) {
7276 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7277 SourceLocation SelLoc
7278 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7279 Sels.push_back(std::make_pair(Sel, SelLoc));
7281 ReferencedSelectorsData.clear();
7284 void ASTReader::ReadWeakUndeclaredIdentifiers(
7285 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7286 if (WeakUndeclaredIdentifiers.empty())
7289 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7290 IdentifierInfo *WeakId
7291 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7292 IdentifierInfo *AliasId
7293 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7295 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7296 bool Used = WeakUndeclaredIdentifiers[I++];
7297 WeakInfo WI(AliasId, Loc);
7299 WeakIDs.push_back(std::make_pair(WeakId, WI));
7301 WeakUndeclaredIdentifiers.clear();
7304 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7305 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7306 ExternalVTableUse VT;
7307 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7308 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7309 VT.DefinitionRequired = VTableUses[Idx++];
7310 VTables.push_back(VT);
7316 void ASTReader::ReadPendingInstantiations(
7317 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7318 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7319 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7321 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7323 Pending.push_back(std::make_pair(D, Loc));
7325 PendingInstantiations.clear();
7328 void ASTReader::ReadLateParsedTemplates(
7329 llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
7330 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7332 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7334 LateParsedTemplate *LT = new LateParsedTemplate;
7335 LT->D = GetDecl(LateParsedTemplates[Idx++]);
7337 ModuleFile *F = getOwningModuleFile(LT->D);
7338 assert(F && "No module");
7340 unsigned TokN = LateParsedTemplates[Idx++];
7341 LT->Toks.reserve(TokN);
7342 for (unsigned T = 0; T < TokN; ++T)
7343 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7345 LPTMap.insert(std::make_pair(FD, LT));
7348 LateParsedTemplates.clear();
7351 void ASTReader::LoadSelector(Selector Sel) {
7352 // It would be complicated to avoid reading the methods anyway. So don't.
7353 ReadMethodPool(Sel);
7356 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7357 assert(ID && "Non-zero identifier ID required");
7358 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7359 IdentifiersLoaded[ID - 1] = II;
7360 if (DeserializationListener)
7361 DeserializationListener->IdentifierRead(ID, II);
7364 /// \brief Set the globally-visible declarations associated with the given
7367 /// If the AST reader is currently in a state where the given declaration IDs
7368 /// cannot safely be resolved, they are queued until it is safe to resolve
7371 /// \param II an IdentifierInfo that refers to one or more globally-visible
7374 /// \param DeclIDs the set of declaration IDs with the name @p II that are
7375 /// visible at global scope.
7377 /// \param Decls if non-null, this vector will be populated with the set of
7378 /// deserialized declarations. These declarations will not be pushed into
7381 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7382 const SmallVectorImpl<uint32_t> &DeclIDs,
7383 SmallVectorImpl<Decl *> *Decls) {
7384 if (NumCurrentElementsDeserializing && !Decls) {
7385 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
7389 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
7391 // Queue this declaration so that it will be added to the
7392 // translation unit scope and identifier's declaration chain
7393 // once a Sema object is known.
7394 PreloadedDeclIDs.push_back(DeclIDs[I]);
7398 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7400 // If we're simply supposed to record the declarations, do so now.
7402 Decls->push_back(D);
7406 // Introduce this declaration into the translation-unit scope
7407 // and add it to the declaration chain for this identifier, so
7408 // that (unqualified) name lookup will find it.
7409 pushExternalDeclIntoScope(D, II);
7413 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
7417 if (IdentifiersLoaded.empty()) {
7418 Error("no identifier table in AST file");
7423 if (!IdentifiersLoaded[ID]) {
7424 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7425 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7426 ModuleFile *M = I->second;
7427 unsigned Index = ID - M->BaseIdentifierID;
7428 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7430 // All of the strings in the AST file are preceded by a 16-bit length.
7431 // Extract that 16-bit length to avoid having to execute strlen().
7432 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7433 // unsigned integers. This is important to avoid integer overflow when
7434 // we cast them to 'unsigned'.
7435 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7436 unsigned StrLen = (((unsigned) StrLenPtr[0])
7437 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
7438 IdentifiersLoaded[ID]
7439 = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
7440 if (DeserializationListener)
7441 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
7444 return IdentifiersLoaded[ID];
7447 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7448 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
7451 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7452 if (LocalID < NUM_PREDEF_IDENT_IDS)
7455 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7456 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7457 assert(I != M.IdentifierRemap.end()
7458 && "Invalid index into identifier index remap");
7460 return LocalID + I->second;
7463 MacroInfo *ASTReader::getMacro(MacroID ID) {
7467 if (MacrosLoaded.empty()) {
7468 Error("no macro table in AST file");
7472 ID -= NUM_PREDEF_MACRO_IDS;
7473 if (!MacrosLoaded[ID]) {
7474 GlobalMacroMapType::iterator I
7475 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7476 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7477 ModuleFile *M = I->second;
7478 unsigned Index = ID - M->BaseMacroID;
7479 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7481 if (DeserializationListener)
7482 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7486 return MacrosLoaded[ID];
7489 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7490 if (LocalID < NUM_PREDEF_MACRO_IDS)
7493 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7494 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7495 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7497 return LocalID + I->second;
7500 serialization::SubmoduleID
7501 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7502 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7505 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7506 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7507 assert(I != M.SubmoduleRemap.end()
7508 && "Invalid index into submodule index remap");
7510 return LocalID + I->second;
7513 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7514 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7515 assert(GlobalID == 0 && "Unhandled global submodule ID");
7519 if (GlobalID > SubmodulesLoaded.size()) {
7520 Error("submodule ID out of range in AST file");
7524 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7527 Module *ASTReader::getModule(unsigned ID) {
7528 return getSubmodule(ID);
7531 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
7533 // It's a module, look it up by submodule ID.
7534 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
7535 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
7537 // It's a prefix (preamble, PCH, ...). Look it up by index.
7538 unsigned IndexFromEnd = ID >> 1;
7539 assert(IndexFromEnd && "got reference to unknown module file");
7540 return getModuleManager().pch_modules().end()[-IndexFromEnd];
7544 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
7548 // For a file representing a module, use the submodule ID of the top-level
7549 // module as the file ID. For any other kind of file, the number of such
7550 // files loaded beforehand will be the same on reload.
7551 // FIXME: Is this true even if we have an explicit module file and a PCH?
7553 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
7555 auto PCHModules = getModuleManager().pch_modules();
7556 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
7557 assert(I != PCHModules.end() && "emitting reference to unknown file");
7558 return (I - PCHModules.end()) << 1;
7561 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
7562 ASTReader::getSourceDescriptor(unsigned ID) {
7563 if (const Module *M = getSubmodule(ID))
7564 return ExternalASTSource::ASTSourceDescriptor(*M);
7566 // If there is only a single PCH, return it instead.
7567 // Chained PCH are not suported.
7568 if (ModuleMgr.size() == 1) {
7569 ModuleFile &MF = ModuleMgr.getPrimaryModule();
7570 return ASTReader::ASTSourceDescriptor(
7571 MF.OriginalSourceFileName, MF.OriginalDir, MF.FileName, MF.Signature);
7576 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7577 return DecodeSelector(getGlobalSelectorID(M, LocalID));
7580 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7584 if (ID > SelectorsLoaded.size()) {
7585 Error("selector ID out of range in AST file");
7589 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
7590 // Load this selector from the selector table.
7591 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7592 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7593 ModuleFile &M = *I->second;
7594 ASTSelectorLookupTrait Trait(*this, M);
7595 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7596 SelectorsLoaded[ID - 1] =
7597 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7598 if (DeserializationListener)
7599 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7602 return SelectorsLoaded[ID - 1];
7605 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7606 return DecodeSelector(ID);
7609 uint32_t ASTReader::GetNumExternalSelectors() {
7610 // ID 0 (the null selector) is considered an external selector.
7611 return getTotalNumSelectors() + 1;
7614 serialization::SelectorID
7615 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7616 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7619 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7620 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7621 assert(I != M.SelectorRemap.end()
7622 && "Invalid index into selector index remap");
7624 return LocalID + I->second;
7628 ASTReader::ReadDeclarationName(ModuleFile &F,
7629 const RecordData &Record, unsigned &Idx) {
7630 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7632 case DeclarationName::Identifier:
7633 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
7635 case DeclarationName::ObjCZeroArgSelector:
7636 case DeclarationName::ObjCOneArgSelector:
7637 case DeclarationName::ObjCMultiArgSelector:
7638 return DeclarationName(ReadSelector(F, Record, Idx));
7640 case DeclarationName::CXXConstructorName:
7641 return Context.DeclarationNames.getCXXConstructorName(
7642 Context.getCanonicalType(readType(F, Record, Idx)));
7644 case DeclarationName::CXXDestructorName:
7645 return Context.DeclarationNames.getCXXDestructorName(
7646 Context.getCanonicalType(readType(F, Record, Idx)));
7648 case DeclarationName::CXXConversionFunctionName:
7649 return Context.DeclarationNames.getCXXConversionFunctionName(
7650 Context.getCanonicalType(readType(F, Record, Idx)));
7652 case DeclarationName::CXXOperatorName:
7653 return Context.DeclarationNames.getCXXOperatorName(
7654 (OverloadedOperatorKind)Record[Idx++]);
7656 case DeclarationName::CXXLiteralOperatorName:
7657 return Context.DeclarationNames.getCXXLiteralOperatorName(
7658 GetIdentifierInfo(F, Record, Idx));
7660 case DeclarationName::CXXUsingDirective:
7661 return DeclarationName::getUsingDirectiveName();
7664 llvm_unreachable("Invalid NameKind!");
7667 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7668 DeclarationNameLoc &DNLoc,
7669 DeclarationName Name,
7670 const RecordData &Record, unsigned &Idx) {
7671 switch (Name.getNameKind()) {
7672 case DeclarationName::CXXConstructorName:
7673 case DeclarationName::CXXDestructorName:
7674 case DeclarationName::CXXConversionFunctionName:
7675 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7678 case DeclarationName::CXXOperatorName:
7679 DNLoc.CXXOperatorName.BeginOpNameLoc
7680 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7681 DNLoc.CXXOperatorName.EndOpNameLoc
7682 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7685 case DeclarationName::CXXLiteralOperatorName:
7686 DNLoc.CXXLiteralOperatorName.OpNameLoc
7687 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7690 case DeclarationName::Identifier:
7691 case DeclarationName::ObjCZeroArgSelector:
7692 case DeclarationName::ObjCOneArgSelector:
7693 case DeclarationName::ObjCMultiArgSelector:
7694 case DeclarationName::CXXUsingDirective:
7699 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7700 DeclarationNameInfo &NameInfo,
7701 const RecordData &Record, unsigned &Idx) {
7702 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7703 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7704 DeclarationNameLoc DNLoc;
7705 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7706 NameInfo.setInfo(DNLoc);
7709 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7710 const RecordData &Record, unsigned &Idx) {
7711 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7712 unsigned NumTPLists = Record[Idx++];
7713 Info.NumTemplParamLists = NumTPLists;
7715 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7716 for (unsigned i=0; i != NumTPLists; ++i)
7717 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7722 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7724 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7726 case TemplateName::Template:
7727 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7729 case TemplateName::OverloadedTemplate: {
7730 unsigned size = Record[Idx++];
7731 UnresolvedSet<8> Decls;
7733 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7735 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7738 case TemplateName::QualifiedTemplate: {
7739 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7740 bool hasTemplKeyword = Record[Idx++];
7741 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7742 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7745 case TemplateName::DependentTemplate: {
7746 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7747 if (Record[Idx++]) // isIdentifier
7748 return Context.getDependentTemplateName(NNS,
7749 GetIdentifierInfo(F, Record,
7751 return Context.getDependentTemplateName(NNS,
7752 (OverloadedOperatorKind)Record[Idx++]);
7755 case TemplateName::SubstTemplateTemplateParm: {
7756 TemplateTemplateParmDecl *param
7757 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7758 if (!param) return TemplateName();
7759 TemplateName replacement = ReadTemplateName(F, Record, Idx);
7760 return Context.getSubstTemplateTemplateParm(param, replacement);
7763 case TemplateName::SubstTemplateTemplateParmPack: {
7764 TemplateTemplateParmDecl *Param
7765 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7767 return TemplateName();
7769 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
7770 if (ArgPack.getKind() != TemplateArgument::Pack)
7771 return TemplateName();
7773 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
7777 llvm_unreachable("Unhandled template name kind!");
7780 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
7781 const RecordData &Record,
7783 bool Canonicalize) {
7785 // The caller wants a canonical template argument. Sometimes the AST only
7786 // wants template arguments in canonical form (particularly as the template
7787 // argument lists of template specializations) so ensure we preserve that
7788 // canonical form across serialization.
7789 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
7790 return Context.getCanonicalTemplateArgument(Arg);
7793 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
7795 case TemplateArgument::Null:
7796 return TemplateArgument();
7797 case TemplateArgument::Type:
7798 return TemplateArgument(readType(F, Record, Idx));
7799 case TemplateArgument::Declaration: {
7800 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
7801 return TemplateArgument(D, readType(F, Record, Idx));
7803 case TemplateArgument::NullPtr:
7804 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
7805 case TemplateArgument::Integral: {
7806 llvm::APSInt Value = ReadAPSInt(Record, Idx);
7807 QualType T = readType(F, Record, Idx);
7808 return TemplateArgument(Context, Value, T);
7810 case TemplateArgument::Template:
7811 return TemplateArgument(ReadTemplateName(F, Record, Idx));
7812 case TemplateArgument::TemplateExpansion: {
7813 TemplateName Name = ReadTemplateName(F, Record, Idx);
7814 Optional<unsigned> NumTemplateExpansions;
7815 if (unsigned NumExpansions = Record[Idx++])
7816 NumTemplateExpansions = NumExpansions - 1;
7817 return TemplateArgument(Name, NumTemplateExpansions);
7819 case TemplateArgument::Expression:
7820 return TemplateArgument(ReadExpr(F));
7821 case TemplateArgument::Pack: {
7822 unsigned NumArgs = Record[Idx++];
7823 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
7824 for (unsigned I = 0; I != NumArgs; ++I)
7825 Args[I] = ReadTemplateArgument(F, Record, Idx);
7826 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
7830 llvm_unreachable("Unhandled template argument kind!");
7833 TemplateParameterList *
7834 ASTReader::ReadTemplateParameterList(ModuleFile &F,
7835 const RecordData &Record, unsigned &Idx) {
7836 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
7837 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
7838 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
7840 unsigned NumParams = Record[Idx++];
7841 SmallVector<NamedDecl *, 16> Params;
7842 Params.reserve(NumParams);
7844 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
7846 TemplateParameterList* TemplateParams =
7847 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
7849 return TemplateParams;
7854 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
7855 ModuleFile &F, const RecordData &Record,
7856 unsigned &Idx, bool Canonicalize) {
7857 unsigned NumTemplateArgs = Record[Idx++];
7858 TemplArgs.reserve(NumTemplateArgs);
7859 while (NumTemplateArgs--)
7860 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
7863 /// \brief Read a UnresolvedSet structure.
7864 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
7865 const RecordData &Record, unsigned &Idx) {
7866 unsigned NumDecls = Record[Idx++];
7867 Set.reserve(Context, NumDecls);
7868 while (NumDecls--) {
7869 DeclID ID = ReadDeclID(F, Record, Idx);
7870 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
7871 Set.addLazyDecl(Context, ID, AS);
7876 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
7877 const RecordData &Record, unsigned &Idx) {
7878 bool isVirtual = static_cast<bool>(Record[Idx++]);
7879 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
7880 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
7881 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
7882 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
7883 SourceRange Range = ReadSourceRange(F, Record, Idx);
7884 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
7885 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
7887 Result.setInheritConstructors(inheritConstructors);
7891 CXXCtorInitializer **
7892 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
7894 unsigned NumInitializers = Record[Idx++];
7895 assert(NumInitializers && "wrote ctor initializers but have no inits");
7896 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
7897 for (unsigned i = 0; i != NumInitializers; ++i) {
7898 TypeSourceInfo *TInfo = nullptr;
7899 bool IsBaseVirtual = false;
7900 FieldDecl *Member = nullptr;
7901 IndirectFieldDecl *IndirectMember = nullptr;
7903 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
7905 case CTOR_INITIALIZER_BASE:
7906 TInfo = GetTypeSourceInfo(F, Record, Idx);
7907 IsBaseVirtual = Record[Idx++];
7910 case CTOR_INITIALIZER_DELEGATING:
7911 TInfo = GetTypeSourceInfo(F, Record, Idx);
7914 case CTOR_INITIALIZER_MEMBER:
7915 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
7918 case CTOR_INITIALIZER_INDIRECT_MEMBER:
7919 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
7923 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
7924 Expr *Init = ReadExpr(F);
7925 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
7926 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
7927 bool IsWritten = Record[Idx++];
7928 unsigned SourceOrderOrNumArrayIndices;
7929 SmallVector<VarDecl *, 8> Indices;
7931 SourceOrderOrNumArrayIndices = Record[Idx++];
7933 SourceOrderOrNumArrayIndices = Record[Idx++];
7934 Indices.reserve(SourceOrderOrNumArrayIndices);
7935 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
7936 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
7939 CXXCtorInitializer *BOMInit;
7940 if (Type == CTOR_INITIALIZER_BASE) {
7941 BOMInit = new (Context)
7942 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
7943 RParenLoc, MemberOrEllipsisLoc);
7944 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
7945 BOMInit = new (Context)
7946 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
7947 } else if (IsWritten) {
7949 BOMInit = new (Context) CXXCtorInitializer(
7950 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc);
7952 BOMInit = new (Context)
7953 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
7954 LParenLoc, Init, RParenLoc);
7956 if (IndirectMember) {
7957 assert(Indices.empty() && "Indirect field improperly initialized");
7958 BOMInit = new (Context)
7959 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
7960 LParenLoc, Init, RParenLoc);
7962 BOMInit = CXXCtorInitializer::Create(
7963 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc,
7964 Indices.data(), Indices.size());
7969 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
7970 CtorInitializers[i] = BOMInit;
7973 return CtorInitializers;
7976 NestedNameSpecifier *
7977 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
7978 const RecordData &Record, unsigned &Idx) {
7979 unsigned N = Record[Idx++];
7980 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
7981 for (unsigned I = 0; I != N; ++I) {
7982 NestedNameSpecifier::SpecifierKind Kind
7983 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
7985 case NestedNameSpecifier::Identifier: {
7986 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
7987 NNS = NestedNameSpecifier::Create(Context, Prev, II);
7991 case NestedNameSpecifier::Namespace: {
7992 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
7993 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
7997 case NestedNameSpecifier::NamespaceAlias: {
7998 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
7999 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8003 case NestedNameSpecifier::TypeSpec:
8004 case NestedNameSpecifier::TypeSpecWithTemplate: {
8005 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8009 bool Template = Record[Idx++];
8010 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8014 case NestedNameSpecifier::Global: {
8015 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8016 // No associated value, and there can't be a prefix.
8020 case NestedNameSpecifier::Super: {
8021 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8022 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8031 NestedNameSpecifierLoc
8032 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
8034 unsigned N = Record[Idx++];
8035 NestedNameSpecifierLocBuilder Builder;
8036 for (unsigned I = 0; I != N; ++I) {
8037 NestedNameSpecifier::SpecifierKind Kind
8038 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8040 case NestedNameSpecifier::Identifier: {
8041 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8042 SourceRange Range = ReadSourceRange(F, Record, Idx);
8043 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8047 case NestedNameSpecifier::Namespace: {
8048 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8049 SourceRange Range = ReadSourceRange(F, Record, Idx);
8050 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8054 case NestedNameSpecifier::NamespaceAlias: {
8055 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8056 SourceRange Range = ReadSourceRange(F, Record, Idx);
8057 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8061 case NestedNameSpecifier::TypeSpec:
8062 case NestedNameSpecifier::TypeSpecWithTemplate: {
8063 bool Template = Record[Idx++];
8064 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8066 return NestedNameSpecifierLoc();
8067 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8069 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8070 Builder.Extend(Context,
8071 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8072 T->getTypeLoc(), ColonColonLoc);
8076 case NestedNameSpecifier::Global: {
8077 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8078 Builder.MakeGlobal(Context, ColonColonLoc);
8082 case NestedNameSpecifier::Super: {
8083 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8084 SourceRange Range = ReadSourceRange(F, Record, Idx);
8085 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8091 return Builder.getWithLocInContext(Context);
8095 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8097 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8098 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8099 return SourceRange(beg, end);
8102 /// \brief Read an integral value
8103 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8104 unsigned BitWidth = Record[Idx++];
8105 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8106 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8111 /// \brief Read a signed integral value
8112 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8113 bool isUnsigned = Record[Idx++];
8114 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8117 /// \brief Read a floating-point value
8118 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8119 const llvm::fltSemantics &Sem,
8121 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8124 // \brief Read a string
8125 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8126 unsigned Len = Record[Idx++];
8127 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8132 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8134 std::string Filename = ReadString(Record, Idx);
8135 ResolveImportedPath(F, Filename);
8139 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8141 unsigned Major = Record[Idx++];
8142 unsigned Minor = Record[Idx++];
8143 unsigned Subminor = Record[Idx++];
8145 return VersionTuple(Major);
8147 return VersionTuple(Major, Minor - 1);
8148 return VersionTuple(Major, Minor - 1, Subminor - 1);
8151 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8152 const RecordData &Record,
8154 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8155 return CXXTemporary::Create(Context, Decl);
8158 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
8159 return Diag(CurrentImportLoc, DiagID);
8162 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8163 return Diags.Report(Loc, DiagID);
8166 /// \brief Retrieve the identifier table associated with the
8168 IdentifierTable &ASTReader::getIdentifierTable() {
8169 return PP.getIdentifierTable();
8172 /// \brief Record that the given ID maps to the given switch-case
8174 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
8175 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8176 "Already have a SwitchCase with this ID");
8177 (*CurrSwitchCaseStmts)[ID] = SC;
8180 /// \brief Retrieve the switch-case statement with the given ID.
8181 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
8182 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8183 return (*CurrSwitchCaseStmts)[ID];
8186 void ASTReader::ClearSwitchCaseIDs() {
8187 CurrSwitchCaseStmts->clear();
8190 void ASTReader::ReadComments() {
8191 std::vector<RawComment *> Comments;
8192 for (SmallVectorImpl<std::pair<BitstreamCursor,
8193 serialization::ModuleFile *> >::iterator
8194 I = CommentsCursors.begin(),
8195 E = CommentsCursors.end();
8198 BitstreamCursor &Cursor = I->first;
8199 serialization::ModuleFile &F = *I->second;
8200 SavedStreamPosition SavedPosition(Cursor);
8204 llvm::BitstreamEntry Entry =
8205 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8207 switch (Entry.Kind) {
8208 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8209 case llvm::BitstreamEntry::Error:
8210 Error("malformed block record in AST file");
8212 case llvm::BitstreamEntry::EndBlock:
8214 case llvm::BitstreamEntry::Record:
8215 // The interesting case.
8221 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8222 case COMMENTS_RAW_COMMENT: {
8224 SourceRange SR = ReadSourceRange(F, Record, Idx);
8225 RawComment::CommentKind Kind =
8226 (RawComment::CommentKind) Record[Idx++];
8227 bool IsTrailingComment = Record[Idx++];
8228 bool IsAlmostTrailingComment = Record[Idx++];
8229 Comments.push_back(new (Context) RawComment(
8230 SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8231 Context.getLangOpts().CommentOpts.ParseAllComments));
8237 Context.Comments.addDeserializedComments(Comments);
8241 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8242 // If we know the owning module, use it.
8243 if (Module *M = D->getImportedOwningModule())
8244 return M->getFullModuleName();
8246 // Otherwise, use the name of the top-level module the decl is within.
8247 if (ModuleFile *M = getOwningModuleFile(D))
8248 return M->ModuleName;
8250 // Not from a module.
8254 void ASTReader::finishPendingActions() {
8255 while (!PendingIdentifierInfos.empty() ||
8256 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8257 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8258 !PendingUpdateRecords.empty()) {
8259 // If any identifiers with corresponding top-level declarations have
8260 // been loaded, load those declarations now.
8261 typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8263 TopLevelDeclsMap TopLevelDecls;
8265 while (!PendingIdentifierInfos.empty()) {
8266 IdentifierInfo *II = PendingIdentifierInfos.back().first;
8267 SmallVector<uint32_t, 4> DeclIDs =
8268 std::move(PendingIdentifierInfos.back().second);
8269 PendingIdentifierInfos.pop_back();
8271 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
8274 // For each decl chain that we wanted to complete while deserializing, mark
8275 // it as "still needs to be completed".
8276 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8277 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8279 PendingIncompleteDeclChains.clear();
8281 // Load pending declaration chains.
8282 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
8283 loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
8284 PendingDeclChains.clear();
8286 // Make the most recent of the top-level declarations visible.
8287 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8288 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
8289 IdentifierInfo *II = TLD->first;
8290 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
8291 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
8295 // Load any pending macro definitions.
8296 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
8297 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8298 SmallVector<PendingMacroInfo, 2> GlobalIDs;
8299 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8300 // Initialize the macro history from chained-PCHs ahead of module imports.
8301 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8303 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8304 if (Info.M->Kind != MK_ImplicitModule &&
8305 Info.M->Kind != MK_ExplicitModule)
8306 resolvePendingMacro(II, Info);
8308 // Handle module imports.
8309 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8311 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8312 if (Info.M->Kind == MK_ImplicitModule ||
8313 Info.M->Kind == MK_ExplicitModule)
8314 resolvePendingMacro(II, Info);
8317 PendingMacroIDs.clear();
8319 // Wire up the DeclContexts for Decls that we delayed setting until
8320 // recursive loading is completed.
8321 while (!PendingDeclContextInfos.empty()) {
8322 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8323 PendingDeclContextInfos.pop_front();
8324 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8325 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8326 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8329 // Perform any pending declaration updates.
8330 while (!PendingUpdateRecords.empty()) {
8331 auto Update = PendingUpdateRecords.pop_back_val();
8332 ReadingKindTracker ReadingKind(Read_Decl, *this);
8333 loadDeclUpdateRecords(Update.first, Update.second);
8337 // At this point, all update records for loaded decls are in place, so any
8338 // fake class definitions should have become real.
8339 assert(PendingFakeDefinitionData.empty() &&
8340 "faked up a class definition but never saw the real one");
8342 // If we deserialized any C++ or Objective-C class definitions, any
8343 // Objective-C protocol definitions, or any redeclarable templates, make sure
8344 // that all redeclarations point to the definitions. Note that this can only
8345 // happen now, after the redeclaration chains have been fully wired.
8346 for (Decl *D : PendingDefinitions) {
8347 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
8348 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
8349 // Make sure that the TagType points at the definition.
8350 const_cast<TagType*>(TagT)->decl = TD;
8353 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
8354 for (auto *R = getMostRecentExistingDecl(RD); R;
8355 R = R->getPreviousDecl()) {
8357 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
8358 "declaration thinks it's the definition but it isn't");
8359 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
8366 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
8367 // Make sure that the ObjCInterfaceType points at the definition.
8368 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8371 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
8372 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
8377 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
8378 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
8379 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
8384 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
8385 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
8386 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
8388 PendingDefinitions.clear();
8390 // Load the bodies of any functions or methods we've encountered. We do
8391 // this now (delayed) so that we can be sure that the declaration chains
8392 // have been fully wired up (hasBody relies on this).
8393 // FIXME: We shouldn't require complete redeclaration chains here.
8394 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8395 PBEnd = PendingBodies.end();
8396 PB != PBEnd; ++PB) {
8397 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8398 // FIXME: Check for =delete/=default?
8399 // FIXME: Complain about ODR violations here?
8400 if (!getContext().getLangOpts().Modules || !FD->hasBody())
8401 FD->setLazyBody(PB->second);
8405 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8406 if (!getContext().getLangOpts().Modules || !MD->hasBody())
8407 MD->setLazyBody(PB->second);
8409 PendingBodies.clear();
8412 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
8413 getContext().deduplicateMergedDefinitonsFor(ND);
8414 PendingMergedDefinitionsToDeduplicate.clear();
8417 void ASTReader::diagnoseOdrViolations() {
8418 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8421 // Trigger the import of the full definition of each class that had any
8422 // odr-merging problems, so we can produce better diagnostics for them.
8423 // These updates may in turn find and diagnose some ODR failures, so take
8424 // ownership of the set first.
8425 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8426 PendingOdrMergeFailures.clear();
8427 for (auto &Merge : OdrMergeFailures) {
8428 Merge.first->buildLookup();
8429 Merge.first->decls_begin();
8430 Merge.first->bases_begin();
8431 Merge.first->vbases_begin();
8432 for (auto *RD : Merge.second) {
8439 // For each declaration from a merged context, check that the canonical
8440 // definition of that context also contains a declaration of the same
8443 // Caution: this loop does things that might invalidate iterators into
8444 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8445 while (!PendingOdrMergeChecks.empty()) {
8446 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8448 // FIXME: Skip over implicit declarations for now. This matters for things
8449 // like implicitly-declared special member functions. This isn't entirely
8450 // correct; we can end up with multiple unmerged declarations of the same
8452 if (D->isImplicit())
8455 DeclContext *CanonDef = D->getDeclContext();
8458 const Decl *DCanon = D->getCanonicalDecl();
8460 for (auto RI : D->redecls()) {
8461 if (RI->getLexicalDeclContext() == CanonDef) {
8469 // Quick check failed, time to do the slow thing. Note, we can't just
8470 // look up the name of D in CanonDef here, because the member that is
8471 // in CanonDef might not be found by name lookup (it might have been
8472 // replaced by a more recent declaration in the lookup table), and we
8473 // can't necessarily find it in the redeclaration chain because it might
8474 // be merely mergeable, not redeclarable.
8475 llvm::SmallVector<const NamedDecl*, 4> Candidates;
8476 for (auto *CanonMember : CanonDef->decls()) {
8477 if (CanonMember->getCanonicalDecl() == DCanon) {
8478 // This can happen if the declaration is merely mergeable and not
8479 // actually redeclarable (we looked for redeclarations earlier).
8481 // FIXME: We should be able to detect this more efficiently, without
8482 // pulling in all of the members of CanonDef.
8486 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
8487 if (ND->getDeclName() == D->getDeclName())
8488 Candidates.push_back(ND);
8492 // The AST doesn't like TagDecls becoming invalid after they've been
8493 // completed. We only really need to mark FieldDecls as invalid here.
8494 if (!isa<TagDecl>(D))
8495 D->setInvalidDecl();
8497 // Ensure we don't accidentally recursively enter deserialization while
8498 // we're producing our diagnostic.
8499 Deserializing RecursionGuard(this);
8501 std::string CanonDefModule =
8502 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8503 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8504 << D << getOwningModuleNameForDiagnostic(D)
8505 << CanonDef << CanonDefModule.empty() << CanonDefModule;
8507 if (Candidates.empty())
8508 Diag(cast<Decl>(CanonDef)->getLocation(),
8509 diag::note_module_odr_violation_no_possible_decls) << D;
8511 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8512 Diag(Candidates[I]->getLocation(),
8513 diag::note_module_odr_violation_possible_decl)
8517 DiagnosedOdrMergeFailures.insert(CanonDef);
8521 if (OdrMergeFailures.empty())
8524 // Ensure we don't accidentally recursively enter deserialization while
8525 // we're producing our diagnostics.
8526 Deserializing RecursionGuard(this);
8528 // Issue any pending ODR-failure diagnostics.
8529 for (auto &Merge : OdrMergeFailures) {
8530 // If we've already pointed out a specific problem with this class, don't
8531 // bother issuing a general "something's different" diagnostic.
8532 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
8535 bool Diagnosed = false;
8536 for (auto *RD : Merge.second) {
8537 // Multiple different declarations got merged together; tell the user
8538 // where they came from.
8539 if (Merge.first != RD) {
8540 // FIXME: Walk the definition, figure out what's different,
8541 // and diagnose that.
8543 std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8544 Diag(Merge.first->getLocation(),
8545 diag::err_module_odr_violation_different_definitions)
8546 << Merge.first << Module.empty() << Module;
8550 Diag(RD->getLocation(),
8551 diag::note_module_odr_violation_different_definitions)
8552 << getOwningModuleNameForDiagnostic(RD);
8557 // All definitions are updates to the same declaration. This happens if a
8558 // module instantiates the declaration of a class template specialization
8559 // and two or more other modules instantiate its definition.
8561 // FIXME: Indicate which modules had instantiations of this definition.
8562 // FIXME: How can this even happen?
8563 Diag(Merge.first->getLocation(),
8564 diag::err_module_odr_violation_different_instantiations)
8570 void ASTReader::StartedDeserializing() {
8571 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
8572 ReadTimer->startTimer();
8575 void ASTReader::FinishedDeserializing() {
8576 assert(NumCurrentElementsDeserializing &&
8577 "FinishedDeserializing not paired with StartedDeserializing");
8578 if (NumCurrentElementsDeserializing == 1) {
8579 // We decrease NumCurrentElementsDeserializing only after pending actions
8580 // are finished, to avoid recursively re-calling finishPendingActions().
8581 finishPendingActions();
8583 --NumCurrentElementsDeserializing;
8585 if (NumCurrentElementsDeserializing == 0) {
8586 // Propagate exception specification updates along redeclaration chains.
8587 while (!PendingExceptionSpecUpdates.empty()) {
8588 auto Updates = std::move(PendingExceptionSpecUpdates);
8589 PendingExceptionSpecUpdates.clear();
8590 for (auto Update : Updates) {
8591 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
8592 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
8593 if (auto *Listener = Context.getASTMutationListener())
8594 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
8595 for (auto *Redecl : Update.second->redecls())
8596 Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
8601 ReadTimer->stopTimer();
8603 diagnoseOdrViolations();
8605 // We are not in recursive loading, so it's safe to pass the "interesting"
8606 // decls to the consumer.
8608 PassInterestingDeclsToConsumer();
8612 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
8613 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
8614 // Remove any fake results before adding any real ones.
8615 auto It = PendingFakeLookupResults.find(II);
8616 if (It != PendingFakeLookupResults.end()) {
8617 for (auto *ND : It->second)
8618 SemaObj->IdResolver.RemoveDecl(ND);
8619 // FIXME: this works around module+PCH performance issue.
8620 // Rather than erase the result from the map, which is O(n), just clear
8621 // the vector of NamedDecls.
8626 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8627 SemaObj->TUScope->AddDecl(D);
8628 } else if (SemaObj->TUScope) {
8629 // Adding the decl to IdResolver may have failed because it was already in
8630 // (even though it was not added in scope). If it is already in, make sure
8631 // it gets in the scope as well.
8632 if (std::find(SemaObj->IdResolver.begin(Name),
8633 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8634 SemaObj->TUScope->AddDecl(D);
8638 ASTReader::ASTReader(
8639 Preprocessor &PP, ASTContext &Context,
8640 const PCHContainerReader &PCHContainerRdr,
8641 ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
8642 StringRef isysroot, bool DisableValidation,
8643 bool AllowASTWithCompilerErrors,
8644 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8645 bool UseGlobalIndex,
8646 std::unique_ptr<llvm::Timer> ReadTimer)
8647 : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
8648 OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
8649 FileMgr(PP.getFileManager()), PCHContainerRdr(PCHContainerRdr),
8650 Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context),
8651 Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerRdr),
8652 ReadTimer(std::move(ReadTimer)),
8653 isysroot(isysroot), DisableValidation(DisableValidation),
8654 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8655 AllowConfigurationMismatch(AllowConfigurationMismatch),
8656 ValidateSystemInputs(ValidateSystemInputs),
8657 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
8658 CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0),
8659 TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0),
8660 NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0),
8661 NumIdentifierLookupHits(0), NumSelectorsRead(0),
8662 NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8663 NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8664 NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8665 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8666 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8667 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
8668 PassingDeclsToConsumer(false), ReadingKind(Read_None) {
8669 SourceMgr.setExternalSLocEntrySource(this);
8671 for (const auto &Ext : Extensions) {
8672 auto BlockName = Ext->getExtensionMetadata().BlockName;
8673 auto Known = ModuleFileExtensions.find(BlockName);
8674 if (Known != ModuleFileExtensions.end()) {
8675 Diags.Report(diag::warn_duplicate_module_file_extension)
8680 ModuleFileExtensions.insert({BlockName, Ext});
8684 ASTReader::~ASTReader() {
8685 if (OwnsDeserializationListener)
8686 delete DeserializationListener;