1 //===-- ASTReader.cpp - AST File Reader -----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTReader class, which reads AST files.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTMutationListener.h"
20 #include "clang/AST/ASTUnresolvedSet.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclGroup.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/Expr.h"
27 #include "clang/AST/ExprCXX.h"
28 #include "clang/AST/NestedNameSpecifier.h"
29 #include "clang/AST/RawCommentList.h"
30 #include "clang/AST/Type.h"
31 #include "clang/AST/TypeLocVisitor.h"
32 #include "clang/AST/UnresolvedSet.h"
33 #include "clang/Basic/CommentOptions.h"
34 #include "clang/Basic/DiagnosticOptions.h"
35 #include "clang/Basic/ExceptionSpecificationType.h"
36 #include "clang/Basic/FileManager.h"
37 #include "clang/Basic/FileSystemOptions.h"
38 #include "clang/Basic/LangOptions.h"
39 #include "clang/Basic/ObjCRuntime.h"
40 #include "clang/Basic/OperatorKinds.h"
41 #include "clang/Basic/Sanitizers.h"
42 #include "clang/Basic/SourceManager.h"
43 #include "clang/Basic/SourceManagerInternals.h"
44 #include "clang/Basic/Specifiers.h"
45 #include "clang/Basic/TargetInfo.h"
46 #include "clang/Basic/TargetOptions.h"
47 #include "clang/Basic/TokenKinds.h"
48 #include "clang/Basic/Version.h"
49 #include "clang/Basic/VersionTuple.h"
50 #include "clang/Frontend/PCHContainerOperations.h"
51 #include "clang/Lex/HeaderSearch.h"
52 #include "clang/Lex/HeaderSearchOptions.h"
53 #include "clang/Lex/MacroInfo.h"
54 #include "clang/Lex/ModuleMap.h"
55 #include "clang/Lex/PreprocessingRecord.h"
56 #include "clang/Lex/Preprocessor.h"
57 #include "clang/Lex/PreprocessorOptions.h"
58 #include "clang/Sema/Scope.h"
59 #include "clang/Sema/Sema.h"
60 #include "clang/Sema/Weak.h"
61 #include "clang/Serialization/ASTDeserializationListener.h"
62 #include "clang/Serialization/GlobalModuleIndex.h"
63 #include "clang/Serialization/ModuleManager.h"
64 #include "clang/Serialization/SerializationDiagnostic.h"
65 #include "llvm/ADT/APFloat.h"
66 #include "llvm/ADT/APInt.h"
67 #include "llvm/ADT/APSInt.h"
68 #include "llvm/ADT/Hashing.h"
69 #include "llvm/ADT/SmallString.h"
70 #include "llvm/ADT/StringExtras.h"
71 #include "llvm/ADT/Triple.h"
72 #include "llvm/Bitcode/BitstreamReader.h"
73 #include "llvm/Support/Compression.h"
74 #include "llvm/Support/Compiler.h"
75 #include "llvm/Support/ErrorHandling.h"
76 #include "llvm/Support/FileSystem.h"
77 #include "llvm/Support/MemoryBuffer.h"
78 #include "llvm/Support/Path.h"
79 #include "llvm/Support/SaveAndRestore.h"
80 #include "llvm/Support/raw_ostream.h"
93 #include <system_error>
98 using namespace clang;
99 using namespace clang::serialization;
100 using namespace clang::serialization::reader;
101 using llvm::BitstreamCursor;
103 //===----------------------------------------------------------------------===//
104 // ChainedASTReaderListener implementation
105 //===----------------------------------------------------------------------===//
108 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
109 return First->ReadFullVersionInformation(FullVersion) ||
110 Second->ReadFullVersionInformation(FullVersion);
113 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
114 First->ReadModuleName(ModuleName);
115 Second->ReadModuleName(ModuleName);
118 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
119 First->ReadModuleMapFile(ModuleMapPath);
120 Second->ReadModuleMapFile(ModuleMapPath);
124 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
126 bool AllowCompatibleDifferences) {
127 return First->ReadLanguageOptions(LangOpts, Complain,
128 AllowCompatibleDifferences) ||
129 Second->ReadLanguageOptions(LangOpts, Complain,
130 AllowCompatibleDifferences);
133 bool ChainedASTReaderListener::ReadTargetOptions(
134 const TargetOptions &TargetOpts, bool Complain,
135 bool AllowCompatibleDifferences) {
136 return First->ReadTargetOptions(TargetOpts, Complain,
137 AllowCompatibleDifferences) ||
138 Second->ReadTargetOptions(TargetOpts, Complain,
139 AllowCompatibleDifferences);
142 bool ChainedASTReaderListener::ReadDiagnosticOptions(
143 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
144 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
145 Second->ReadDiagnosticOptions(DiagOpts, Complain);
149 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
151 return First->ReadFileSystemOptions(FSOpts, Complain) ||
152 Second->ReadFileSystemOptions(FSOpts, Complain);
155 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
156 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
158 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
160 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
164 bool ChainedASTReaderListener::ReadPreprocessorOptions(
165 const PreprocessorOptions &PPOpts, bool Complain,
166 std::string &SuggestedPredefines) {
167 return First->ReadPreprocessorOptions(PPOpts, Complain,
168 SuggestedPredefines) ||
169 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
171 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
173 First->ReadCounter(M, Value);
174 Second->ReadCounter(M, Value);
176 bool ChainedASTReaderListener::needsInputFileVisitation() {
177 return First->needsInputFileVisitation() ||
178 Second->needsInputFileVisitation();
180 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
181 return First->needsSystemInputFileVisitation() ||
182 Second->needsSystemInputFileVisitation();
184 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
186 First->visitModuleFile(Filename, Kind);
187 Second->visitModuleFile(Filename, Kind);
190 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
193 bool isExplicitModule) {
194 bool Continue = false;
195 if (First->needsInputFileVisitation() &&
196 (!isSystem || First->needsSystemInputFileVisitation()))
197 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
199 if (Second->needsInputFileVisitation() &&
200 (!isSystem || Second->needsSystemInputFileVisitation()))
201 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
206 void ChainedASTReaderListener::readModuleFileExtension(
207 const ModuleFileExtensionMetadata &Metadata) {
208 First->readModuleFileExtension(Metadata);
209 Second->readModuleFileExtension(Metadata);
212 //===----------------------------------------------------------------------===//
213 // PCH validator implementation
214 //===----------------------------------------------------------------------===//
216 ASTReaderListener::~ASTReaderListener() {}
218 /// \brief Compare the given set of language options against an existing set of
219 /// language options.
221 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
222 /// \param AllowCompatibleDifferences If true, differences between compatible
223 /// language options will be permitted.
225 /// \returns true if the languagae options mis-match, false otherwise.
226 static bool checkLanguageOptions(const LangOptions &LangOpts,
227 const LangOptions &ExistingLangOpts,
228 DiagnosticsEngine *Diags,
229 bool AllowCompatibleDifferences = true) {
230 #define LANGOPT(Name, Bits, Default, Description) \
231 if (ExistingLangOpts.Name != LangOpts.Name) { \
233 Diags->Report(diag::err_pch_langopt_mismatch) \
234 << Description << LangOpts.Name << ExistingLangOpts.Name; \
238 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
239 if (ExistingLangOpts.Name != LangOpts.Name) { \
241 Diags->Report(diag::err_pch_langopt_value_mismatch) \
246 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
247 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
249 Diags->Report(diag::err_pch_langopt_value_mismatch) \
254 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
255 if (!AllowCompatibleDifferences) \
256 LANGOPT(Name, Bits, Default, Description)
258 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
259 if (!AllowCompatibleDifferences) \
260 ENUM_LANGOPT(Name, Bits, Default, Description)
262 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
263 if (!AllowCompatibleDifferences) \
264 VALUE_LANGOPT(Name, Bits, Default, Description)
266 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
267 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
268 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
269 #include "clang/Basic/LangOptions.def"
271 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
273 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
277 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
279 Diags->Report(diag::err_pch_langopt_value_mismatch)
280 << "target Objective-C runtime";
284 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
285 LangOpts.CommentOpts.BlockCommandNames) {
287 Diags->Report(diag::err_pch_langopt_value_mismatch)
288 << "block command names";
295 /// \brief Compare the given set of target options against an existing set of
298 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
300 /// \returns true if the target options mis-match, false otherwise.
301 static bool checkTargetOptions(const TargetOptions &TargetOpts,
302 const TargetOptions &ExistingTargetOpts,
303 DiagnosticsEngine *Diags,
304 bool AllowCompatibleDifferences = true) {
305 #define CHECK_TARGET_OPT(Field, Name) \
306 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
308 Diags->Report(diag::err_pch_targetopt_mismatch) \
309 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
313 // The triple and ABI must match exactly.
314 CHECK_TARGET_OPT(Triple, "target");
315 CHECK_TARGET_OPT(ABI, "target ABI");
317 // We can tolerate different CPUs in many cases, notably when one CPU
318 // supports a strict superset of another. When allowing compatible
319 // differences skip this check.
320 if (!AllowCompatibleDifferences)
321 CHECK_TARGET_OPT(CPU, "target CPU");
323 #undef CHECK_TARGET_OPT
325 // Compare feature sets.
326 SmallVector<StringRef, 4> ExistingFeatures(
327 ExistingTargetOpts.FeaturesAsWritten.begin(),
328 ExistingTargetOpts.FeaturesAsWritten.end());
329 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
330 TargetOpts.FeaturesAsWritten.end());
331 std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
332 std::sort(ReadFeatures.begin(), ReadFeatures.end());
334 // We compute the set difference in both directions explicitly so that we can
335 // diagnose the differences differently.
336 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
338 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
339 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
340 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
341 ExistingFeatures.begin(), ExistingFeatures.end(),
342 std::back_inserter(UnmatchedReadFeatures));
344 // If we are allowing compatible differences and the read feature set is
345 // a strict subset of the existing feature set, there is nothing to diagnose.
346 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
350 for (StringRef Feature : UnmatchedReadFeatures)
351 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
352 << /* is-existing-feature */ false << Feature;
353 for (StringRef Feature : UnmatchedExistingFeatures)
354 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
355 << /* is-existing-feature */ true << Feature;
358 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
362 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
364 bool AllowCompatibleDifferences) {
365 const LangOptions &ExistingLangOpts = PP.getLangOpts();
366 return checkLanguageOptions(LangOpts, ExistingLangOpts,
367 Complain ? &Reader.Diags : nullptr,
368 AllowCompatibleDifferences);
371 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
373 bool AllowCompatibleDifferences) {
374 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
375 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
376 Complain ? &Reader.Diags : nullptr,
377 AllowCompatibleDifferences);
382 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
384 typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
387 } // end anonymous namespace
389 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
390 DiagnosticsEngine &Diags,
392 typedef DiagnosticsEngine::Level Level;
394 // Check current mappings for new -Werror mappings, and the stored mappings
395 // for cases that were explicitly mapped to *not* be errors that are now
396 // errors because of options like -Werror.
397 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
399 for (DiagnosticsEngine *MappingSource : MappingSources) {
400 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
401 diag::kind DiagID = DiagIDMappingPair.first;
402 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
403 if (CurLevel < DiagnosticsEngine::Error)
404 continue; // not significant
406 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
407 if (StoredLevel < DiagnosticsEngine::Error) {
409 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
410 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
419 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
420 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
421 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
423 return Ext >= diag::Severity::Error;
426 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
427 DiagnosticsEngine &Diags,
428 bool IsSystem, bool Complain) {
431 if (Diags.getSuppressSystemWarnings())
433 // If -Wsystem-headers was not enabled before, be conservative
434 if (StoredDiags.getSuppressSystemWarnings()) {
436 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
441 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
443 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
447 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
448 !StoredDiags.getEnableAllWarnings()) {
450 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
454 if (isExtHandlingFromDiagsError(Diags) &&
455 !isExtHandlingFromDiagsError(StoredDiags)) {
457 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
461 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
464 bool PCHValidator::ReadDiagnosticOptions(
465 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
466 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
467 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
468 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
469 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
470 // This should never fail, because we would have processed these options
471 // before writing them to an ASTFile.
472 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
474 ModuleManager &ModuleMgr = Reader.getModuleManager();
475 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
477 // If the original import came from a file explicitly generated by the user,
478 // don't check the diagnostic mappings.
479 // FIXME: currently this is approximated by checking whether this is not a
480 // module import of an implicitly-loaded module file.
481 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
482 // the transitive closure of its imports, since unrelated modules cannot be
483 // imported until after this module finishes validation.
484 ModuleFile *TopImport = *ModuleMgr.rbegin();
485 while (!TopImport->ImportedBy.empty())
486 TopImport = TopImport->ImportedBy[0];
487 if (TopImport->Kind != MK_ImplicitModule)
490 StringRef ModuleName = TopImport->ModuleName;
491 assert(!ModuleName.empty() && "diagnostic options read before module name");
493 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
494 assert(M && "missing module");
496 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
497 // contains the union of their flags.
498 return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
501 /// \brief Collect the macro definitions provided by the given preprocessor
504 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
505 MacroDefinitionsMap &Macros,
506 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
507 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
508 StringRef Macro = PPOpts.Macros[I].first;
509 bool IsUndef = PPOpts.Macros[I].second;
511 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
512 StringRef MacroName = MacroPair.first;
513 StringRef MacroBody = MacroPair.second;
515 // For an #undef'd macro, we only care about the name.
517 if (MacroNames && !Macros.count(MacroName))
518 MacroNames->push_back(MacroName);
520 Macros[MacroName] = std::make_pair("", true);
524 // For a #define'd macro, figure out the actual definition.
525 if (MacroName.size() == Macro.size())
528 // Note: GCC drops anything following an end-of-line character.
529 StringRef::size_type End = MacroBody.find_first_of("\n\r");
530 MacroBody = MacroBody.substr(0, End);
533 if (MacroNames && !Macros.count(MacroName))
534 MacroNames->push_back(MacroName);
535 Macros[MacroName] = std::make_pair(MacroBody, false);
539 /// \brief Check the preprocessor options deserialized from the control block
540 /// against the preprocessor options in an existing preprocessor.
542 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
543 /// \param Validate If true, validate preprocessor options. If false, allow
544 /// macros defined by \p ExistingPPOpts to override those defined by
545 /// \p PPOpts in SuggestedPredefines.
546 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
547 const PreprocessorOptions &ExistingPPOpts,
548 DiagnosticsEngine *Diags,
549 FileManager &FileMgr,
550 std::string &SuggestedPredefines,
551 const LangOptions &LangOpts,
552 bool Validate = true) {
553 // Check macro definitions.
554 MacroDefinitionsMap ASTFileMacros;
555 collectMacroDefinitions(PPOpts, ASTFileMacros);
556 MacroDefinitionsMap ExistingMacros;
557 SmallVector<StringRef, 4> ExistingMacroNames;
558 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
560 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
561 // Dig out the macro definition in the existing preprocessor options.
562 StringRef MacroName = ExistingMacroNames[I];
563 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
565 // Check whether we know anything about this macro name or not.
566 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
567 = ASTFileMacros.find(MacroName);
568 if (!Validate || Known == ASTFileMacros.end()) {
569 // FIXME: Check whether this identifier was referenced anywhere in the
570 // AST file. If so, we should reject the AST file. Unfortunately, this
571 // information isn't in the control block. What shall we do about it?
573 if (Existing.second) {
574 SuggestedPredefines += "#undef ";
575 SuggestedPredefines += MacroName.str();
576 SuggestedPredefines += '\n';
578 SuggestedPredefines += "#define ";
579 SuggestedPredefines += MacroName.str();
580 SuggestedPredefines += ' ';
581 SuggestedPredefines += Existing.first.str();
582 SuggestedPredefines += '\n';
587 // If the macro was defined in one but undef'd in the other, we have a
589 if (Existing.second != Known->second.second) {
591 Diags->Report(diag::err_pch_macro_def_undef)
592 << MacroName << Known->second.second;
597 // If the macro was #undef'd in both, or if the macro bodies are identical,
599 if (Existing.second || Existing.first == Known->second.first)
602 // The macro bodies differ; complain.
604 Diags->Report(diag::err_pch_macro_def_conflict)
605 << MacroName << Known->second.first << Existing.first;
610 // Check whether we're using predefines.
611 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
613 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
618 // Detailed record is important since it is used for the module cache hash.
619 if (LangOpts.Modules &&
620 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
622 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
627 // Compute the #include and #include_macros lines we need.
628 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
629 StringRef File = ExistingPPOpts.Includes[I];
630 if (File == ExistingPPOpts.ImplicitPCHInclude)
633 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
634 != PPOpts.Includes.end())
637 SuggestedPredefines += "#include \"";
638 SuggestedPredefines += File;
639 SuggestedPredefines += "\"\n";
642 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
643 StringRef File = ExistingPPOpts.MacroIncludes[I];
644 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
646 != PPOpts.MacroIncludes.end())
649 SuggestedPredefines += "#__include_macros \"";
650 SuggestedPredefines += File;
651 SuggestedPredefines += "\"\n##\n";
657 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
659 std::string &SuggestedPredefines) {
660 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
662 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
663 Complain? &Reader.Diags : nullptr,
669 bool SimpleASTReaderListener::ReadPreprocessorOptions(
670 const PreprocessorOptions &PPOpts,
672 std::string &SuggestedPredefines) {
673 return checkPreprocessorOptions(PPOpts,
674 PP.getPreprocessorOpts(),
682 /// Check the header search options deserialized from the control block
683 /// against the header search options in an existing preprocessor.
685 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
686 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
687 StringRef SpecificModuleCachePath,
688 StringRef ExistingModuleCachePath,
689 DiagnosticsEngine *Diags,
690 const LangOptions &LangOpts) {
691 if (LangOpts.Modules) {
692 if (SpecificModuleCachePath != ExistingModuleCachePath) {
694 Diags->Report(diag::err_pch_modulecache_mismatch)
695 << SpecificModuleCachePath << ExistingModuleCachePath;
703 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
704 StringRef SpecificModuleCachePath,
706 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
707 PP.getHeaderSearchInfo().getModuleCachePath(),
708 Complain ? &Reader.Diags : nullptr,
712 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
713 PP.setCounterValue(Value);
716 //===----------------------------------------------------------------------===//
717 // AST reader implementation
718 //===----------------------------------------------------------------------===//
720 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
721 bool TakeOwnership) {
722 DeserializationListener = Listener;
723 OwnsDeserializationListener = TakeOwnership;
726 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
727 return serialization::ComputeHash(Sel);
730 std::pair<unsigned, unsigned>
731 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
732 using namespace llvm::support;
733 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
734 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
735 return std::make_pair(KeyLen, DataLen);
738 ASTSelectorLookupTrait::internal_key_type
739 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
740 using namespace llvm::support;
741 SelectorTable &SelTable = Reader.getContext().Selectors;
742 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
743 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
744 F, endian::readNext<uint32_t, little, unaligned>(d));
746 return SelTable.getNullarySelector(FirstII);
748 return SelTable.getUnarySelector(FirstII);
750 SmallVector<IdentifierInfo *, 16> Args;
751 Args.push_back(FirstII);
752 for (unsigned I = 1; I != N; ++I)
753 Args.push_back(Reader.getLocalIdentifier(
754 F, endian::readNext<uint32_t, little, unaligned>(d)));
756 return SelTable.getSelector(N, Args.data());
759 ASTSelectorLookupTrait::data_type
760 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
762 using namespace llvm::support;
766 Result.ID = Reader.getGlobalSelectorID(
767 F, endian::readNext<uint32_t, little, unaligned>(d));
768 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
769 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
770 Result.InstanceBits = FullInstanceBits & 0x3;
771 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
772 Result.FactoryBits = FullFactoryBits & 0x3;
773 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
774 unsigned NumInstanceMethods = FullInstanceBits >> 3;
775 unsigned NumFactoryMethods = FullFactoryBits >> 3;
777 // Load instance methods
778 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
779 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
780 F, endian::readNext<uint32_t, little, unaligned>(d)))
781 Result.Instance.push_back(Method);
784 // Load factory methods
785 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
786 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
787 F, endian::readNext<uint32_t, little, unaligned>(d)))
788 Result.Factory.push_back(Method);
794 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
795 return llvm::HashString(a);
798 std::pair<unsigned, unsigned>
799 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
800 using namespace llvm::support;
801 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
802 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
803 return std::make_pair(KeyLen, DataLen);
806 ASTIdentifierLookupTraitBase::internal_key_type
807 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
808 assert(n >= 2 && d[n-1] == '\0');
809 return StringRef((const char*) d, n-1);
812 /// \brief Whether the given identifier is "interesting".
813 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
815 return II.hadMacroDefinition() ||
817 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
818 II.hasRevertedTokenIDToIdentifier() ||
819 (!(IsModule && Reader.getContext().getLangOpts().CPlusPlus) &&
820 II.getFETokenInfo<void>());
823 static bool readBit(unsigned &Bits) {
824 bool Value = Bits & 0x1;
829 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
830 using namespace llvm::support;
831 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
832 return Reader.getGlobalIdentifierID(F, RawID >> 1);
835 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
836 if (!II.isFromAST()) {
838 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
839 if (isInterestingIdentifier(Reader, II, IsModule))
840 II.setChangedSinceDeserialization();
844 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
845 const unsigned char* d,
847 using namespace llvm::support;
848 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
849 bool IsInteresting = RawID & 0x01;
851 // Wipe out the "is interesting" bit.
854 // Build the IdentifierInfo and link the identifier ID with it.
855 IdentifierInfo *II = KnownII;
857 II = &Reader.getIdentifierTable().getOwn(k);
860 markIdentifierFromAST(Reader, *II);
861 Reader.markIdentifierUpToDate(II);
863 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
864 if (!IsInteresting) {
865 // For uninteresting identifiers, there's nothing else to do. Just notify
866 // the reader that we've finished loading this identifier.
867 Reader.SetIdentifierInfo(ID, II);
871 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
872 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
873 bool CPlusPlusOperatorKeyword = readBit(Bits);
874 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
875 bool HasRevertedBuiltin = readBit(Bits);
876 bool Poisoned = readBit(Bits);
877 bool ExtensionToken = readBit(Bits);
878 bool HadMacroDefinition = readBit(Bits);
880 assert(Bits == 0 && "Extra bits in the identifier?");
883 // Set or check the various bits in the IdentifierInfo structure.
884 // Token IDs are read-only.
885 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
886 II->revertTokenIDToIdentifier();
888 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
889 else if (HasRevertedBuiltin && II->getBuiltinID()) {
891 assert((II->hasRevertedBuiltin() ||
892 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
893 "Incorrect ObjC keyword or builtin ID");
895 assert(II->isExtensionToken() == ExtensionToken &&
896 "Incorrect extension token flag");
897 (void)ExtensionToken;
899 II->setIsPoisoned(true);
900 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
901 "Incorrect C++ operator keyword flag");
902 (void)CPlusPlusOperatorKeyword;
904 // If this identifier is a macro, deserialize the macro
906 if (HadMacroDefinition) {
907 uint32_t MacroDirectivesOffset =
908 endian::readNext<uint32_t, little, unaligned>(d);
911 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
914 Reader.SetIdentifierInfo(ID, II);
916 // Read all of the declarations visible at global scope with this
919 SmallVector<uint32_t, 4> DeclIDs;
920 for (; DataLen > 0; DataLen -= 4)
921 DeclIDs.push_back(Reader.getGlobalDeclID(
922 F, endian::readNext<uint32_t, little, unaligned>(d)));
923 Reader.SetGloballyVisibleDecls(II, DeclIDs);
929 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
930 : Kind(Name.getNameKind()) {
932 case DeclarationName::Identifier:
933 Data = (uint64_t)Name.getAsIdentifierInfo();
935 case DeclarationName::ObjCZeroArgSelector:
936 case DeclarationName::ObjCOneArgSelector:
937 case DeclarationName::ObjCMultiArgSelector:
938 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
940 case DeclarationName::CXXOperatorName:
941 Data = Name.getCXXOverloadedOperator();
943 case DeclarationName::CXXLiteralOperatorName:
944 Data = (uint64_t)Name.getCXXLiteralIdentifier();
946 case DeclarationName::CXXConstructorName:
947 case DeclarationName::CXXDestructorName:
948 case DeclarationName::CXXConversionFunctionName:
949 case DeclarationName::CXXUsingDirective:
955 unsigned DeclarationNameKey::getHash() const {
956 llvm::FoldingSetNodeID ID;
960 case DeclarationName::Identifier:
961 case DeclarationName::CXXLiteralOperatorName:
962 ID.AddString(((IdentifierInfo*)Data)->getName());
964 case DeclarationName::ObjCZeroArgSelector:
965 case DeclarationName::ObjCOneArgSelector:
966 case DeclarationName::ObjCMultiArgSelector:
967 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
969 case DeclarationName::CXXOperatorName:
970 ID.AddInteger((OverloadedOperatorKind)Data);
972 case DeclarationName::CXXConstructorName:
973 case DeclarationName::CXXDestructorName:
974 case DeclarationName::CXXConversionFunctionName:
975 case DeclarationName::CXXUsingDirective:
979 return ID.ComputeHash();
983 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
984 using namespace llvm::support;
985 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
986 return Reader.getLocalModuleFile(F, ModuleFileID);
989 std::pair<unsigned, unsigned>
990 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
991 using namespace llvm::support;
992 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
993 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
994 return std::make_pair(KeyLen, DataLen);
997 ASTDeclContextNameLookupTrait::internal_key_type
998 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
999 using namespace llvm::support;
1001 auto Kind = (DeclarationName::NameKind)*d++;
1004 case DeclarationName::Identifier:
1005 Data = (uint64_t)Reader.getLocalIdentifier(
1006 F, endian::readNext<uint32_t, little, unaligned>(d));
1008 case DeclarationName::ObjCZeroArgSelector:
1009 case DeclarationName::ObjCOneArgSelector:
1010 case DeclarationName::ObjCMultiArgSelector:
1012 (uint64_t)Reader.getLocalSelector(
1013 F, endian::readNext<uint32_t, little, unaligned>(
1014 d)).getAsOpaquePtr();
1016 case DeclarationName::CXXOperatorName:
1017 Data = *d++; // OverloadedOperatorKind
1019 case DeclarationName::CXXLiteralOperatorName:
1020 Data = (uint64_t)Reader.getLocalIdentifier(
1021 F, endian::readNext<uint32_t, little, unaligned>(d));
1023 case DeclarationName::CXXConstructorName:
1024 case DeclarationName::CXXDestructorName:
1025 case DeclarationName::CXXConversionFunctionName:
1026 case DeclarationName::CXXUsingDirective:
1031 return DeclarationNameKey(Kind, Data);
1034 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1035 const unsigned char *d,
1037 data_type_builder &Val) {
1038 using namespace llvm::support;
1039 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1040 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1041 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1045 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1046 BitstreamCursor &Cursor,
1049 assert(Offset != 0);
1051 SavedStreamPosition SavedPosition(Cursor);
1052 Cursor.JumpToBit(Offset);
1056 unsigned Code = Cursor.ReadCode();
1057 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1058 if (RecCode != DECL_CONTEXT_LEXICAL) {
1059 Error("Expected lexical block");
1063 assert(!isa<TranslationUnitDecl>(DC) &&
1064 "expected a TU_UPDATE_LEXICAL record for TU");
1065 // If we are handling a C++ class template instantiation, we can see multiple
1066 // lexical updates for the same record. It's important that we select only one
1067 // of them, so that field numbering works properly. Just pick the first one we
1069 auto &Lex = LexicalDecls[DC];
1071 Lex = std::make_pair(
1072 &M, llvm::makeArrayRef(
1073 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1077 DC->setHasExternalLexicalStorage(true);
1081 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1082 BitstreamCursor &Cursor,
1085 assert(Offset != 0);
1087 SavedStreamPosition SavedPosition(Cursor);
1088 Cursor.JumpToBit(Offset);
1092 unsigned Code = Cursor.ReadCode();
1093 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1094 if (RecCode != DECL_CONTEXT_VISIBLE) {
1095 Error("Expected visible lookup table block");
1099 // We can't safely determine the primary context yet, so delay attaching the
1100 // lookup table until we're done with recursive deserialization.
1101 auto *Data = (const unsigned char*)Blob.data();
1102 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1106 void ASTReader::Error(StringRef Msg) {
1107 Error(diag::err_fe_pch_malformed, Msg);
1108 if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1109 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1110 Diag(diag::note_module_cache_path)
1111 << PP.getHeaderSearchInfo().getModuleCachePath();
1115 void ASTReader::Error(unsigned DiagID,
1116 StringRef Arg1, StringRef Arg2) {
1117 if (Diags.isDiagnosticInFlight())
1118 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1120 Diag(DiagID) << Arg1 << Arg2;
1123 //===----------------------------------------------------------------------===//
1124 // Source Manager Deserialization
1125 //===----------------------------------------------------------------------===//
1127 /// \brief Read the line table in the source manager block.
1128 /// \returns true if there was an error.
1129 bool ASTReader::ParseLineTable(ModuleFile &F,
1130 const RecordData &Record) {
1132 LineTableInfo &LineTable = SourceMgr.getLineTable();
1134 // Parse the file names
1135 std::map<int, int> FileIDs;
1136 for (unsigned I = 0; Record[Idx]; ++I) {
1137 // Extract the file name
1138 auto Filename = ReadPath(F, Record, Idx);
1139 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1143 // Parse the line entries
1144 std::vector<LineEntry> Entries;
1145 while (Idx < Record.size()) {
1146 int FID = Record[Idx++];
1147 assert(FID >= 0 && "Serialized line entries for non-local file.");
1148 // Remap FileID from 1-based old view.
1149 FID += F.SLocEntryBaseID - 1;
1151 // Extract the line entries
1152 unsigned NumEntries = Record[Idx++];
1153 assert(NumEntries && "no line entries for file ID");
1155 Entries.reserve(NumEntries);
1156 for (unsigned I = 0; I != NumEntries; ++I) {
1157 unsigned FileOffset = Record[Idx++];
1158 unsigned LineNo = Record[Idx++];
1159 int FilenameID = FileIDs[Record[Idx++]];
1160 SrcMgr::CharacteristicKind FileKind
1161 = (SrcMgr::CharacteristicKind)Record[Idx++];
1162 unsigned IncludeOffset = Record[Idx++];
1163 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1164 FileKind, IncludeOffset));
1166 LineTable.AddEntry(FileID::get(FID), Entries);
1172 /// \brief Read a source manager block
1173 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1174 using namespace SrcMgr;
1176 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1178 // Set the source-location entry cursor to the current position in
1179 // the stream. This cursor will be used to read the contents of the
1180 // source manager block initially, and then lazily read
1181 // source-location entries as needed.
1182 SLocEntryCursor = F.Stream;
1184 // The stream itself is going to skip over the source manager block.
1185 if (F.Stream.SkipBlock()) {
1186 Error("malformed block record in AST file");
1190 // Enter the source manager block.
1191 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1192 Error("malformed source manager block record in AST file");
1198 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1201 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1202 case llvm::BitstreamEntry::Error:
1203 Error("malformed block record in AST file");
1205 case llvm::BitstreamEntry::EndBlock:
1207 case llvm::BitstreamEntry::Record:
1208 // The interesting case.
1215 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1216 default: // Default behavior: ignore.
1219 case SM_SLOC_FILE_ENTRY:
1220 case SM_SLOC_BUFFER_ENTRY:
1221 case SM_SLOC_EXPANSION_ENTRY:
1222 // Once we hit one of the source location entries, we're done.
1228 /// \brief If a header file is not found at the path that we expect it to be
1229 /// and the PCH file was moved from its original location, try to resolve the
1230 /// file by assuming that header+PCH were moved together and the header is in
1231 /// the same place relative to the PCH.
1233 resolveFileRelativeToOriginalDir(const std::string &Filename,
1234 const std::string &OriginalDir,
1235 const std::string &CurrDir) {
1236 assert(OriginalDir != CurrDir &&
1237 "No point trying to resolve the file if the PCH dir didn't change");
1238 using namespace llvm::sys;
1239 SmallString<128> filePath(Filename);
1240 fs::make_absolute(filePath);
1241 assert(path::is_absolute(OriginalDir));
1242 SmallString<128> currPCHPath(CurrDir);
1244 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1245 fileDirE = path::end(path::parent_path(filePath));
1246 path::const_iterator origDirI = path::begin(OriginalDir),
1247 origDirE = path::end(OriginalDir);
1248 // Skip the common path components from filePath and OriginalDir.
1249 while (fileDirI != fileDirE && origDirI != origDirE &&
1250 *fileDirI == *origDirI) {
1254 for (; origDirI != origDirE; ++origDirI)
1255 path::append(currPCHPath, "..");
1256 path::append(currPCHPath, fileDirI, fileDirE);
1257 path::append(currPCHPath, path::filename(Filename));
1258 return currPCHPath.str();
1261 bool ASTReader::ReadSLocEntry(int ID) {
1265 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1266 Error("source location entry ID out-of-range for AST file");
1270 // Local helper to read the (possibly-compressed) buffer data following the
1272 auto ReadBuffer = [this](
1273 BitstreamCursor &SLocEntryCursor,
1274 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1277 unsigned Code = SLocEntryCursor.ReadCode();
1278 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1280 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1281 SmallString<0> Uncompressed;
1282 if (llvm::zlib::uncompress(Blob, Uncompressed, Record[0]) !=
1283 llvm::zlib::StatusOK) {
1284 Error("could not decompress embedded file contents");
1287 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1288 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1289 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1291 Error("AST record has invalid code");
1296 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1297 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1298 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1299 unsigned BaseOffset = F->SLocEntryBaseOffset;
1301 ++NumSLocEntriesRead;
1302 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1303 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1304 Error("incorrectly-formatted source location entry in AST file");
1310 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1312 Error("incorrectly-formatted source location entry in AST file");
1315 case SM_SLOC_FILE_ENTRY: {
1316 // We will detect whether a file changed and return 'Failure' for it, but
1317 // we will also try to fail gracefully by setting up the SLocEntry.
1318 unsigned InputID = Record[4];
1319 InputFile IF = getInputFile(*F, InputID);
1320 const FileEntry *File = IF.getFile();
1321 bool OverriddenBuffer = IF.isOverridden();
1323 // Note that we only check if a File was returned. If it was out-of-date
1324 // we have complained but we will continue creating a FileID to recover
1329 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1330 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1331 // This is the module's main file.
1332 IncludeLoc = getImportLocation(F);
1334 SrcMgr::CharacteristicKind
1335 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1336 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1337 ID, BaseOffset + Record[0]);
1338 SrcMgr::FileInfo &FileInfo =
1339 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1340 FileInfo.NumCreatedFIDs = Record[5];
1342 FileInfo.setHasLineDirectives();
1344 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1345 unsigned NumFileDecls = Record[7];
1347 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1348 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1352 const SrcMgr::ContentCache *ContentCache
1353 = SourceMgr.getOrCreateContentCache(File,
1354 /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
1355 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1356 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1357 !ContentCache->getRawBuffer()) {
1358 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1361 SourceMgr.overrideFileContents(File, std::move(Buffer));
1367 case SM_SLOC_BUFFER_ENTRY: {
1368 const char *Name = Blob.data();
1369 unsigned Offset = Record[0];
1370 SrcMgr::CharacteristicKind
1371 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1372 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1373 if (IncludeLoc.isInvalid() && F->isModule()) {
1374 IncludeLoc = getImportLocation(F);
1377 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1380 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1381 BaseOffset + Offset, IncludeLoc);
1385 case SM_SLOC_EXPANSION_ENTRY: {
1386 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1387 SourceMgr.createExpansionLoc(SpellingLoc,
1388 ReadSourceLocation(*F, Record[2]),
1389 ReadSourceLocation(*F, Record[3]),
1392 BaseOffset + Record[0]);
1400 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1402 return std::make_pair(SourceLocation(), "");
1404 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1405 Error("source location entry ID out-of-range for AST file");
1406 return std::make_pair(SourceLocation(), "");
1409 // Find which module file this entry lands in.
1410 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1412 return std::make_pair(SourceLocation(), "");
1414 // FIXME: Can we map this down to a particular submodule? That would be
1416 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1419 /// \brief Find the location where the module F is imported.
1420 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1421 if (F->ImportLoc.isValid())
1422 return F->ImportLoc;
1424 // Otherwise we have a PCH. It's considered to be "imported" at the first
1425 // location of its includer.
1426 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1427 // Main file is the importer.
1428 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1429 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1431 return F->ImportedBy[0]->FirstLoc;
1434 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1435 /// specified cursor. Read the abbreviations that are at the top of the block
1436 /// and then leave the cursor pointing into the block.
1437 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1438 if (Cursor.EnterSubBlock(BlockID))
1442 uint64_t Offset = Cursor.GetCurrentBitNo();
1443 unsigned Code = Cursor.ReadCode();
1445 // We expect all abbrevs to be at the start of the block.
1446 if (Code != llvm::bitc::DEFINE_ABBREV) {
1447 Cursor.JumpToBit(Offset);
1450 Cursor.ReadAbbrevRecord();
1454 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1458 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1459 Tok.setLength(Record[Idx++]);
1460 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1461 Tok.setIdentifierInfo(II);
1462 Tok.setKind((tok::TokenKind)Record[Idx++]);
1463 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1467 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1468 BitstreamCursor &Stream = F.MacroCursor;
1470 // Keep track of where we are in the stream, then jump back there
1471 // after reading this macro.
1472 SavedStreamPosition SavedPosition(Stream);
1474 Stream.JumpToBit(Offset);
1476 SmallVector<IdentifierInfo*, 16> MacroArgs;
1477 MacroInfo *Macro = nullptr;
1480 // Advance to the next record, but if we get to the end of the block, don't
1481 // pop it (removing all the abbreviations from the cursor) since we want to
1482 // be able to reseek within the block and read entries.
1483 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1484 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1486 switch (Entry.Kind) {
1487 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1488 case llvm::BitstreamEntry::Error:
1489 Error("malformed block record in AST file");
1491 case llvm::BitstreamEntry::EndBlock:
1493 case llvm::BitstreamEntry::Record:
1494 // The interesting case.
1500 PreprocessorRecordTypes RecType =
1501 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1503 case PP_MODULE_MACRO:
1504 case PP_MACRO_DIRECTIVE_HISTORY:
1507 case PP_MACRO_OBJECT_LIKE:
1508 case PP_MACRO_FUNCTION_LIKE: {
1509 // If we already have a macro, that means that we've hit the end
1510 // of the definition of the macro we were looking for. We're
1515 unsigned NextIndex = 1; // Skip identifier ID.
1516 SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
1517 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1518 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
1519 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1520 MI->setIsUsed(Record[NextIndex++]);
1521 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1523 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1524 // Decode function-like macro info.
1525 bool isC99VarArgs = Record[NextIndex++];
1526 bool isGNUVarArgs = Record[NextIndex++];
1527 bool hasCommaPasting = Record[NextIndex++];
1529 unsigned NumArgs = Record[NextIndex++];
1530 for (unsigned i = 0; i != NumArgs; ++i)
1531 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1533 // Install function-like macro info.
1534 MI->setIsFunctionLike();
1535 if (isC99VarArgs) MI->setIsC99Varargs();
1536 if (isGNUVarArgs) MI->setIsGNUVarargs();
1537 if (hasCommaPasting) MI->setHasCommaPasting();
1538 MI->setArgumentList(MacroArgs, PP.getPreprocessorAllocator());
1541 // Remember that we saw this macro last so that we add the tokens that
1542 // form its body to it.
1545 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1546 Record[NextIndex]) {
1547 // We have a macro definition. Register the association
1548 PreprocessedEntityID
1549 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1550 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1551 PreprocessingRecord::PPEntityID PPID =
1552 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1553 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1554 PPRec.getPreprocessedEntity(PPID));
1556 PPRec.RegisterMacroDefinition(Macro, PPDef);
1564 // If we see a TOKEN before a PP_MACRO_*, then the file is
1565 // erroneous, just pretend we didn't see this.
1569 Token Tok = ReadToken(F, Record, Idx);
1570 Macro->AddTokenToBody(Tok);
1577 PreprocessedEntityID
1578 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1579 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1580 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1581 assert(I != M.PreprocessedEntityRemap.end()
1582 && "Invalid index into preprocessed entity index remap");
1584 return LocalID + I->second;
1587 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1588 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1591 HeaderFileInfoTrait::internal_key_type
1592 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1593 internal_key_type ikey = {FE->getSize(),
1594 M.HasTimestamps ? FE->getModificationTime() : 0,
1595 FE->getName(), /*Imported*/ false};
1599 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1600 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1603 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1606 // Determine whether the actual files are equivalent.
1607 FileManager &FileMgr = Reader.getFileManager();
1608 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1610 return FileMgr.getFile(Key.Filename);
1612 std::string Resolved = Key.Filename;
1613 Reader.ResolveImportedPath(M, Resolved);
1614 return FileMgr.getFile(Resolved);
1617 const FileEntry *FEA = GetFile(a);
1618 const FileEntry *FEB = GetFile(b);
1619 return FEA && FEA == FEB;
1622 std::pair<unsigned, unsigned>
1623 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1624 using namespace llvm::support;
1625 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1626 unsigned DataLen = (unsigned) *d++;
1627 return std::make_pair(KeyLen, DataLen);
1630 HeaderFileInfoTrait::internal_key_type
1631 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1632 using namespace llvm::support;
1633 internal_key_type ikey;
1634 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1635 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1636 ikey.Filename = (const char *)d;
1637 ikey.Imported = true;
1641 HeaderFileInfoTrait::data_type
1642 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1644 const unsigned char *End = d + DataLen;
1645 using namespace llvm::support;
1647 unsigned Flags = *d++;
1648 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1649 HFI.isImport |= (Flags >> 4) & 0x01;
1650 HFI.isPragmaOnce |= (Flags >> 3) & 0x01;
1651 HFI.DirInfo = (Flags >> 1) & 0x03;
1652 HFI.IndexHeaderMapHeader = Flags & 0x01;
1653 // FIXME: Find a better way to handle this. Maybe just store a
1654 // "has been included" flag?
1655 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1657 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1658 M, endian::readNext<uint32_t, little, unaligned>(d));
1659 if (unsigned FrameworkOffset =
1660 endian::readNext<uint32_t, little, unaligned>(d)) {
1661 // The framework offset is 1 greater than the actual offset,
1662 // since 0 is used as an indicator for "no framework name".
1663 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1664 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1667 assert((End - d) % 4 == 0 &&
1668 "Wrong data length in HeaderFileInfo deserialization");
1670 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1671 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1674 // This header is part of a module. Associate it with the module to enable
1675 // implicit module import.
1676 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1677 Module *Mod = Reader.getSubmodule(GlobalSMID);
1678 FileManager &FileMgr = Reader.getFileManager();
1680 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1682 std::string Filename = key.Filename;
1684 Reader.ResolveImportedPath(M, Filename);
1685 // FIXME: This is not always the right filename-as-written, but we're not
1686 // going to use this information to rebuild the module, so it doesn't make
1687 // a lot of difference.
1688 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1689 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1690 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1693 // This HeaderFileInfo was externally loaded.
1694 HFI.External = true;
1699 void ASTReader::addPendingMacro(IdentifierInfo *II,
1701 uint64_t MacroDirectivesOffset) {
1702 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1703 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1706 void ASTReader::ReadDefinedMacros() {
1707 // Note that we are loading defined macros.
1708 Deserializing Macros(this);
1710 for (auto &I : llvm::reverse(ModuleMgr)) {
1711 BitstreamCursor &MacroCursor = I->MacroCursor;
1713 // If there was no preprocessor block, skip this file.
1714 if (MacroCursor.getBitcodeBytes().empty())
1717 BitstreamCursor Cursor = MacroCursor;
1718 Cursor.JumpToBit(I->MacroStartOffset);
1722 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1725 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1726 case llvm::BitstreamEntry::Error:
1727 Error("malformed block record in AST file");
1729 case llvm::BitstreamEntry::EndBlock:
1732 case llvm::BitstreamEntry::Record:
1734 switch (Cursor.readRecord(E.ID, Record)) {
1735 default: // Default behavior: ignore.
1738 case PP_MACRO_OBJECT_LIKE:
1739 case PP_MACRO_FUNCTION_LIKE: {
1740 IdentifierInfo *II = getLocalIdentifier(*I, Record[0]);
1741 if (II->isOutOfDate())
1742 updateOutOfDateIdentifier(*II);
1759 /// \brief Visitor class used to look up identifirs in an AST file.
1760 class IdentifierLookupVisitor {
1763 unsigned PriorGeneration;
1764 unsigned &NumIdentifierLookups;
1765 unsigned &NumIdentifierLookupHits;
1766 IdentifierInfo *Found;
1769 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1770 unsigned &NumIdentifierLookups,
1771 unsigned &NumIdentifierLookupHits)
1772 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1773 PriorGeneration(PriorGeneration),
1774 NumIdentifierLookups(NumIdentifierLookups),
1775 NumIdentifierLookupHits(NumIdentifierLookupHits),
1780 bool operator()(ModuleFile &M) {
1781 // If we've already searched this module file, skip it now.
1782 if (M.Generation <= PriorGeneration)
1785 ASTIdentifierLookupTable *IdTable
1786 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1790 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1792 ++NumIdentifierLookups;
1793 ASTIdentifierLookupTable::iterator Pos =
1794 IdTable->find_hashed(Name, NameHash, &Trait);
1795 if (Pos == IdTable->end())
1798 // Dereferencing the iterator has the effect of building the
1799 // IdentifierInfo node and populating it with the various
1800 // declarations it needs.
1801 ++NumIdentifierLookupHits;
1806 // \brief Retrieve the identifier info found within the module
1808 IdentifierInfo *getIdentifierInfo() const { return Found; }
1811 } // end anonymous namespace
1813 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1814 // Note that we are loading an identifier.
1815 Deserializing AnIdentifier(this);
1817 unsigned PriorGeneration = 0;
1818 if (getContext().getLangOpts().Modules)
1819 PriorGeneration = IdentifierGeneration[&II];
1821 // If there is a global index, look there first to determine which modules
1822 // provably do not have any results for this identifier.
1823 GlobalModuleIndex::HitSet Hits;
1824 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1825 if (!loadGlobalIndex()) {
1826 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1831 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1832 NumIdentifierLookups,
1833 NumIdentifierLookupHits);
1834 ModuleMgr.visit(Visitor, HitsPtr);
1835 markIdentifierUpToDate(&II);
1838 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1842 II->setOutOfDate(false);
1844 // Update the generation for this identifier.
1845 if (getContext().getLangOpts().Modules)
1846 IdentifierGeneration[II] = getGeneration();
1849 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1850 const PendingMacroInfo &PMInfo) {
1851 ModuleFile &M = *PMInfo.M;
1853 BitstreamCursor &Cursor = M.MacroCursor;
1854 SavedStreamPosition SavedPosition(Cursor);
1855 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1857 struct ModuleMacroRecord {
1858 SubmoduleID SubModID;
1860 SmallVector<SubmoduleID, 8> Overrides;
1862 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1864 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1865 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1869 llvm::BitstreamEntry Entry =
1870 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1871 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1872 Error("malformed block record in AST file");
1877 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1878 case PP_MACRO_DIRECTIVE_HISTORY:
1881 case PP_MODULE_MACRO: {
1882 ModuleMacros.push_back(ModuleMacroRecord());
1883 auto &Info = ModuleMacros.back();
1884 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1885 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1886 for (int I = 2, N = Record.size(); I != N; ++I)
1887 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1892 Error("malformed block record in AST file");
1896 // We found the macro directive history; that's the last record
1901 // Module macros are listed in reverse dependency order.
1903 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
1904 llvm::SmallVector<ModuleMacro*, 8> Overrides;
1905 for (auto &MMR : ModuleMacros) {
1907 for (unsigned ModID : MMR.Overrides) {
1908 Module *Mod = getSubmodule(ModID);
1909 auto *Macro = PP.getModuleMacro(Mod, II);
1910 assert(Macro && "missing definition for overridden macro");
1911 Overrides.push_back(Macro);
1914 bool Inserted = false;
1915 Module *Owner = getSubmodule(MMR.SubModID);
1916 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
1920 // Don't read the directive history for a module; we don't have anywhere
1925 // Deserialize the macro directives history in reverse source-order.
1926 MacroDirective *Latest = nullptr, *Earliest = nullptr;
1927 unsigned Idx = 0, N = Record.size();
1929 MacroDirective *MD = nullptr;
1930 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
1931 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1933 case MacroDirective::MD_Define: {
1934 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
1935 MD = PP.AllocateDefMacroDirective(MI, Loc);
1938 case MacroDirective::MD_Undefine: {
1939 MD = PP.AllocateUndefMacroDirective(Loc);
1942 case MacroDirective::MD_Visibility:
1943 bool isPublic = Record[Idx++];
1944 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1951 Earliest->setPrevious(MD);
1956 PP.setLoadedMacroDirective(II, Earliest, Latest);
1959 ASTReader::InputFileInfo
1960 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
1961 // Go find this input file.
1962 BitstreamCursor &Cursor = F.InputFilesCursor;
1963 SavedStreamPosition SavedPosition(Cursor);
1964 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1966 unsigned Code = Cursor.ReadCode();
1970 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
1971 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
1972 "invalid record type for input file");
1975 assert(Record[0] == ID && "Bogus stored ID or offset");
1977 R.StoredSize = static_cast<off_t>(Record[1]);
1978 R.StoredTime = static_cast<time_t>(Record[2]);
1979 R.Overridden = static_cast<bool>(Record[3]);
1980 R.Transient = static_cast<bool>(Record[4]);
1982 ResolveImportedPath(F, R.Filename);
1986 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
1987 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
1988 // If this ID is bogus, just return an empty input file.
1989 if (ID == 0 || ID > F.InputFilesLoaded.size())
1992 // If we've already loaded this input file, return it.
1993 if (F.InputFilesLoaded[ID-1].getFile())
1994 return F.InputFilesLoaded[ID-1];
1996 if (F.InputFilesLoaded[ID-1].isNotFound())
1999 // Go find this input file.
2000 BitstreamCursor &Cursor = F.InputFilesCursor;
2001 SavedStreamPosition SavedPosition(Cursor);
2002 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2004 InputFileInfo FI = readInputFileInfo(F, ID);
2005 off_t StoredSize = FI.StoredSize;
2006 time_t StoredTime = FI.StoredTime;
2007 bool Overridden = FI.Overridden;
2008 bool Transient = FI.Transient;
2009 StringRef Filename = FI.Filename;
2011 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2013 // If we didn't find the file, resolve it relative to the
2014 // original directory from which this AST file was created.
2015 if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
2016 F.OriginalDir != CurrentDir) {
2017 std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
2020 if (!Resolved.empty())
2021 File = FileMgr.getFile(Resolved);
2024 // For an overridden file, create a virtual file with the stored
2026 if ((Overridden || Transient) && File == nullptr)
2027 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2029 if (File == nullptr) {
2031 std::string ErrorStr = "could not find file '";
2032 ErrorStr += Filename;
2033 ErrorStr += "' referenced by AST file '";
2034 ErrorStr += F.FileName;
2038 // Record that we didn't find the file.
2039 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2043 // Check if there was a request to override the contents of the file
2044 // that was part of the precompiled header. Overridding such a file
2045 // can lead to problems when lexing using the source locations from the
2047 SourceManager &SM = getSourceManager();
2048 // FIXME: Reject if the overrides are different.
2049 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2051 Error(diag::err_fe_pch_file_overridden, Filename);
2052 // After emitting the diagnostic, recover by disabling the override so
2053 // that the original file will be used.
2055 // FIXME: This recovery is just as broken as the original state; there may
2056 // be another precompiled module that's using the overridden contents, or
2057 // we might be half way through parsing it. Instead, we should treat the
2058 // overridden contents as belonging to a separate FileEntry.
2059 SM.disableFileContentsOverride(File);
2060 // The FileEntry is a virtual file entry with the size of the contents
2061 // that would override the original contents. Set it to the original's
2063 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2064 StoredSize, StoredTime);
2067 bool IsOutOfDate = false;
2069 // For an overridden file, there is nothing to validate.
2070 if (!Overridden && //
2071 (StoredSize != File->getSize() ||
2072 (StoredTime && StoredTime != File->getModificationTime() &&
2076 // Build a list of the PCH imports that got us here (in reverse).
2077 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2078 while (ImportStack.back()->ImportedBy.size() > 0)
2079 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2081 // The top-level PCH is stale.
2082 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2083 unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2084 if (DiagnosticKind == 0)
2085 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2086 else if (DiagnosticKind == 1)
2087 Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2089 Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2091 // Print the import stack.
2092 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2093 Diag(diag::note_pch_required_by)
2094 << Filename << ImportStack[0]->FileName;
2095 for (unsigned I = 1; I < ImportStack.size(); ++I)
2096 Diag(diag::note_pch_required_by)
2097 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2100 if (!Diags.isDiagnosticInFlight())
2101 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2106 // FIXME: If the file is overridden and we've already opened it,
2107 // issue an error (or split it into a separate FileEntry).
2109 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2111 // Note that we've loaded this input file.
2112 F.InputFilesLoaded[ID-1] = IF;
2116 /// \brief If we are loading a relocatable PCH or module file, and the filename
2117 /// is not an absolute path, add the system or module root to the beginning of
2119 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2120 // Resolve relative to the base directory, if we have one.
2121 if (!M.BaseDirectory.empty())
2122 return ResolveImportedPath(Filename, M.BaseDirectory);
2125 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2126 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2129 SmallString<128> Buffer;
2130 llvm::sys::path::append(Buffer, Prefix, Filename);
2131 Filename.assign(Buffer.begin(), Buffer.end());
2134 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2136 case ASTReader::Failure: return true;
2137 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2138 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2139 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2140 case ASTReader::ConfigurationMismatch:
2141 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2142 case ASTReader::HadErrors: return true;
2143 case ASTReader::Success: return false;
2146 llvm_unreachable("unknown ASTReadResult");
2149 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2150 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2151 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2152 std::string &SuggestedPredefines, bool ValidateDiagnosticOptions) {
2153 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2156 // Read all of the records in the options block.
2158 ASTReadResult Result = Success;
2160 llvm::BitstreamEntry Entry = Stream.advance();
2162 switch (Entry.Kind) {
2163 case llvm::BitstreamEntry::Error:
2164 case llvm::BitstreamEntry::SubBlock:
2167 case llvm::BitstreamEntry::EndBlock:
2170 case llvm::BitstreamEntry::Record:
2171 // The interesting case.
2175 // Read and process a record.
2177 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2178 case LANGUAGE_OPTIONS: {
2179 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2180 if (ParseLanguageOptions(Record, Complain, Listener,
2181 AllowCompatibleConfigurationMismatch))
2182 Result = ConfigurationMismatch;
2186 case TARGET_OPTIONS: {
2187 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2188 if (ParseTargetOptions(Record, Complain, Listener,
2189 AllowCompatibleConfigurationMismatch))
2190 Result = ConfigurationMismatch;
2194 case DIAGNOSTIC_OPTIONS: {
2195 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2196 if (ValidateDiagnosticOptions &&
2197 !AllowCompatibleConfigurationMismatch &&
2198 ParseDiagnosticOptions(Record, Complain, Listener))
2203 case FILE_SYSTEM_OPTIONS: {
2204 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2205 if (!AllowCompatibleConfigurationMismatch &&
2206 ParseFileSystemOptions(Record, Complain, Listener))
2207 Result = ConfigurationMismatch;
2211 case HEADER_SEARCH_OPTIONS: {
2212 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2213 if (!AllowCompatibleConfigurationMismatch &&
2214 ParseHeaderSearchOptions(Record, Complain, Listener))
2215 Result = ConfigurationMismatch;
2219 case PREPROCESSOR_OPTIONS:
2220 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2221 if (!AllowCompatibleConfigurationMismatch &&
2222 ParsePreprocessorOptions(Record, Complain, Listener,
2223 SuggestedPredefines))
2224 Result = ConfigurationMismatch;
2230 ASTReader::ASTReadResult
2231 ASTReader::ReadControlBlock(ModuleFile &F,
2232 SmallVectorImpl<ImportedModule> &Loaded,
2233 const ModuleFile *ImportedBy,
2234 unsigned ClientLoadCapabilities) {
2235 BitstreamCursor &Stream = F.Stream;
2236 ASTReadResult Result = Success;
2238 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2239 Error("malformed block record in AST file");
2243 // Read all of the records and blocks in the control block.
2245 unsigned NumInputs = 0;
2246 unsigned NumUserInputs = 0;
2248 llvm::BitstreamEntry Entry = Stream.advance();
2250 switch (Entry.Kind) {
2251 case llvm::BitstreamEntry::Error:
2252 Error("malformed block record in AST file");
2254 case llvm::BitstreamEntry::EndBlock: {
2255 // Validate input files.
2256 const HeaderSearchOptions &HSOpts =
2257 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2259 // All user input files reside at the index range [0, NumUserInputs), and
2260 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2261 // loaded module files, ignore missing inputs.
2262 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2263 F.Kind != MK_PrebuiltModule) {
2264 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2266 // If we are reading a module, we will create a verification timestamp,
2267 // so we verify all input files. Otherwise, verify only user input
2270 unsigned N = NumUserInputs;
2271 if (ValidateSystemInputs ||
2272 (HSOpts.ModulesValidateOncePerBuildSession &&
2273 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2274 F.Kind == MK_ImplicitModule))
2277 for (unsigned I = 0; I < N; ++I) {
2278 InputFile IF = getInputFile(F, I+1, Complain);
2279 if (!IF.getFile() || IF.isOutOfDate())
2285 Listener->visitModuleFile(F.FileName, F.Kind);
2287 if (Listener && Listener->needsInputFileVisitation()) {
2288 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2290 for (unsigned I = 0; I < N; ++I) {
2291 bool IsSystem = I >= NumUserInputs;
2292 InputFileInfo FI = readInputFileInfo(F, I+1);
2293 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2294 F.Kind == MK_ExplicitModule ||
2295 F.Kind == MK_PrebuiltModule);
2302 case llvm::BitstreamEntry::SubBlock:
2304 case INPUT_FILES_BLOCK_ID:
2305 F.InputFilesCursor = Stream;
2306 if (Stream.SkipBlock() || // Skip with the main cursor
2307 // Read the abbreviations
2308 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2309 Error("malformed block record in AST file");
2314 case OPTIONS_BLOCK_ID:
2315 // If we're reading the first module for this group, check its options
2316 // are compatible with ours. For modules it imports, no further checking
2317 // is required, because we checked them when we built it.
2318 if (Listener && !ImportedBy) {
2319 // Should we allow the configuration of the module file to differ from
2320 // the configuration of the current translation unit in a compatible
2323 // FIXME: Allow this for files explicitly specified with -include-pch.
2324 bool AllowCompatibleConfigurationMismatch =
2325 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2326 const HeaderSearchOptions &HSOpts =
2327 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2329 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2330 AllowCompatibleConfigurationMismatch,
2331 *Listener, SuggestedPredefines,
2332 HSOpts.ModulesValidateDiagnosticOptions);
2333 if (Result == Failure) {
2334 Error("malformed block record in AST file");
2338 if (DisableValidation ||
2339 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2342 // If we can't load the module, exit early since we likely
2343 // will rebuild the module anyway. The stream may be in the
2344 // middle of a block.
2345 if (Result != Success)
2347 } else if (Stream.SkipBlock()) {
2348 Error("malformed block record in AST file");
2354 if (Stream.SkipBlock()) {
2355 Error("malformed block record in AST file");
2361 case llvm::BitstreamEntry::Record:
2362 // The interesting case.
2366 // Read and process a record.
2369 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2371 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2372 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2373 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2374 : diag::err_pch_version_too_new);
2375 return VersionMismatch;
2378 bool hasErrors = Record[6];
2379 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2380 Diag(diag::err_pch_with_compiler_errors);
2384 Diags.ErrorOccurred = true;
2385 Diags.UncompilableErrorOccurred = true;
2386 Diags.UnrecoverableErrorOccurred = true;
2389 F.RelocatablePCH = Record[4];
2390 // Relative paths in a relocatable PCH are relative to our sysroot.
2391 if (F.RelocatablePCH)
2392 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2394 F.HasTimestamps = Record[5];
2396 const std::string &CurBranch = getClangFullRepositoryVersion();
2397 StringRef ASTBranch = Blob;
2398 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2399 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2400 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2401 return VersionMismatch;
2407 assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
2408 F.Signature = Record[0];
2412 // Load each of the imported PCH files.
2413 unsigned Idx = 0, N = Record.size();
2415 // Read information about the AST file.
2416 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2417 // The import location will be the local one for now; we will adjust
2418 // all import locations of module imports after the global source
2419 // location info are setup, in ReadAST.
2420 SourceLocation ImportLoc =
2421 ReadUntranslatedSourceLocation(Record[Idx++]);
2422 off_t StoredSize = (off_t)Record[Idx++];
2423 time_t StoredModTime = (time_t)Record[Idx++];
2424 ASTFileSignature StoredSignature = Record[Idx++];
2425 auto ImportedFile = ReadPath(F, Record, Idx);
2427 // If our client can't cope with us being out of date, we can't cope with
2428 // our dependency being missing.
2429 unsigned Capabilities = ClientLoadCapabilities;
2430 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2431 Capabilities &= ~ARR_Missing;
2433 // Load the AST file.
2434 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2435 Loaded, StoredSize, StoredModTime,
2436 StoredSignature, Capabilities);
2438 // If we diagnosed a problem, produce a backtrace.
2439 if (isDiagnosedResult(Result, Capabilities))
2440 Diag(diag::note_module_file_imported_by)
2441 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2444 case Failure: return Failure;
2445 // If we have to ignore the dependency, we'll have to ignore this too.
2447 case OutOfDate: return OutOfDate;
2448 case VersionMismatch: return VersionMismatch;
2449 case ConfigurationMismatch: return ConfigurationMismatch;
2450 case HadErrors: return HadErrors;
2451 case Success: break;
2458 F.OriginalSourceFileID = FileID::get(Record[0]);
2459 F.ActualOriginalSourceFileName = Blob;
2460 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2461 ResolveImportedPath(F, F.OriginalSourceFileName);
2464 case ORIGINAL_FILE_ID:
2465 F.OriginalSourceFileID = FileID::get(Record[0]);
2468 case ORIGINAL_PCH_DIR:
2469 F.OriginalDir = Blob;
2473 F.ModuleName = Blob;
2475 Listener->ReadModuleName(F.ModuleName);
2478 case MODULE_DIRECTORY: {
2479 assert(!F.ModuleName.empty() &&
2480 "MODULE_DIRECTORY found before MODULE_NAME");
2481 // If we've already loaded a module map file covering this module, we may
2482 // have a better path for it (relative to the current build).
2483 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2484 if (M && M->Directory) {
2485 // If we're implicitly loading a module, the base directory can't
2486 // change between the build and use.
2487 if (F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2488 const DirectoryEntry *BuildDir =
2489 PP.getFileManager().getDirectory(Blob);
2490 if (!BuildDir || BuildDir != M->Directory) {
2491 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2492 Diag(diag::err_imported_module_relocated)
2493 << F.ModuleName << Blob << M->Directory->getName();
2497 F.BaseDirectory = M->Directory->getName();
2499 F.BaseDirectory = Blob;
2504 case MODULE_MAP_FILE:
2505 if (ASTReadResult Result =
2506 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2510 case INPUT_FILE_OFFSETS:
2511 NumInputs = Record[0];
2512 NumUserInputs = Record[1];
2513 F.InputFileOffsets =
2514 (const llvm::support::unaligned_uint64_t *)Blob.data();
2515 F.InputFilesLoaded.resize(NumInputs);
2521 ASTReader::ASTReadResult
2522 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2523 BitstreamCursor &Stream = F.Stream;
2525 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2526 Error("malformed block record in AST file");
2530 // Read all of the records and blocks for the AST file.
2533 llvm::BitstreamEntry Entry = Stream.advance();
2535 switch (Entry.Kind) {
2536 case llvm::BitstreamEntry::Error:
2537 Error("error at end of module block in AST file");
2539 case llvm::BitstreamEntry::EndBlock: {
2540 // Outside of C++, we do not store a lookup map for the translation unit.
2541 // Instead, mark it as needing a lookup map to be built if this module
2542 // contains any declarations lexically within it (which it always does!).
2543 // This usually has no cost, since we very rarely need the lookup map for
2544 // the translation unit outside C++.
2545 DeclContext *DC = Context.getTranslationUnitDecl();
2546 if (DC->hasExternalLexicalStorage() &&
2547 !getContext().getLangOpts().CPlusPlus)
2548 DC->setMustBuildLookupTable();
2552 case llvm::BitstreamEntry::SubBlock:
2554 case DECLTYPES_BLOCK_ID:
2555 // We lazily load the decls block, but we want to set up the
2556 // DeclsCursor cursor to point into it. Clone our current bitcode
2557 // cursor to it, enter the block and read the abbrevs in that block.
2558 // With the main cursor, we just skip over it.
2559 F.DeclsCursor = Stream;
2560 if (Stream.SkipBlock() || // Skip with the main cursor.
2561 // Read the abbrevs.
2562 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2563 Error("malformed block record in AST file");
2568 case PREPROCESSOR_BLOCK_ID:
2569 F.MacroCursor = Stream;
2570 if (!PP.getExternalSource())
2571 PP.setExternalSource(this);
2573 if (Stream.SkipBlock() ||
2574 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2575 Error("malformed block record in AST file");
2578 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2581 case PREPROCESSOR_DETAIL_BLOCK_ID:
2582 F.PreprocessorDetailCursor = Stream;
2583 if (Stream.SkipBlock() ||
2584 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2585 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2586 Error("malformed preprocessor detail record in AST file");
2589 F.PreprocessorDetailStartOffset
2590 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2592 if (!PP.getPreprocessingRecord())
2593 PP.createPreprocessingRecord();
2594 if (!PP.getPreprocessingRecord()->getExternalSource())
2595 PP.getPreprocessingRecord()->SetExternalSource(*this);
2598 case SOURCE_MANAGER_BLOCK_ID:
2599 if (ReadSourceManagerBlock(F))
2603 case SUBMODULE_BLOCK_ID:
2604 if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
2608 case COMMENTS_BLOCK_ID: {
2609 BitstreamCursor C = Stream;
2610 if (Stream.SkipBlock() ||
2611 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2612 Error("malformed comments block in AST file");
2615 CommentsCursors.push_back(std::make_pair(C, &F));
2620 if (Stream.SkipBlock()) {
2621 Error("malformed block record in AST file");
2628 case llvm::BitstreamEntry::Record:
2629 // The interesting case.
2633 // Read and process a record.
2636 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2637 default: // Default behavior: ignore.
2641 if (F.LocalNumTypes != 0) {
2642 Error("duplicate TYPE_OFFSET record in AST file");
2645 F.TypeOffsets = (const uint32_t *)Blob.data();
2646 F.LocalNumTypes = Record[0];
2647 unsigned LocalBaseTypeIndex = Record[1];
2648 F.BaseTypeIndex = getTotalNumTypes();
2650 if (F.LocalNumTypes > 0) {
2651 // Introduce the global -> local mapping for types within this module.
2652 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2654 // Introduce the local -> global mapping for types within this module.
2655 F.TypeRemap.insertOrReplace(
2656 std::make_pair(LocalBaseTypeIndex,
2657 F.BaseTypeIndex - LocalBaseTypeIndex));
2659 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2665 if (F.LocalNumDecls != 0) {
2666 Error("duplicate DECL_OFFSET record in AST file");
2669 F.DeclOffsets = (const DeclOffset *)Blob.data();
2670 F.LocalNumDecls = Record[0];
2671 unsigned LocalBaseDeclID = Record[1];
2672 F.BaseDeclID = getTotalNumDecls();
2674 if (F.LocalNumDecls > 0) {
2675 // Introduce the global -> local mapping for declarations within this
2677 GlobalDeclMap.insert(
2678 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2680 // Introduce the local -> global mapping for declarations within this
2682 F.DeclRemap.insertOrReplace(
2683 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2685 // Introduce the global -> local mapping for declarations within this
2687 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2689 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2694 case TU_UPDATE_LEXICAL: {
2695 DeclContext *TU = Context.getTranslationUnitDecl();
2696 LexicalContents Contents(
2697 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2699 static_cast<unsigned int>(Blob.size() / 4));
2700 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2701 TU->setHasExternalLexicalStorage(true);
2705 case UPDATE_VISIBLE: {
2707 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2708 auto *Data = (const unsigned char*)Blob.data();
2709 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2710 // If we've already loaded the decl, perform the updates when we finish
2711 // loading this block.
2712 if (Decl *D = GetExistingDecl(ID))
2713 PendingUpdateRecords.push_back(std::make_pair(ID, D));
2717 case IDENTIFIER_TABLE:
2718 F.IdentifierTableData = Blob.data();
2720 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2721 (const unsigned char *)F.IdentifierTableData + Record[0],
2722 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2723 (const unsigned char *)F.IdentifierTableData,
2724 ASTIdentifierLookupTrait(*this, F));
2726 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2730 case IDENTIFIER_OFFSET: {
2731 if (F.LocalNumIdentifiers != 0) {
2732 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2735 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2736 F.LocalNumIdentifiers = Record[0];
2737 unsigned LocalBaseIdentifierID = Record[1];
2738 F.BaseIdentifierID = getTotalNumIdentifiers();
2740 if (F.LocalNumIdentifiers > 0) {
2741 // Introduce the global -> local mapping for identifiers within this
2743 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2746 // Introduce the local -> global mapping for identifiers within this
2748 F.IdentifierRemap.insertOrReplace(
2749 std::make_pair(LocalBaseIdentifierID,
2750 F.BaseIdentifierID - LocalBaseIdentifierID));
2752 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2753 + F.LocalNumIdentifiers);
2758 case INTERESTING_IDENTIFIERS:
2759 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2762 case EAGERLY_DESERIALIZED_DECLS:
2763 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2764 // about "interesting" decls (for instance, if we're building a module).
2765 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2766 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2770 if (SpecialTypes.empty()) {
2771 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2772 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2776 if (SpecialTypes.size() != Record.size()) {
2777 Error("invalid special-types record");
2781 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2782 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2783 if (!SpecialTypes[I])
2784 SpecialTypes[I] = ID;
2785 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2791 TotalNumStatements += Record[0];
2792 TotalNumMacros += Record[1];
2793 TotalLexicalDeclContexts += Record[2];
2794 TotalVisibleDeclContexts += Record[3];
2797 case UNUSED_FILESCOPED_DECLS:
2798 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2799 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2802 case DELEGATING_CTORS:
2803 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2804 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2807 case WEAK_UNDECLARED_IDENTIFIERS:
2808 if (Record.size() % 4 != 0) {
2809 Error("invalid weak identifiers record");
2813 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2814 // files. This isn't the way to do it :)
2815 WeakUndeclaredIdentifiers.clear();
2817 // Translate the weak, undeclared identifiers into global IDs.
2818 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2819 WeakUndeclaredIdentifiers.push_back(
2820 getGlobalIdentifierID(F, Record[I++]));
2821 WeakUndeclaredIdentifiers.push_back(
2822 getGlobalIdentifierID(F, Record[I++]));
2823 WeakUndeclaredIdentifiers.push_back(
2824 ReadSourceLocation(F, Record, I).getRawEncoding());
2825 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2829 case SELECTOR_OFFSETS: {
2830 F.SelectorOffsets = (const uint32_t *)Blob.data();
2831 F.LocalNumSelectors = Record[0];
2832 unsigned LocalBaseSelectorID = Record[1];
2833 F.BaseSelectorID = getTotalNumSelectors();
2835 if (F.LocalNumSelectors > 0) {
2836 // Introduce the global -> local mapping for selectors within this
2838 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2840 // Introduce the local -> global mapping for selectors within this
2842 F.SelectorRemap.insertOrReplace(
2843 std::make_pair(LocalBaseSelectorID,
2844 F.BaseSelectorID - LocalBaseSelectorID));
2846 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2852 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
2854 F.SelectorLookupTable
2855 = ASTSelectorLookupTable::Create(
2856 F.SelectorLookupTableData + Record[0],
2857 F.SelectorLookupTableData,
2858 ASTSelectorLookupTrait(*this, F));
2859 TotalNumMethodPoolEntries += Record[1];
2862 case REFERENCED_SELECTOR_POOL:
2863 if (!Record.empty()) {
2864 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2865 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2867 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2873 case PP_COUNTER_VALUE:
2874 if (!Record.empty() && Listener)
2875 Listener->ReadCounter(F, Record[0]);
2878 case FILE_SORTED_DECLS:
2879 F.FileSortedDecls = (const DeclID *)Blob.data();
2880 F.NumFileSortedDecls = Record[0];
2883 case SOURCE_LOCATION_OFFSETS: {
2884 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
2885 F.LocalNumSLocEntries = Record[0];
2886 unsigned SLocSpaceSize = Record[1];
2887 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2888 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2890 if (!F.SLocEntryBaseID) {
2891 Error("ran out of source locations");
2894 // Make our entry in the range map. BaseID is negative and growing, so
2895 // we invert it. Because we invert it, though, we need the other end of
2897 unsigned RangeStart =
2898 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2899 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2900 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2902 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2903 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2904 GlobalSLocOffsetMap.insert(
2905 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2906 - SLocSpaceSize,&F));
2908 // Initialize the remapping table.
2909 // Invalid stays invalid.
2910 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
2911 // This module. Base was 2 when being compiled.
2912 F.SLocRemap.insertOrReplace(std::make_pair(2U,
2913 static_cast<int>(F.SLocEntryBaseOffset - 2)));
2915 TotalNumSLocEntries += F.LocalNumSLocEntries;
2919 case MODULE_OFFSET_MAP: {
2920 // Additional remapping information.
2921 const unsigned char *Data = (const unsigned char*)Blob.data();
2922 const unsigned char *DataEnd = Data + Blob.size();
2924 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
2925 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
2926 F.SLocRemap.insert(std::make_pair(0U, 0));
2927 F.SLocRemap.insert(std::make_pair(2U, 1));
2930 // Continuous range maps we may be updating in our module.
2931 typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
2933 RemapBuilder SLocRemap(F.SLocRemap);
2934 RemapBuilder IdentifierRemap(F.IdentifierRemap);
2935 RemapBuilder MacroRemap(F.MacroRemap);
2936 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2937 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
2938 RemapBuilder SelectorRemap(F.SelectorRemap);
2939 RemapBuilder DeclRemap(F.DeclRemap);
2940 RemapBuilder TypeRemap(F.TypeRemap);
2942 while (Data < DataEnd) {
2943 using namespace llvm::support;
2944 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
2945 StringRef Name = StringRef((const char*)Data, Len);
2947 ModuleFile *OM = ModuleMgr.lookup(Name);
2949 Error("SourceLocation remap refers to unknown module");
2953 uint32_t SLocOffset =
2954 endian::readNext<uint32_t, little, unaligned>(Data);
2955 uint32_t IdentifierIDOffset =
2956 endian::readNext<uint32_t, little, unaligned>(Data);
2957 uint32_t MacroIDOffset =
2958 endian::readNext<uint32_t, little, unaligned>(Data);
2959 uint32_t PreprocessedEntityIDOffset =
2960 endian::readNext<uint32_t, little, unaligned>(Data);
2961 uint32_t SubmoduleIDOffset =
2962 endian::readNext<uint32_t, little, unaligned>(Data);
2963 uint32_t SelectorIDOffset =
2964 endian::readNext<uint32_t, little, unaligned>(Data);
2965 uint32_t DeclIDOffset =
2966 endian::readNext<uint32_t, little, unaligned>(Data);
2967 uint32_t TypeIndexOffset =
2968 endian::readNext<uint32_t, little, unaligned>(Data);
2970 uint32_t None = std::numeric_limits<uint32_t>::max();
2972 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
2973 RemapBuilder &Remap) {
2975 Remap.insert(std::make_pair(Offset,
2976 static_cast<int>(BaseOffset - Offset)));
2978 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
2979 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
2980 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
2981 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
2982 PreprocessedEntityRemap);
2983 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
2984 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
2985 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
2986 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
2988 // Global -> local mappings.
2989 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2994 case SOURCE_MANAGER_LINE_TABLE:
2995 if (ParseLineTable(F, Record))
2999 case SOURCE_LOCATION_PRELOADS: {
3000 // Need to transform from the local view (1-based IDs) to the global view,
3001 // which is based off F.SLocEntryBaseID.
3002 if (!F.PreloadSLocEntries.empty()) {
3003 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3007 F.PreloadSLocEntries.swap(Record);
3011 case EXT_VECTOR_DECLS:
3012 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3013 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3017 if (Record.size() % 3 != 0) {
3018 Error("Invalid VTABLE_USES record");
3022 // Later tables overwrite earlier ones.
3023 // FIXME: Modules will have some trouble with this. This is clearly not
3024 // the right way to do this.
3027 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3028 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3029 VTableUses.push_back(
3030 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3031 VTableUses.push_back(Record[Idx++]);
3035 case PENDING_IMPLICIT_INSTANTIATIONS:
3036 if (PendingInstantiations.size() % 2 != 0) {
3037 Error("Invalid existing PendingInstantiations");
3041 if (Record.size() % 2 != 0) {
3042 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3046 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3047 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3048 PendingInstantiations.push_back(
3049 ReadSourceLocation(F, Record, I).getRawEncoding());
3053 case SEMA_DECL_REFS:
3054 if (Record.size() != 3) {
3055 Error("Invalid SEMA_DECL_REFS block");
3058 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3059 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3062 case PPD_ENTITIES_OFFSETS: {
3063 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3064 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3065 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3067 unsigned LocalBasePreprocessedEntityID = Record[0];
3069 unsigned StartingID;
3070 if (!PP.getPreprocessingRecord())
3071 PP.createPreprocessingRecord();
3072 if (!PP.getPreprocessingRecord()->getExternalSource())
3073 PP.getPreprocessingRecord()->SetExternalSource(*this);
3075 = PP.getPreprocessingRecord()
3076 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3077 F.BasePreprocessedEntityID = StartingID;
3079 if (F.NumPreprocessedEntities > 0) {
3080 // Introduce the global -> local mapping for preprocessed entities in
3082 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3084 // Introduce the local -> global mapping for preprocessed entities in
3086 F.PreprocessedEntityRemap.insertOrReplace(
3087 std::make_pair(LocalBasePreprocessedEntityID,
3088 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3094 case DECL_UPDATE_OFFSETS: {
3095 if (Record.size() % 2 != 0) {
3096 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3099 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3100 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3101 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3103 // If we've already loaded the decl, perform the updates when we finish
3104 // loading this block.
3105 if (Decl *D = GetExistingDecl(ID))
3106 PendingUpdateRecords.push_back(std::make_pair(ID, D));
3111 case OBJC_CATEGORIES_MAP: {
3112 if (F.LocalNumObjCCategoriesInMap != 0) {
3113 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3117 F.LocalNumObjCCategoriesInMap = Record[0];
3118 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3122 case OBJC_CATEGORIES:
3123 F.ObjCCategories.swap(Record);
3126 case DIAG_PRAGMA_MAPPINGS:
3127 if (F.PragmaDiagMappings.empty())
3128 F.PragmaDiagMappings.swap(Record);
3130 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3131 Record.begin(), Record.end());
3134 case CUDA_SPECIAL_DECL_REFS:
3135 // Later tables overwrite earlier ones.
3136 // FIXME: Modules will have trouble with this.
3137 CUDASpecialDeclRefs.clear();
3138 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3139 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3142 case HEADER_SEARCH_TABLE: {
3143 F.HeaderFileInfoTableData = Blob.data();
3144 F.LocalNumHeaderFileInfos = Record[1];
3146 F.HeaderFileInfoTable
3147 = HeaderFileInfoLookupTable::Create(
3148 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3149 (const unsigned char *)F.HeaderFileInfoTableData,
3150 HeaderFileInfoTrait(*this, F,
3151 &PP.getHeaderSearchInfo(),
3152 Blob.data() + Record[2]));
3154 PP.getHeaderSearchInfo().SetExternalSource(this);
3155 if (!PP.getHeaderSearchInfo().getExternalLookup())
3156 PP.getHeaderSearchInfo().SetExternalLookup(this);
3161 case FP_PRAGMA_OPTIONS:
3162 // Later tables overwrite earlier ones.
3163 FPPragmaOptions.swap(Record);
3166 case OPENCL_EXTENSIONS:
3167 // Later tables overwrite earlier ones.
3168 OpenCLExtensions.swap(Record);
3171 case TENTATIVE_DEFINITIONS:
3172 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3173 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3176 case KNOWN_NAMESPACES:
3177 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3178 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3181 case UNDEFINED_BUT_USED:
3182 if (UndefinedButUsed.size() % 2 != 0) {
3183 Error("Invalid existing UndefinedButUsed");
3187 if (Record.size() % 2 != 0) {
3188 Error("invalid undefined-but-used record");
3191 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3192 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3193 UndefinedButUsed.push_back(
3194 ReadSourceLocation(F, Record, I).getRawEncoding());
3197 case DELETE_EXPRS_TO_ANALYZE:
3198 for (unsigned I = 0, N = Record.size(); I != N;) {
3199 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3200 const uint64_t Count = Record[I++];
3201 DelayedDeleteExprs.push_back(Count);
3202 for (uint64_t C = 0; C < Count; ++C) {
3203 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3204 bool IsArrayForm = Record[I++] == 1;
3205 DelayedDeleteExprs.push_back(IsArrayForm);
3210 case IMPORTED_MODULES: {
3211 if (!F.isModule()) {
3212 // If we aren't loading a module (which has its own exports), make
3213 // all of the imported modules visible.
3214 // FIXME: Deal with macros-only imports.
3215 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3216 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3217 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3219 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3225 case MACRO_OFFSET: {
3226 if (F.LocalNumMacros != 0) {
3227 Error("duplicate MACRO_OFFSET record in AST file");
3230 F.MacroOffsets = (const uint32_t *)Blob.data();
3231 F.LocalNumMacros = Record[0];
3232 unsigned LocalBaseMacroID = Record[1];
3233 F.BaseMacroID = getTotalNumMacros();
3235 if (F.LocalNumMacros > 0) {
3236 // Introduce the global -> local mapping for macros within this module.
3237 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3239 // Introduce the local -> global mapping for macros within this module.
3240 F.MacroRemap.insertOrReplace(
3241 std::make_pair(LocalBaseMacroID,
3242 F.BaseMacroID - LocalBaseMacroID));
3244 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3249 case LATE_PARSED_TEMPLATE: {
3250 LateParsedTemplates.append(Record.begin(), Record.end());
3254 case OPTIMIZE_PRAGMA_OPTIONS:
3255 if (Record.size() != 1) {
3256 Error("invalid pragma optimize record");
3259 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3262 case MSSTRUCT_PRAGMA_OPTIONS:
3263 if (Record.size() != 1) {
3264 Error("invalid pragma ms_struct record");
3267 PragmaMSStructState = Record[0];
3270 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3271 if (Record.size() != 2) {
3272 Error("invalid pragma ms_struct record");
3275 PragmaMSPointersToMembersState = Record[0];
3276 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3279 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3280 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3281 UnusedLocalTypedefNameCandidates.push_back(
3282 getGlobalDeclID(F, Record[I]));
3285 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3286 if (Record.size() != 1) {
3287 Error("invalid cuda pragma options record");
3290 ForceCUDAHostDeviceDepth = Record[0];
3296 ASTReader::ASTReadResult
3297 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3298 const ModuleFile *ImportedBy,
3299 unsigned ClientLoadCapabilities) {
3301 F.ModuleMapPath = ReadPath(F, Record, Idx);
3303 if (F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule) {
3304 // For an explicitly-loaded module, we don't care whether the original
3305 // module map file exists or matches.
3309 // Try to resolve ModuleName in the current header search context and
3310 // verify that it is found in the same module map file as we saved. If the
3311 // top-level AST file is a main file, skip this check because there is no
3312 // usable header search context.
3313 assert(!F.ModuleName.empty() &&
3314 "MODULE_NAME should come before MODULE_MAP_FILE");
3315 if (F.Kind == MK_ImplicitModule &&
3316 (*ModuleMgr.begin())->Kind != MK_MainFile) {
3317 // An implicitly-loaded module file should have its module listed in some
3318 // module map file that we've already loaded.
3319 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3320 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3321 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3323 assert(ImportedBy && "top-level import should be verified");
3324 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3325 if (auto *ASTFE = M ? M->getASTFile() : nullptr)
3326 // This module was defined by an imported (explicit) module.
3327 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3328 << ASTFE->getName();
3330 // This module was built with a different module map.
3331 Diag(diag::err_imported_module_not_found)
3332 << F.ModuleName << F.FileName << ImportedBy->FileName
3338 assert(M->Name == F.ModuleName && "found module with different name");
3340 // Check the primary module map file.
3341 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3342 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3343 assert(ModMap && "found module is missing module map file");
3344 assert(ImportedBy && "top-level import should be verified");
3345 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3346 Diag(diag::err_imported_module_modmap_changed)
3347 << F.ModuleName << ImportedBy->FileName
3348 << ModMap->getName() << F.ModuleMapPath;
3352 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3353 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3354 // FIXME: we should use input files rather than storing names.
3355 std::string Filename = ReadPath(F, Record, Idx);
3356 const FileEntry *F =
3357 FileMgr.getFile(Filename, false, false);
3359 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3360 Error("could not find file '" + Filename +"' referenced by AST file");
3363 AdditionalStoredMaps.insert(F);
3366 // Check any additional module map files (e.g. module.private.modulemap)
3367 // that are not in the pcm.
3368 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3369 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3370 // Remove files that match
3371 // Note: SmallPtrSet::erase is really remove
3372 if (!AdditionalStoredMaps.erase(ModMap)) {
3373 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3374 Diag(diag::err_module_different_modmap)
3375 << F.ModuleName << /*new*/0 << ModMap->getName();
3381 // Check any additional module map files that are in the pcm, but not
3382 // found in header search. Cases that match are already removed.
3383 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3384 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3385 Diag(diag::err_module_different_modmap)
3386 << F.ModuleName << /*not new*/1 << ModMap->getName();
3392 Listener->ReadModuleMapFile(F.ModuleMapPath);
3397 /// \brief Move the given method to the back of the global list of methods.
3398 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3399 // Find the entry for this selector in the method pool.
3400 Sema::GlobalMethodPool::iterator Known
3401 = S.MethodPool.find(Method->getSelector());
3402 if (Known == S.MethodPool.end())
3405 // Retrieve the appropriate method list.
3406 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3407 : Known->second.second;
3409 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3411 if (List->getMethod() == Method) {
3419 if (List->getNext())
3420 List->setMethod(List->getNext()->getMethod());
3422 List->setMethod(Method);
3426 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3427 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3428 for (Decl *D : Names) {
3429 bool wasHidden = D->Hidden;
3432 if (wasHidden && SemaObj) {
3433 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3434 moveMethodToBackOfGlobalList(*SemaObj, Method);
3440 void ASTReader::makeModuleVisible(Module *Mod,
3441 Module::NameVisibilityKind NameVisibility,
3442 SourceLocation ImportLoc) {
3443 llvm::SmallPtrSet<Module *, 4> Visited;
3444 SmallVector<Module *, 4> Stack;
3445 Stack.push_back(Mod);
3446 while (!Stack.empty()) {
3447 Mod = Stack.pop_back_val();
3449 if (NameVisibility <= Mod->NameVisibility) {
3450 // This module already has this level of visibility (or greater), so
3451 // there is nothing more to do.
3455 if (!Mod->isAvailable()) {
3456 // Modules that aren't available cannot be made visible.
3460 // Update the module's name visibility.
3461 Mod->NameVisibility = NameVisibility;
3463 // If we've already deserialized any names from this module,
3464 // mark them as visible.
3465 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3466 if (Hidden != HiddenNamesMap.end()) {
3467 auto HiddenNames = std::move(*Hidden);
3468 HiddenNamesMap.erase(Hidden);
3469 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3470 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3471 "making names visible added hidden names");
3474 // Push any exported modules onto the stack to be marked as visible.
3475 SmallVector<Module *, 16> Exports;
3476 Mod->getExportedModules(Exports);
3477 for (SmallVectorImpl<Module *>::iterator
3478 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3479 Module *Exported = *I;
3480 if (Visited.insert(Exported).second)
3481 Stack.push_back(Exported);
3486 /// We've merged the definition \p MergedDef into the existing definition
3487 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3489 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
3490 NamedDecl *MergedDef) {
3491 // FIXME: This doesn't correctly handle the case where MergedDef is visible
3492 // in modules other than its owning module. We should instead give the
3493 // ASTContext a list of merged definitions for Def.
3494 if (Def->isHidden()) {
3495 // If MergedDef is visible or becomes visible, make the definition visible.
3496 if (!MergedDef->isHidden())
3497 Def->Hidden = false;
3498 else if (getContext().getLangOpts().ModulesLocalVisibility) {
3499 getContext().mergeDefinitionIntoModule(
3500 Def, MergedDef->getImportedOwningModule(),
3501 /*NotifyListeners*/ false);
3502 PendingMergedDefinitionsToDeduplicate.insert(Def);
3504 auto SubmoduleID = MergedDef->getOwningModuleID();
3505 assert(SubmoduleID && "hidden definition in no module");
3506 HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
3511 bool ASTReader::loadGlobalIndex() {
3515 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3516 !Context.getLangOpts().Modules)
3519 // Try to load the global index.
3520 TriedLoadingGlobalIndex = true;
3521 StringRef ModuleCachePath
3522 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3523 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3524 = GlobalModuleIndex::readIndex(ModuleCachePath);
3528 GlobalIndex.reset(Result.first);
3529 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3533 bool ASTReader::isGlobalIndexUnavailable() const {
3534 return Context.getLangOpts().Modules && UseGlobalIndex &&
3535 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3538 static void updateModuleTimestamp(ModuleFile &MF) {
3539 // Overwrite the timestamp file contents so that file's mtime changes.
3540 std::string TimestampFilename = MF.getTimestampFilename();
3542 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3545 OS << "Timestamp file\n";
3548 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3549 /// cursor into the start of the given block ID, returning false on success and
3550 /// true on failure.
3551 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3553 llvm::BitstreamEntry Entry = Cursor.advance();
3554 switch (Entry.Kind) {
3555 case llvm::BitstreamEntry::Error:
3556 case llvm::BitstreamEntry::EndBlock:
3559 case llvm::BitstreamEntry::Record:
3560 // Ignore top-level records.
3561 Cursor.skipRecord(Entry.ID);
3564 case llvm::BitstreamEntry::SubBlock:
3565 if (Entry.ID == BlockID) {
3566 if (Cursor.EnterSubBlock(BlockID))
3572 if (Cursor.SkipBlock())
3578 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3580 SourceLocation ImportLoc,
3581 unsigned ClientLoadCapabilities,
3582 SmallVectorImpl<ImportedSubmodule> *Imported) {
3583 llvm::SaveAndRestore<SourceLocation>
3584 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3586 // Defer any pending actions until we get to the end of reading the AST file.
3587 Deserializing AnASTFile(this);
3589 // Bump the generation number.
3590 unsigned PreviousGeneration = incrementGeneration(Context);
3592 unsigned NumModules = ModuleMgr.size();
3593 SmallVector<ImportedModule, 4> Loaded;
3594 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
3595 /*ImportedBy=*/nullptr, Loaded,
3597 ClientLoadCapabilities)) {
3601 case VersionMismatch:
3602 case ConfigurationMismatch:
3604 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3605 for (const ImportedModule &IM : Loaded)
3606 LoadedSet.insert(IM.Mod);
3608 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
3610 Context.getLangOpts().Modules
3611 ? &PP.getHeaderSearchInfo().getModuleMap()
3614 // If we find that any modules are unusable, the global index is going
3615 // to be out-of-date. Just remove it.
3616 GlobalIndex.reset();
3617 ModuleMgr.setGlobalIndex(nullptr);
3624 // Here comes stuff that we only do once the entire chain is loaded.
3626 // Load the AST blocks of all of the modules that we loaded.
3627 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3628 MEnd = Loaded.end();
3630 ModuleFile &F = *M->Mod;
3632 // Read the AST block.
3633 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3636 // Read the extension blocks.
3637 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3638 if (ASTReadResult Result = ReadExtensionBlock(F))
3642 // Once read, set the ModuleFile bit base offset and update the size in
3643 // bits of all files we've seen.
3644 F.GlobalBitOffset = TotalModulesSizeInBits;
3645 TotalModulesSizeInBits += F.SizeInBits;
3646 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3648 // Preload SLocEntries.
3649 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3650 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3651 // Load it through the SourceManager and don't call ReadSLocEntry()
3652 // directly because the entry may have already been loaded in which case
3653 // calling ReadSLocEntry() directly would trigger an assertion in
3655 SourceMgr.getLoadedSLocEntryByID(Index);
3658 // Preload all the pending interesting identifiers by marking them out of
3660 for (auto Offset : F.PreloadIdentifierOffsets) {
3661 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3662 F.IdentifierTableData + Offset);
3664 ASTIdentifierLookupTrait Trait(*this, F);
3665 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3666 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3667 auto &II = PP.getIdentifierTable().getOwn(Key);
3668 II.setOutOfDate(true);
3670 // Mark this identifier as being from an AST file so that we can track
3671 // whether we need to serialize it.
3672 markIdentifierFromAST(*this, II);
3674 // Associate the ID with the identifier so that the writer can reuse it.
3675 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3676 SetIdentifierInfo(ID, &II);
3680 // Setup the import locations and notify the module manager that we've
3681 // committed to these module files.
3682 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3683 MEnd = Loaded.end();
3685 ModuleFile &F = *M->Mod;
3687 ModuleMgr.moduleFileAccepted(&F);
3689 // Set the import location.
3690 F.DirectImportLoc = ImportLoc;
3691 // FIXME: We assume that locations from PCH / preamble do not need
3694 F.ImportLoc = M->ImportLoc;
3696 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3699 if (!Context.getLangOpts().CPlusPlus ||
3700 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
3701 Type != MK_PrebuiltModule)) {
3702 // Mark all of the identifiers in the identifier table as being out of date,
3703 // so that various accessors know to check the loaded modules when the
3704 // identifier is used.
3706 // For C++ modules, we don't need information on many identifiers (just
3707 // those that provide macros or are poisoned), so we mark all of
3708 // the interesting ones via PreloadIdentifierOffsets.
3709 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3710 IdEnd = PP.getIdentifierTable().end();
3712 Id->second->setOutOfDate(true);
3714 // Mark selectors as out of date.
3715 for (auto Sel : SelectorGeneration)
3716 SelectorOutOfDate[Sel.first] = true;
3718 // Resolve any unresolved module exports.
3719 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3720 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3721 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3722 Module *ResolvedMod = getSubmodule(GlobalID);
3724 switch (Unresolved.Kind) {
3725 case UnresolvedModuleRef::Conflict:
3727 Module::Conflict Conflict;
3728 Conflict.Other = ResolvedMod;
3729 Conflict.Message = Unresolved.String.str();
3730 Unresolved.Mod->Conflicts.push_back(Conflict);
3734 case UnresolvedModuleRef::Import:
3736 Unresolved.Mod->Imports.insert(ResolvedMod);
3739 case UnresolvedModuleRef::Export:
3740 if (ResolvedMod || Unresolved.IsWildcard)
3741 Unresolved.Mod->Exports.push_back(
3742 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3746 UnresolvedModuleRefs.clear();
3749 Imported->append(ImportedModules.begin(),
3750 ImportedModules.end());
3752 // FIXME: How do we load the 'use'd modules? They may not be submodules.
3753 // Might be unnecessary as use declarations are only used to build the
3756 InitializeContext();
3761 if (DeserializationListener)
3762 DeserializationListener->ReaderInitialized(this);
3764 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3765 if (PrimaryModule.OriginalSourceFileID.isValid()) {
3766 PrimaryModule.OriginalSourceFileID
3767 = FileID::get(PrimaryModule.SLocEntryBaseID
3768 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3770 // If this AST file is a precompiled preamble, then set the
3771 // preamble file ID of the source manager to the file source file
3772 // from which the preamble was built.
3773 if (Type == MK_Preamble) {
3774 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3775 } else if (Type == MK_MainFile) {
3776 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3780 // For any Objective-C class definitions we have already loaded, make sure
3781 // that we load any additional categories.
3782 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3783 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3784 ObjCClassesLoaded[I],
3785 PreviousGeneration);
3788 if (PP.getHeaderSearchInfo()
3789 .getHeaderSearchOpts()
3790 .ModulesValidateOncePerBuildSession) {
3791 // Now we are certain that the module and all modules it depends on are
3792 // up to date. Create or update timestamp files for modules that are
3793 // located in the module cache (not for PCH files that could be anywhere
3794 // in the filesystem).
3795 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3796 ImportedModule &M = Loaded[I];
3797 if (M.Mod->Kind == MK_ImplicitModule) {
3798 updateModuleTimestamp(*M.Mod);
3806 static ASTFileSignature readASTFileSignature(StringRef PCH);
3808 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
3809 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
3810 return Stream.canSkipToPos(4) &&
3811 Stream.Read(8) == 'C' &&
3812 Stream.Read(8) == 'P' &&
3813 Stream.Read(8) == 'C' &&
3814 Stream.Read(8) == 'H';
3817 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
3821 case MK_ImplicitModule:
3822 case MK_ExplicitModule:
3823 case MK_PrebuiltModule:
3827 return 2; // main source file
3829 llvm_unreachable("unknown module kind");
3832 ASTReader::ASTReadResult
3833 ASTReader::ReadASTCore(StringRef FileName,
3835 SourceLocation ImportLoc,
3836 ModuleFile *ImportedBy,
3837 SmallVectorImpl<ImportedModule> &Loaded,
3838 off_t ExpectedSize, time_t ExpectedModTime,
3839 ASTFileSignature ExpectedSignature,
3840 unsigned ClientLoadCapabilities) {
3842 std::string ErrorStr;
3843 ModuleManager::AddModuleResult AddResult
3844 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
3845 getGeneration(), ExpectedSize, ExpectedModTime,
3846 ExpectedSignature, readASTFileSignature,
3849 switch (AddResult) {
3850 case ModuleManager::AlreadyLoaded:
3853 case ModuleManager::NewlyLoaded:
3854 // Load module file below.
3857 case ModuleManager::Missing:
3858 // The module file was missing; if the client can handle that, return
3860 if (ClientLoadCapabilities & ARR_Missing)
3863 // Otherwise, return an error.
3864 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
3865 << FileName << !ErrorStr.empty()
3869 case ModuleManager::OutOfDate:
3870 // We couldn't load the module file because it is out-of-date. If the
3871 // client can handle out-of-date, return it.
3872 if (ClientLoadCapabilities & ARR_OutOfDate)
3875 // Otherwise, return an error.
3876 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
3877 << FileName << !ErrorStr.empty()
3882 assert(M && "Missing module file");
3884 // FIXME: This seems rather a hack. Should CurrentDir be part of the
3886 if (FileName != "-") {
3887 CurrentDir = llvm::sys::path::parent_path(FileName);
3888 if (CurrentDir.empty()) CurrentDir = ".";
3892 BitstreamCursor &Stream = F.Stream;
3893 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
3894 F.SizeInBits = F.Buffer->getBufferSize() * 8;
3896 // Sniff for the signature.
3897 if (!startsWithASTFileMagic(Stream)) {
3898 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
3903 // This is used for compatibility with older PCH formats.
3904 bool HaveReadControlBlock = false;
3906 llvm::BitstreamEntry Entry = Stream.advance();
3908 switch (Entry.Kind) {
3909 case llvm::BitstreamEntry::Error:
3910 case llvm::BitstreamEntry::Record:
3911 case llvm::BitstreamEntry::EndBlock:
3912 Error("invalid record at top-level of AST file");
3915 case llvm::BitstreamEntry::SubBlock:
3920 case CONTROL_BLOCK_ID:
3921 HaveReadControlBlock = true;
3922 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
3924 // Check that we didn't try to load a non-module AST file as a module.
3926 // FIXME: Should we also perform the converse check? Loading a module as
3927 // a PCH file sort of works, but it's a bit wonky.
3928 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
3929 Type == MK_PrebuiltModule) &&
3930 F.ModuleName.empty()) {
3931 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
3932 if (Result != OutOfDate ||
3933 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
3934 Diag(diag::err_module_file_not_module) << FileName;
3939 case Failure: return Failure;
3940 case Missing: return Missing;
3941 case OutOfDate: return OutOfDate;
3942 case VersionMismatch: return VersionMismatch;
3943 case ConfigurationMismatch: return ConfigurationMismatch;
3944 case HadErrors: return HadErrors;
3949 if (!HaveReadControlBlock) {
3950 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3951 Diag(diag::err_pch_version_too_old);
3952 return VersionMismatch;
3955 // Record that we've loaded this module.
3956 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3960 if (Stream.SkipBlock()) {
3961 Error("malformed block record in AST file");
3971 /// Parse a record and blob containing module file extension metadata.
3972 static bool parseModuleFileExtensionMetadata(
3973 const SmallVectorImpl<uint64_t> &Record,
3975 ModuleFileExtensionMetadata &Metadata) {
3976 if (Record.size() < 4) return true;
3978 Metadata.MajorVersion = Record[0];
3979 Metadata.MinorVersion = Record[1];
3981 unsigned BlockNameLen = Record[2];
3982 unsigned UserInfoLen = Record[3];
3984 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
3986 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
3987 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
3988 Blob.data() + BlockNameLen + UserInfoLen);
3992 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
3993 BitstreamCursor &Stream = F.Stream;
3997 llvm::BitstreamEntry Entry = Stream.advance();
3998 switch (Entry.Kind) {
3999 case llvm::BitstreamEntry::SubBlock:
4000 if (Stream.SkipBlock())
4005 case llvm::BitstreamEntry::EndBlock:
4008 case llvm::BitstreamEntry::Error:
4011 case llvm::BitstreamEntry::Record:
4017 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4019 case EXTENSION_METADATA: {
4020 ModuleFileExtensionMetadata Metadata;
4021 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4024 // Find a module file extension with this block name.
4025 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4026 if (Known == ModuleFileExtensions.end()) break;
4029 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4031 F.ExtensionReaders.push_back(std::move(Reader));
4042 void ASTReader::InitializeContext() {
4043 // If there's a listener, notify them that we "read" the translation unit.
4044 if (DeserializationListener)
4045 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4046 Context.getTranslationUnitDecl());
4048 // FIXME: Find a better way to deal with collisions between these
4049 // built-in types. Right now, we just ignore the problem.
4051 // Load the special types.
4052 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4053 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4054 if (!Context.CFConstantStringTypeDecl)
4055 Context.setCFConstantStringType(GetType(String));
4058 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4059 QualType FileType = GetType(File);
4060 if (FileType.isNull()) {
4061 Error("FILE type is NULL");
4065 if (!Context.FILEDecl) {
4066 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4067 Context.setFILEDecl(Typedef->getDecl());
4069 const TagType *Tag = FileType->getAs<TagType>();
4071 Error("Invalid FILE type in AST file");
4074 Context.setFILEDecl(Tag->getDecl());
4079 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4080 QualType Jmp_bufType = GetType(Jmp_buf);
4081 if (Jmp_bufType.isNull()) {
4082 Error("jmp_buf type is NULL");
4086 if (!Context.jmp_bufDecl) {
4087 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4088 Context.setjmp_bufDecl(Typedef->getDecl());
4090 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4092 Error("Invalid jmp_buf type in AST file");
4095 Context.setjmp_bufDecl(Tag->getDecl());
4100 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4101 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4102 if (Sigjmp_bufType.isNull()) {
4103 Error("sigjmp_buf type is NULL");
4107 if (!Context.sigjmp_bufDecl) {
4108 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4109 Context.setsigjmp_bufDecl(Typedef->getDecl());
4111 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4112 assert(Tag && "Invalid sigjmp_buf type in AST file");
4113 Context.setsigjmp_bufDecl(Tag->getDecl());
4118 if (unsigned ObjCIdRedef
4119 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4120 if (Context.ObjCIdRedefinitionType.isNull())
4121 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4124 if (unsigned ObjCClassRedef
4125 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4126 if (Context.ObjCClassRedefinitionType.isNull())
4127 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4130 if (unsigned ObjCSelRedef
4131 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4132 if (Context.ObjCSelRedefinitionType.isNull())
4133 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4136 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4137 QualType Ucontext_tType = GetType(Ucontext_t);
4138 if (Ucontext_tType.isNull()) {
4139 Error("ucontext_t type is NULL");
4143 if (!Context.ucontext_tDecl) {
4144 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4145 Context.setucontext_tDecl(Typedef->getDecl());
4147 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4148 assert(Tag && "Invalid ucontext_t type in AST file");
4149 Context.setucontext_tDecl(Tag->getDecl());
4155 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4157 // If there were any CUDA special declarations, deserialize them.
4158 if (!CUDASpecialDeclRefs.empty()) {
4159 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4160 Context.setcudaConfigureCallDecl(
4161 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4164 // Re-export any modules that were imported by a non-module AST file.
4165 // FIXME: This does not make macro-only imports visible again.
4166 for (auto &Import : ImportedModules) {
4167 if (Module *Imported = getSubmodule(Import.ID)) {
4168 makeModuleVisible(Imported, Module::AllVisible,
4169 /*ImportLoc=*/Import.ImportLoc);
4170 if (Import.ImportLoc.isValid())
4171 PP.makeModuleVisible(Imported, Import.ImportLoc);
4172 // FIXME: should we tell Sema to make the module visible too?
4175 ImportedModules.clear();
4178 void ASTReader::finalizeForWriting() {
4179 // Nothing to do for now.
4182 /// \brief Reads and return the signature record from \p PCH's control block, or
4184 static ASTFileSignature readASTFileSignature(StringRef PCH) {
4185 BitstreamCursor Stream(PCH);
4186 if (!startsWithASTFileMagic(Stream))
4189 // Scan for the CONTROL_BLOCK_ID block.
4190 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4193 // Scan for SIGNATURE inside the control block.
4194 ASTReader::RecordData Record;
4196 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4197 if (Entry.Kind != llvm::BitstreamEntry::Record)
4202 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4207 /// \brief Retrieve the name of the original source file name
4208 /// directly from the AST file, without actually loading the AST
4210 std::string ASTReader::getOriginalSourceFile(
4211 const std::string &ASTFileName, FileManager &FileMgr,
4212 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4213 // Open the AST file.
4214 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4216 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4217 << ASTFileName << Buffer.getError().message();
4218 return std::string();
4221 // Initialize the stream
4222 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4224 // Sniff for the signature.
4225 if (!startsWithASTFileMagic(Stream)) {
4226 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4227 return std::string();
4230 // Scan for the CONTROL_BLOCK_ID block.
4231 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4232 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4233 return std::string();
4236 // Scan for ORIGINAL_FILE inside the control block.
4239 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4240 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4241 return std::string();
4243 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4244 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4245 return std::string();
4250 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4257 class SimplePCHValidator : public ASTReaderListener {
4258 const LangOptions &ExistingLangOpts;
4259 const TargetOptions &ExistingTargetOpts;
4260 const PreprocessorOptions &ExistingPPOpts;
4261 std::string ExistingModuleCachePath;
4262 FileManager &FileMgr;
4265 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4266 const TargetOptions &ExistingTargetOpts,
4267 const PreprocessorOptions &ExistingPPOpts,
4268 StringRef ExistingModuleCachePath,
4269 FileManager &FileMgr)
4270 : ExistingLangOpts(ExistingLangOpts),
4271 ExistingTargetOpts(ExistingTargetOpts),
4272 ExistingPPOpts(ExistingPPOpts),
4273 ExistingModuleCachePath(ExistingModuleCachePath),
4278 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4279 bool AllowCompatibleDifferences) override {
4280 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4281 AllowCompatibleDifferences);
4284 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4285 bool AllowCompatibleDifferences) override {
4286 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4287 AllowCompatibleDifferences);
4290 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4291 StringRef SpecificModuleCachePath,
4292 bool Complain) override {
4293 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4294 ExistingModuleCachePath,
4295 nullptr, ExistingLangOpts);
4298 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4300 std::string &SuggestedPredefines) override {
4301 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4302 SuggestedPredefines, ExistingLangOpts);
4306 } // end anonymous namespace
4308 bool ASTReader::readASTFileControlBlock(
4309 StringRef Filename, FileManager &FileMgr,
4310 const PCHContainerReader &PCHContainerRdr,
4311 bool FindModuleFileExtensions,
4312 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4313 // Open the AST file.
4314 // FIXME: This allows use of the VFS; we do not allow use of the
4315 // VFS when actually loading a module.
4316 auto Buffer = FileMgr.getBufferForFile(Filename);
4321 // Initialize the stream
4322 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4324 // Sniff for the signature.
4325 if (!startsWithASTFileMagic(Stream))
4328 // Scan for the CONTROL_BLOCK_ID block.
4329 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4332 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4333 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4334 bool NeedsImports = Listener.needsImportVisitation();
4335 BitstreamCursor InputFilesCursor;
4338 std::string ModuleDir;
4339 bool DoneWithControlBlock = false;
4340 while (!DoneWithControlBlock) {
4341 llvm::BitstreamEntry Entry = Stream.advance();
4343 switch (Entry.Kind) {
4344 case llvm::BitstreamEntry::SubBlock: {
4346 case OPTIONS_BLOCK_ID: {
4347 std::string IgnoredSuggestedPredefines;
4348 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4349 /*AllowCompatibleConfigurationMismatch*/ false,
4350 Listener, IgnoredSuggestedPredefines,
4351 ValidateDiagnosticOptions) != Success)
4356 case INPUT_FILES_BLOCK_ID:
4357 InputFilesCursor = Stream;
4358 if (Stream.SkipBlock() ||
4360 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4365 if (Stream.SkipBlock())
4373 case llvm::BitstreamEntry::EndBlock:
4374 DoneWithControlBlock = true;
4377 case llvm::BitstreamEntry::Error:
4380 case llvm::BitstreamEntry::Record:
4384 if (DoneWithControlBlock) break;
4388 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4389 switch ((ControlRecordTypes)RecCode) {
4391 if (Record[0] != VERSION_MAJOR)
4394 if (Listener.ReadFullVersionInformation(Blob))
4400 Listener.ReadModuleName(Blob);
4402 case MODULE_DIRECTORY:
4405 case MODULE_MAP_FILE: {
4407 auto Path = ReadString(Record, Idx);
4408 ResolveImportedPath(Path, ModuleDir);
4409 Listener.ReadModuleMapFile(Path);
4412 case INPUT_FILE_OFFSETS: {
4413 if (!NeedsInputFiles)
4416 unsigned NumInputFiles = Record[0];
4417 unsigned NumUserFiles = Record[1];
4418 const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
4419 for (unsigned I = 0; I != NumInputFiles; ++I) {
4420 // Go find this input file.
4421 bool isSystemFile = I >= NumUserFiles;
4423 if (isSystemFile && !NeedsSystemInputFiles)
4424 break; // the rest are system input files
4426 BitstreamCursor &Cursor = InputFilesCursor;
4427 SavedStreamPosition SavedPosition(Cursor);
4428 Cursor.JumpToBit(InputFileOffs[I]);
4430 unsigned Code = Cursor.ReadCode();
4433 bool shouldContinue = false;
4434 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4436 bool Overridden = static_cast<bool>(Record[3]);
4437 std::string Filename = Blob;
4438 ResolveImportedPath(Filename, ModuleDir);
4439 shouldContinue = Listener.visitInputFile(
4440 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4443 if (!shouldContinue)
4453 unsigned Idx = 0, N = Record.size();
4455 // Read information about the AST file.
4456 Idx += 5; // ImportLoc, Size, ModTime, Signature
4457 std::string Filename = ReadString(Record, Idx);
4458 ResolveImportedPath(Filename, ModuleDir);
4459 Listener.visitImport(Filename);
4465 // No other validation to perform.
4470 // Look for module file extension blocks, if requested.
4471 if (FindModuleFileExtensions) {
4472 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4473 bool DoneWithExtensionBlock = false;
4474 while (!DoneWithExtensionBlock) {
4475 llvm::BitstreamEntry Entry = Stream.advance();
4477 switch (Entry.Kind) {
4478 case llvm::BitstreamEntry::SubBlock:
4479 if (Stream.SkipBlock())
4484 case llvm::BitstreamEntry::EndBlock:
4485 DoneWithExtensionBlock = true;
4488 case llvm::BitstreamEntry::Error:
4491 case llvm::BitstreamEntry::Record:
4497 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4499 case EXTENSION_METADATA: {
4500 ModuleFileExtensionMetadata Metadata;
4501 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4504 Listener.readModuleFileExtension(Metadata);
4515 bool ASTReader::isAcceptableASTFile(
4516 StringRef Filename, FileManager &FileMgr,
4517 const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts,
4518 const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts,
4519 std::string ExistingModuleCachePath) {
4520 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4521 ExistingModuleCachePath, FileMgr);
4522 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4523 /*FindModuleFileExtensions=*/false,
4525 /*ValidateDiagnosticOptions=*/true);
4528 ASTReader::ASTReadResult
4529 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4530 // Enter the submodule block.
4531 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4532 Error("malformed submodule block record in AST file");
4536 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4538 Module *CurrentModule = nullptr;
4541 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4543 switch (Entry.Kind) {
4544 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4545 case llvm::BitstreamEntry::Error:
4546 Error("malformed block record in AST file");
4548 case llvm::BitstreamEntry::EndBlock:
4550 case llvm::BitstreamEntry::Record:
4551 // The interesting case.
4558 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4560 if ((Kind == SUBMODULE_METADATA) != First) {
4561 Error("submodule metadata record should be at beginning of block");
4566 // Submodule information is only valid if we have a current module.
4567 // FIXME: Should we error on these cases?
4568 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4569 Kind != SUBMODULE_DEFINITION)
4573 default: // Default behavior: ignore.
4576 case SUBMODULE_DEFINITION: {
4577 if (Record.size() < 8) {
4578 Error("malformed module definition");
4582 StringRef Name = Blob;
4584 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4585 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4586 bool IsFramework = Record[Idx++];
4587 bool IsExplicit = Record[Idx++];
4588 bool IsSystem = Record[Idx++];
4589 bool IsExternC = Record[Idx++];
4590 bool InferSubmodules = Record[Idx++];
4591 bool InferExplicitSubmodules = Record[Idx++];
4592 bool InferExportWildcard = Record[Idx++];
4593 bool ConfigMacrosExhaustive = Record[Idx++];
4595 Module *ParentModule = nullptr;
4597 ParentModule = getSubmodule(Parent);
4599 // Retrieve this (sub)module from the module map, creating it if
4601 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
4604 // FIXME: set the definition loc for CurrentModule, or call
4605 // ModMap.setInferredModuleAllowedBy()
4607 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4608 if (GlobalIndex >= SubmodulesLoaded.size() ||
4609 SubmodulesLoaded[GlobalIndex]) {
4610 Error("too many submodules");
4614 if (!ParentModule) {
4615 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4616 if (CurFile != F.File) {
4617 if (!Diags.isDiagnosticInFlight()) {
4618 Diag(diag::err_module_file_conflict)
4619 << CurrentModule->getTopLevelModuleName()
4620 << CurFile->getName()
4621 << F.File->getName();
4627 CurrentModule->setASTFile(F.File);
4630 CurrentModule->Signature = F.Signature;
4631 CurrentModule->IsFromModuleFile = true;
4632 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4633 CurrentModule->IsExternC = IsExternC;
4634 CurrentModule->InferSubmodules = InferSubmodules;
4635 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4636 CurrentModule->InferExportWildcard = InferExportWildcard;
4637 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4638 if (DeserializationListener)
4639 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4641 SubmodulesLoaded[GlobalIndex] = CurrentModule;
4643 // Clear out data that will be replaced by what is in the module file.
4644 CurrentModule->LinkLibraries.clear();
4645 CurrentModule->ConfigMacros.clear();
4646 CurrentModule->UnresolvedConflicts.clear();
4647 CurrentModule->Conflicts.clear();
4649 // The module is available unless it's missing a requirement; relevant
4650 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
4651 // Missing headers that were present when the module was built do not
4652 // make it unavailable -- if we got this far, this must be an explicitly
4653 // imported module file.
4654 CurrentModule->Requirements.clear();
4655 CurrentModule->MissingHeaders.clear();
4656 CurrentModule->IsMissingRequirement =
4657 ParentModule && ParentModule->IsMissingRequirement;
4658 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
4662 case SUBMODULE_UMBRELLA_HEADER: {
4663 std::string Filename = Blob;
4664 ResolveImportedPath(F, Filename);
4665 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
4666 if (!CurrentModule->getUmbrellaHeader())
4667 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
4668 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
4669 // This can be a spurious difference caused by changing the VFS to
4670 // point to a different copy of the file, and it is too late to
4671 // to rebuild safely.
4672 // FIXME: If we wrote the virtual paths instead of the 'real' paths,
4673 // after input file validation only real problems would remain and we
4674 // could just error. For now, assume it's okay.
4681 case SUBMODULE_HEADER:
4682 case SUBMODULE_EXCLUDED_HEADER:
4683 case SUBMODULE_PRIVATE_HEADER:
4684 // We lazily associate headers with their modules via the HeaderInfo table.
4685 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4686 // of complete filenames or remove it entirely.
4689 case SUBMODULE_TEXTUAL_HEADER:
4690 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
4691 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
4695 case SUBMODULE_TOPHEADER: {
4696 CurrentModule->addTopHeaderFilename(Blob);
4700 case SUBMODULE_UMBRELLA_DIR: {
4701 std::string Dirname = Blob;
4702 ResolveImportedPath(F, Dirname);
4703 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
4704 if (!CurrentModule->getUmbrellaDir())
4705 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
4706 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
4707 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4708 Error("mismatched umbrella directories in submodule");
4715 case SUBMODULE_METADATA: {
4716 F.BaseSubmoduleID = getTotalNumSubmodules();
4717 F.LocalNumSubmodules = Record[0];
4718 unsigned LocalBaseSubmoduleID = Record[1];
4719 if (F.LocalNumSubmodules > 0) {
4720 // Introduce the global -> local mapping for submodules within this
4722 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4724 // Introduce the local -> global mapping for submodules within this
4726 F.SubmoduleRemap.insertOrReplace(
4727 std::make_pair(LocalBaseSubmoduleID,
4728 F.BaseSubmoduleID - LocalBaseSubmoduleID));
4730 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
4735 case SUBMODULE_IMPORTS: {
4736 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
4737 UnresolvedModuleRef Unresolved;
4738 Unresolved.File = &F;
4739 Unresolved.Mod = CurrentModule;
4740 Unresolved.ID = Record[Idx];
4741 Unresolved.Kind = UnresolvedModuleRef::Import;
4742 Unresolved.IsWildcard = false;
4743 UnresolvedModuleRefs.push_back(Unresolved);
4748 case SUBMODULE_EXPORTS: {
4749 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
4750 UnresolvedModuleRef Unresolved;
4751 Unresolved.File = &F;
4752 Unresolved.Mod = CurrentModule;
4753 Unresolved.ID = Record[Idx];
4754 Unresolved.Kind = UnresolvedModuleRef::Export;
4755 Unresolved.IsWildcard = Record[Idx + 1];
4756 UnresolvedModuleRefs.push_back(Unresolved);
4759 // Once we've loaded the set of exports, there's no reason to keep
4760 // the parsed, unresolved exports around.
4761 CurrentModule->UnresolvedExports.clear();
4764 case SUBMODULE_REQUIRES: {
4765 CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
4766 Context.getTargetInfo());
4770 case SUBMODULE_LINK_LIBRARY:
4771 CurrentModule->LinkLibraries.push_back(
4772 Module::LinkLibrary(Blob, Record[0]));
4775 case SUBMODULE_CONFIG_MACRO:
4776 CurrentModule->ConfigMacros.push_back(Blob.str());
4779 case SUBMODULE_CONFLICT: {
4780 UnresolvedModuleRef Unresolved;
4781 Unresolved.File = &F;
4782 Unresolved.Mod = CurrentModule;
4783 Unresolved.ID = Record[0];
4784 Unresolved.Kind = UnresolvedModuleRef::Conflict;
4785 Unresolved.IsWildcard = false;
4786 Unresolved.String = Blob;
4787 UnresolvedModuleRefs.push_back(Unresolved);
4791 case SUBMODULE_INITIALIZERS:
4792 SmallVector<uint32_t, 16> Inits;
4793 for (auto &ID : Record)
4794 Inits.push_back(getGlobalDeclID(F, ID));
4795 Context.addLazyModuleInitializers(CurrentModule, Inits);
4801 /// \brief Parse the record that corresponds to a LangOptions data
4804 /// This routine parses the language options from the AST file and then gives
4805 /// them to the AST listener if one is set.
4807 /// \returns true if the listener deems the file unacceptable, false otherwise.
4808 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4810 ASTReaderListener &Listener,
4811 bool AllowCompatibleDifferences) {
4812 LangOptions LangOpts;
4814 #define LANGOPT(Name, Bits, Default, Description) \
4815 LangOpts.Name = Record[Idx++];
4816 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4817 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4818 #include "clang/Basic/LangOptions.def"
4819 #define SANITIZER(NAME, ID) \
4820 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
4821 #include "clang/Basic/Sanitizers.def"
4823 for (unsigned N = Record[Idx++]; N; --N)
4824 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
4826 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4827 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4828 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
4830 LangOpts.CurrentModule = ReadString(Record, Idx);
4833 for (unsigned N = Record[Idx++]; N; --N) {
4834 LangOpts.CommentOpts.BlockCommandNames.push_back(
4835 ReadString(Record, Idx));
4837 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
4839 // OpenMP offloading options.
4840 for (unsigned N = Record[Idx++]; N; --N) {
4841 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
4844 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
4846 return Listener.ReadLanguageOptions(LangOpts, Complain,
4847 AllowCompatibleDifferences);
4850 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
4851 ASTReaderListener &Listener,
4852 bool AllowCompatibleDifferences) {
4854 TargetOptions TargetOpts;
4855 TargetOpts.Triple = ReadString(Record, Idx);
4856 TargetOpts.CPU = ReadString(Record, Idx);
4857 TargetOpts.ABI = ReadString(Record, Idx);
4858 for (unsigned N = Record[Idx++]; N; --N) {
4859 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4861 for (unsigned N = Record[Idx++]; N; --N) {
4862 TargetOpts.Features.push_back(ReadString(Record, Idx));
4865 return Listener.ReadTargetOptions(TargetOpts, Complain,
4866 AllowCompatibleDifferences);
4869 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4870 ASTReaderListener &Listener) {
4871 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
4873 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
4874 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4875 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
4876 #include "clang/Basic/DiagnosticOptions.def"
4878 for (unsigned N = Record[Idx++]; N; --N)
4879 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
4880 for (unsigned N = Record[Idx++]; N; --N)
4881 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
4883 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4886 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4887 ASTReaderListener &Listener) {
4888 FileSystemOptions FSOpts;
4890 FSOpts.WorkingDir = ReadString(Record, Idx);
4891 return Listener.ReadFileSystemOptions(FSOpts, Complain);
4894 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4896 ASTReaderListener &Listener) {
4897 HeaderSearchOptions HSOpts;
4899 HSOpts.Sysroot = ReadString(Record, Idx);
4902 for (unsigned N = Record[Idx++]; N; --N) {
4903 std::string Path = ReadString(Record, Idx);
4904 frontend::IncludeDirGroup Group
4905 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
4906 bool IsFramework = Record[Idx++];
4907 bool IgnoreSysRoot = Record[Idx++];
4908 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
4912 // System header prefixes.
4913 for (unsigned N = Record[Idx++]; N; --N) {
4914 std::string Prefix = ReadString(Record, Idx);
4915 bool IsSystemHeader = Record[Idx++];
4916 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
4919 HSOpts.ResourceDir = ReadString(Record, Idx);
4920 HSOpts.ModuleCachePath = ReadString(Record, Idx);
4921 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
4922 HSOpts.DisableModuleHash = Record[Idx++];
4923 HSOpts.UseBuiltinIncludes = Record[Idx++];
4924 HSOpts.UseStandardSystemIncludes = Record[Idx++];
4925 HSOpts.UseStandardCXXIncludes = Record[Idx++];
4926 HSOpts.UseLibcxx = Record[Idx++];
4927 std::string SpecificModuleCachePath = ReadString(Record, Idx);
4929 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4933 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4935 ASTReaderListener &Listener,
4936 std::string &SuggestedPredefines) {
4937 PreprocessorOptions PPOpts;
4940 // Macro definitions/undefs
4941 for (unsigned N = Record[Idx++]; N; --N) {
4942 std::string Macro = ReadString(Record, Idx);
4943 bool IsUndef = Record[Idx++];
4944 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4948 for (unsigned N = Record[Idx++]; N; --N) {
4949 PPOpts.Includes.push_back(ReadString(Record, Idx));
4953 for (unsigned N = Record[Idx++]; N; --N) {
4954 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4957 PPOpts.UsePredefines = Record[Idx++];
4958 PPOpts.DetailedRecord = Record[Idx++];
4959 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4960 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4961 PPOpts.ObjCXXARCStandardLibrary =
4962 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4963 SuggestedPredefines.clear();
4964 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4965 SuggestedPredefines);
4968 std::pair<ModuleFile *, unsigned>
4969 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4970 GlobalPreprocessedEntityMapType::iterator
4971 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4972 assert(I != GlobalPreprocessedEntityMap.end() &&
4973 "Corrupted global preprocessed entity map");
4974 ModuleFile *M = I->second;
4975 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4976 return std::make_pair(M, LocalIndex);
4979 llvm::iterator_range<PreprocessingRecord::iterator>
4980 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4981 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4982 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4983 Mod.NumPreprocessedEntities);
4985 return llvm::make_range(PreprocessingRecord::iterator(),
4986 PreprocessingRecord::iterator());
4989 llvm::iterator_range<ASTReader::ModuleDeclIterator>
4990 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
4991 return llvm::make_range(
4992 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4993 ModuleDeclIterator(this, &Mod,
4994 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
4997 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4998 PreprocessedEntityID PPID = Index+1;
4999 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5000 ModuleFile &M = *PPInfo.first;
5001 unsigned LocalIndex = PPInfo.second;
5002 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5004 if (!PP.getPreprocessingRecord()) {
5005 Error("no preprocessing record");
5009 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5010 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5012 llvm::BitstreamEntry Entry =
5013 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5014 if (Entry.Kind != llvm::BitstreamEntry::Record)
5018 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5019 TranslateSourceLocation(M, PPOffs.getEnd()));
5020 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5023 PreprocessorDetailRecordTypes RecType =
5024 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
5025 Entry.ID, Record, &Blob);
5027 case PPD_MACRO_EXPANSION: {
5028 bool isBuiltin = Record[0];
5029 IdentifierInfo *Name = nullptr;
5030 MacroDefinitionRecord *Def = nullptr;
5032 Name = getLocalIdentifier(M, Record[1]);
5034 PreprocessedEntityID GlobalID =
5035 getGlobalPreprocessedEntityID(M, Record[1]);
5036 Def = cast<MacroDefinitionRecord>(
5037 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5042 ME = new (PPRec) MacroExpansion(Name, Range);
5044 ME = new (PPRec) MacroExpansion(Def, Range);
5049 case PPD_MACRO_DEFINITION: {
5050 // Decode the identifier info and then check again; if the macro is
5051 // still defined and associated with the identifier,
5052 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5053 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5055 if (DeserializationListener)
5056 DeserializationListener->MacroDefinitionRead(PPID, MD);
5061 case PPD_INCLUSION_DIRECTIVE: {
5062 const char *FullFileNameStart = Blob.data() + Record[0];
5063 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5064 const FileEntry *File = nullptr;
5065 if (!FullFileName.empty())
5066 File = PP.getFileManager().getFile(FullFileName);
5068 // FIXME: Stable encoding
5069 InclusionDirective::InclusionKind Kind
5070 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5071 InclusionDirective *ID
5072 = new (PPRec) InclusionDirective(PPRec, Kind,
5073 StringRef(Blob.data(), Record[0]),
5074 Record[1], Record[3],
5081 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5084 /// \brief \arg SLocMapI points at a chunk of a module that contains no
5085 /// preprocessed entities or the entities it contains are not the ones we are
5086 /// looking for. Find the next module that contains entities and return the ID
5087 /// of the first entry.
5088 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5089 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5091 for (GlobalSLocOffsetMapType::const_iterator
5092 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5093 ModuleFile &M = *SLocMapI->second;
5094 if (M.NumPreprocessedEntities)
5095 return M.BasePreprocessedEntityID;
5098 return getTotalNumPreprocessedEntities();
5103 struct PPEntityComp {
5104 const ASTReader &Reader;
5107 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
5109 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5110 SourceLocation LHS = getLoc(L);
5111 SourceLocation RHS = getLoc(R);
5112 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5115 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5116 SourceLocation LHS = getLoc(L);
5117 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5120 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5121 SourceLocation RHS = getLoc(R);
5122 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5125 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5126 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5130 } // end anonymous namespace
5132 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5133 bool EndsAfter) const {
5134 if (SourceMgr.isLocalSourceLocation(Loc))
5135 return getTotalNumPreprocessedEntities();
5137 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5138 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5139 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5140 "Corrupted global sloc offset map");
5142 if (SLocMapI->second->NumPreprocessedEntities == 0)
5143 return findNextPreprocessedEntity(SLocMapI);
5145 ModuleFile &M = *SLocMapI->second;
5146 typedef const PPEntityOffset *pp_iterator;
5147 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5148 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5150 size_t Count = M.NumPreprocessedEntities;
5152 pp_iterator First = pp_begin;
5156 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5157 PPEntityComp(*this, M));
5159 // Do a binary search manually instead of using std::lower_bound because
5160 // The end locations of entities may be unordered (when a macro expansion
5161 // is inside another macro argument), but for this case it is not important
5162 // whether we get the first macro expansion or its containing macro.
5166 std::advance(PPI, Half);
5167 if (SourceMgr.isBeforeInTranslationUnit(
5168 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5171 Count = Count - Half - 1;
5178 return findNextPreprocessedEntity(SLocMapI);
5180 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5183 /// \brief Returns a pair of [Begin, End) indices of preallocated
5184 /// preprocessed entities that \arg Range encompasses.
5185 std::pair<unsigned, unsigned>
5186 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5187 if (Range.isInvalid())
5188 return std::make_pair(0,0);
5189 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5191 PreprocessedEntityID BeginID =
5192 findPreprocessedEntity(Range.getBegin(), false);
5193 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5194 return std::make_pair(BeginID, EndID);
5197 /// \brief Optionally returns true or false if the preallocated preprocessed
5198 /// entity with index \arg Index came from file \arg FID.
5199 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5201 if (FID.isInvalid())
5204 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5205 ModuleFile &M = *PPInfo.first;
5206 unsigned LocalIndex = PPInfo.second;
5207 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5209 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5210 if (Loc.isInvalid())
5213 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5221 /// \brief Visitor used to search for information about a header file.
5222 class HeaderFileInfoVisitor {
5223 const FileEntry *FE;
5225 Optional<HeaderFileInfo> HFI;
5228 explicit HeaderFileInfoVisitor(const FileEntry *FE)
5231 bool operator()(ModuleFile &M) {
5232 HeaderFileInfoLookupTable *Table
5233 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5237 // Look in the on-disk hash table for an entry for this file name.
5238 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5239 if (Pos == Table->end())
5246 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5249 } // end anonymous namespace
5251 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5252 HeaderFileInfoVisitor Visitor(FE);
5253 ModuleMgr.visit(Visitor);
5254 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5257 return HeaderFileInfo();
5260 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5261 // FIXME: Make it work properly with modules.
5262 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
5263 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5264 ModuleFile &F = *(*I);
5267 assert(!Diag.DiagStates.empty());
5268 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5269 while (Idx < F.PragmaDiagMappings.size()) {
5270 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5271 unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5272 if (DiagStateID != 0) {
5273 Diag.DiagStatePoints.push_back(
5274 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5275 FullSourceLoc(Loc, SourceMgr)));
5279 assert(DiagStateID == 0);
5280 // A new DiagState was created here.
5281 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5282 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5283 DiagStates.push_back(NewState);
5284 Diag.DiagStatePoints.push_back(
5285 DiagnosticsEngine::DiagStatePoint(NewState,
5286 FullSourceLoc(Loc, SourceMgr)));
5288 assert(Idx < F.PragmaDiagMappings.size() &&
5289 "Invalid data, didn't find '-1' marking end of diag/map pairs");
5290 if (Idx >= F.PragmaDiagMappings.size()) {
5291 break; // Something is messed up but at least avoid infinite loop in
5294 unsigned DiagID = F.PragmaDiagMappings[Idx++];
5295 if (DiagID == (unsigned)-1) {
5296 break; // no more diag/map pairs for this location.
5298 diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5299 DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5300 Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
5306 /// \brief Get the correct cursor and offset for loading a type.
5307 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5308 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5309 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5310 ModuleFile *M = I->second;
5311 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5314 /// \brief Read and return the type with the given index..
5316 /// The index is the type ID, shifted and minus the number of predefs. This
5317 /// routine actually reads the record corresponding to the type at the given
5318 /// location. It is a helper routine for GetType, which deals with reading type
5320 QualType ASTReader::readTypeRecord(unsigned Index) {
5321 RecordLocation Loc = TypeCursorForIndex(Index);
5322 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5324 // Keep track of where we are in the stream, then jump back there
5325 // after reading this type.
5326 SavedStreamPosition SavedPosition(DeclsCursor);
5328 ReadingKindTracker ReadingKind(Read_Type, *this);
5330 // Note that we are loading a type record.
5331 Deserializing AType(this);
5334 DeclsCursor.JumpToBit(Loc.Offset);
5336 unsigned Code = DeclsCursor.ReadCode();
5337 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5338 case TYPE_EXT_QUAL: {
5339 if (Record.size() != 2) {
5340 Error("Incorrect encoding of extended qualifier type");
5343 QualType Base = readType(*Loc.F, Record, Idx);
5344 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5345 return Context.getQualifiedType(Base, Quals);
5348 case TYPE_COMPLEX: {
5349 if (Record.size() != 1) {
5350 Error("Incorrect encoding of complex type");
5353 QualType ElemType = readType(*Loc.F, Record, Idx);
5354 return Context.getComplexType(ElemType);
5357 case TYPE_POINTER: {
5358 if (Record.size() != 1) {
5359 Error("Incorrect encoding of pointer type");
5362 QualType PointeeType = readType(*Loc.F, Record, Idx);
5363 return Context.getPointerType(PointeeType);
5366 case TYPE_DECAYED: {
5367 if (Record.size() != 1) {
5368 Error("Incorrect encoding of decayed type");
5371 QualType OriginalType = readType(*Loc.F, Record, Idx);
5372 QualType DT = Context.getAdjustedParameterType(OriginalType);
5373 if (!isa<DecayedType>(DT))
5374 Error("Decayed type does not decay");
5378 case TYPE_ADJUSTED: {
5379 if (Record.size() != 2) {
5380 Error("Incorrect encoding of adjusted type");
5383 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5384 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5385 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5388 case TYPE_BLOCK_POINTER: {
5389 if (Record.size() != 1) {
5390 Error("Incorrect encoding of block pointer type");
5393 QualType PointeeType = readType(*Loc.F, Record, Idx);
5394 return Context.getBlockPointerType(PointeeType);
5397 case TYPE_LVALUE_REFERENCE: {
5398 if (Record.size() != 2) {
5399 Error("Incorrect encoding of lvalue reference type");
5402 QualType PointeeType = readType(*Loc.F, Record, Idx);
5403 return Context.getLValueReferenceType(PointeeType, Record[1]);
5406 case TYPE_RVALUE_REFERENCE: {
5407 if (Record.size() != 1) {
5408 Error("Incorrect encoding of rvalue reference type");
5411 QualType PointeeType = readType(*Loc.F, Record, Idx);
5412 return Context.getRValueReferenceType(PointeeType);
5415 case TYPE_MEMBER_POINTER: {
5416 if (Record.size() != 2) {
5417 Error("Incorrect encoding of member pointer type");
5420 QualType PointeeType = readType(*Loc.F, Record, Idx);
5421 QualType ClassType = readType(*Loc.F, Record, Idx);
5422 if (PointeeType.isNull() || ClassType.isNull())
5425 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5428 case TYPE_CONSTANT_ARRAY: {
5429 QualType ElementType = readType(*Loc.F, Record, Idx);
5430 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5431 unsigned IndexTypeQuals = Record[2];
5433 llvm::APInt Size = ReadAPInt(Record, Idx);
5434 return Context.getConstantArrayType(ElementType, Size,
5435 ASM, IndexTypeQuals);
5438 case TYPE_INCOMPLETE_ARRAY: {
5439 QualType ElementType = readType(*Loc.F, Record, Idx);
5440 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5441 unsigned IndexTypeQuals = Record[2];
5442 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5445 case TYPE_VARIABLE_ARRAY: {
5446 QualType ElementType = readType(*Loc.F, Record, Idx);
5447 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5448 unsigned IndexTypeQuals = Record[2];
5449 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5450 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5451 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5452 ASM, IndexTypeQuals,
5453 SourceRange(LBLoc, RBLoc));
5457 if (Record.size() != 3) {
5458 Error("incorrect encoding of vector type in AST file");
5462 QualType ElementType = readType(*Loc.F, Record, Idx);
5463 unsigned NumElements = Record[1];
5464 unsigned VecKind = Record[2];
5465 return Context.getVectorType(ElementType, NumElements,
5466 (VectorType::VectorKind)VecKind);
5469 case TYPE_EXT_VECTOR: {
5470 if (Record.size() != 3) {
5471 Error("incorrect encoding of extended vector type in AST file");
5475 QualType ElementType = readType(*Loc.F, Record, Idx);
5476 unsigned NumElements = Record[1];
5477 return Context.getExtVectorType(ElementType, NumElements);
5480 case TYPE_FUNCTION_NO_PROTO: {
5481 if (Record.size() != 6) {
5482 Error("incorrect encoding of no-proto function type");
5485 QualType ResultType = readType(*Loc.F, Record, Idx);
5486 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5487 (CallingConv)Record[4], Record[5]);
5488 return Context.getFunctionNoProtoType(ResultType, Info);
5491 case TYPE_FUNCTION_PROTO: {
5492 QualType ResultType = readType(*Loc.F, Record, Idx);
5494 FunctionProtoType::ExtProtoInfo EPI;
5495 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5496 /*hasregparm*/ Record[2],
5497 /*regparm*/ Record[3],
5498 static_cast<CallingConv>(Record[4]),
5499 /*produces*/ Record[5]);
5503 EPI.Variadic = Record[Idx++];
5504 EPI.HasTrailingReturn = Record[Idx++];
5505 EPI.TypeQuals = Record[Idx++];
5506 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5507 SmallVector<QualType, 8> ExceptionStorage;
5508 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5510 unsigned NumParams = Record[Idx++];
5511 SmallVector<QualType, 16> ParamTypes;
5512 for (unsigned I = 0; I != NumParams; ++I)
5513 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5515 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
5516 if (Idx != Record.size()) {
5517 for (unsigned I = 0; I != NumParams; ++I)
5518 ExtParameterInfos.push_back(
5519 FunctionProtoType::ExtParameterInfo
5520 ::getFromOpaqueValue(Record[Idx++]));
5521 EPI.ExtParameterInfos = ExtParameterInfos.data();
5524 assert(Idx == Record.size());
5526 return Context.getFunctionType(ResultType, ParamTypes, EPI);
5529 case TYPE_UNRESOLVED_USING: {
5531 return Context.getTypeDeclType(
5532 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5535 case TYPE_TYPEDEF: {
5536 if (Record.size() != 2) {
5537 Error("incorrect encoding of typedef type");
5541 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5542 QualType Canonical = readType(*Loc.F, Record, Idx);
5543 if (!Canonical.isNull())
5544 Canonical = Context.getCanonicalType(Canonical);
5545 return Context.getTypedefType(Decl, Canonical);
5548 case TYPE_TYPEOF_EXPR:
5549 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5552 if (Record.size() != 1) {
5553 Error("incorrect encoding of typeof(type) in AST file");
5556 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5557 return Context.getTypeOfType(UnderlyingType);
5560 case TYPE_DECLTYPE: {
5561 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5562 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5565 case TYPE_UNARY_TRANSFORM: {
5566 QualType BaseType = readType(*Loc.F, Record, Idx);
5567 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5568 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5569 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5573 QualType Deduced = readType(*Loc.F, Record, Idx);
5574 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
5575 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5576 return Context.getAutoType(Deduced, Keyword, IsDependent);
5580 if (Record.size() != 2) {
5581 Error("incorrect encoding of record type");
5585 bool IsDependent = Record[Idx++];
5586 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5587 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5588 QualType T = Context.getRecordType(RD);
5589 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5594 if (Record.size() != 2) {
5595 Error("incorrect encoding of enum type");
5599 bool IsDependent = Record[Idx++];
5601 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5602 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5606 case TYPE_ATTRIBUTED: {
5607 if (Record.size() != 3) {
5608 Error("incorrect encoding of attributed type");
5611 QualType modifiedType = readType(*Loc.F, Record, Idx);
5612 QualType equivalentType = readType(*Loc.F, Record, Idx);
5613 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5614 return Context.getAttributedType(kind, modifiedType, equivalentType);
5618 if (Record.size() != 1) {
5619 Error("incorrect encoding of paren type");
5622 QualType InnerType = readType(*Loc.F, Record, Idx);
5623 return Context.getParenType(InnerType);
5626 case TYPE_PACK_EXPANSION: {
5627 if (Record.size() != 2) {
5628 Error("incorrect encoding of pack expansion type");
5631 QualType Pattern = readType(*Loc.F, Record, Idx);
5632 if (Pattern.isNull())
5634 Optional<unsigned> NumExpansions;
5636 NumExpansions = Record[1] - 1;
5637 return Context.getPackExpansionType(Pattern, NumExpansions);
5640 case TYPE_ELABORATED: {
5642 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5643 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5644 QualType NamedType = readType(*Loc.F, Record, Idx);
5645 return Context.getElaboratedType(Keyword, NNS, NamedType);
5648 case TYPE_OBJC_INTERFACE: {
5650 ObjCInterfaceDecl *ItfD
5651 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5652 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5655 case TYPE_OBJC_TYPE_PARAM: {
5657 ObjCTypeParamDecl *Decl
5658 = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
5659 unsigned NumProtos = Record[Idx++];
5660 SmallVector<ObjCProtocolDecl*, 4> Protos;
5661 for (unsigned I = 0; I != NumProtos; ++I)
5662 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5663 return Context.getObjCTypeParamType(Decl, Protos);
5665 case TYPE_OBJC_OBJECT: {
5667 QualType Base = readType(*Loc.F, Record, Idx);
5668 unsigned NumTypeArgs = Record[Idx++];
5669 SmallVector<QualType, 4> TypeArgs;
5670 for (unsigned I = 0; I != NumTypeArgs; ++I)
5671 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
5672 unsigned NumProtos = Record[Idx++];
5673 SmallVector<ObjCProtocolDecl*, 4> Protos;
5674 for (unsigned I = 0; I != NumProtos; ++I)
5675 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5676 bool IsKindOf = Record[Idx++];
5677 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
5680 case TYPE_OBJC_OBJECT_POINTER: {
5682 QualType Pointee = readType(*Loc.F, Record, Idx);
5683 return Context.getObjCObjectPointerType(Pointee);
5686 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5688 QualType Parm = readType(*Loc.F, Record, Idx);
5689 QualType Replacement = readType(*Loc.F, Record, Idx);
5690 return Context.getSubstTemplateTypeParmType(
5691 cast<TemplateTypeParmType>(Parm),
5692 Context.getCanonicalType(Replacement));
5695 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5697 QualType Parm = readType(*Loc.F, Record, Idx);
5698 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5699 return Context.getSubstTemplateTypeParmPackType(
5700 cast<TemplateTypeParmType>(Parm),
5704 case TYPE_INJECTED_CLASS_NAME: {
5705 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5706 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5707 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5708 // for AST reading, too much interdependencies.
5709 const Type *T = nullptr;
5710 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
5711 if (const Type *Existing = DI->getTypeForDecl()) {
5717 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
5718 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
5719 DI->setTypeForDecl(T);
5721 return QualType(T, 0);
5724 case TYPE_TEMPLATE_TYPE_PARM: {
5726 unsigned Depth = Record[Idx++];
5727 unsigned Index = Record[Idx++];
5728 bool Pack = Record[Idx++];
5729 TemplateTypeParmDecl *D
5730 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5731 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5734 case TYPE_DEPENDENT_NAME: {
5736 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5737 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5738 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5739 QualType Canon = readType(*Loc.F, Record, Idx);
5740 if (!Canon.isNull())
5741 Canon = Context.getCanonicalType(Canon);
5742 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5745 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5747 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5748 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5749 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5750 unsigned NumArgs = Record[Idx++];
5751 SmallVector<TemplateArgument, 8> Args;
5752 Args.reserve(NumArgs);
5754 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5755 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5759 case TYPE_DEPENDENT_SIZED_ARRAY: {
5763 QualType ElementType = readType(*Loc.F, Record, Idx);
5764 ArrayType::ArraySizeModifier ASM
5765 = (ArrayType::ArraySizeModifier)Record[Idx++];
5766 unsigned IndexTypeQuals = Record[Idx++];
5768 // DependentSizedArrayType
5769 Expr *NumElts = ReadExpr(*Loc.F);
5770 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5772 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5773 IndexTypeQuals, Brackets);
5776 case TYPE_TEMPLATE_SPECIALIZATION: {
5778 bool IsDependent = Record[Idx++];
5779 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5780 SmallVector<TemplateArgument, 8> Args;
5781 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5782 QualType Underlying = readType(*Loc.F, Record, Idx);
5784 if (Underlying.isNull())
5785 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
5787 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
5788 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5793 if (Record.size() != 1) {
5794 Error("Incorrect encoding of atomic type");
5797 QualType ValueType = readType(*Loc.F, Record, Idx);
5798 return Context.getAtomicType(ValueType);
5802 if (Record.size() != 2) {
5803 Error("Incorrect encoding of pipe type");
5807 // Reading the pipe element type.
5808 QualType ElementType = readType(*Loc.F, Record, Idx);
5809 unsigned ReadOnly = Record[1];
5810 return Context.getPipeType(ElementType, ReadOnly);
5814 llvm_unreachable("Invalid TypeCode!");
5817 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5818 SmallVectorImpl<QualType> &Exceptions,
5819 FunctionProtoType::ExceptionSpecInfo &ESI,
5820 const RecordData &Record, unsigned &Idx) {
5821 ExceptionSpecificationType EST =
5822 static_cast<ExceptionSpecificationType>(Record[Idx++]);
5824 if (EST == EST_Dynamic) {
5825 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
5826 Exceptions.push_back(readType(ModuleFile, Record, Idx));
5827 ESI.Exceptions = Exceptions;
5828 } else if (EST == EST_ComputedNoexcept) {
5829 ESI.NoexceptExpr = ReadExpr(ModuleFile);
5830 } else if (EST == EST_Uninstantiated) {
5831 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5832 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5833 } else if (EST == EST_Unevaluated) {
5834 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5838 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5839 ASTRecordReader Reader;
5842 SourceLocation ReadSourceLocation() {
5843 return Reader.ReadSourceLocation(Idx);
5847 TypeLocReader(ASTReader &Reader, ModuleFile &F,
5848 const ASTReader::RecordData &Record, unsigned &Idx)
5849 : Reader(Reader, Record, F), Idx(Idx) {}
5851 // We want compile-time assurance that we've enumerated all of
5852 // these, so unfortunately we have to declare them first, then
5853 // define them out-of-line.
5854 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5855 #define TYPELOC(CLASS, PARENT) \
5856 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5857 #include "clang/AST/TypeLocNodes.def"
5859 void VisitFunctionTypeLoc(FunctionTypeLoc);
5860 void VisitArrayTypeLoc(ArrayTypeLoc);
5863 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5867 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5868 TL.setBuiltinLoc(ReadSourceLocation());
5869 if (TL.needsExtraLocalData()) {
5870 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Reader[Idx++]));
5871 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Reader[Idx++]));
5872 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Reader[Idx++]));
5873 TL.setModeAttr(Reader[Idx++]);
5877 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5878 TL.setNameLoc(ReadSourceLocation());
5881 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5882 TL.setStarLoc(ReadSourceLocation());
5885 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5889 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5893 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5894 TL.setCaretLoc(ReadSourceLocation());
5897 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5898 TL.setAmpLoc(ReadSourceLocation());
5901 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5902 TL.setAmpAmpLoc(ReadSourceLocation());
5905 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5906 TL.setStarLoc(ReadSourceLocation());
5907 TL.setClassTInfo(Reader.GetTypeSourceInfo(Idx));
5910 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5911 TL.setLBracketLoc(ReadSourceLocation());
5912 TL.setRBracketLoc(ReadSourceLocation());
5914 TL.setSizeExpr(Reader.ReadExpr());
5916 TL.setSizeExpr(nullptr);
5919 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5920 VisitArrayTypeLoc(TL);
5923 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5924 VisitArrayTypeLoc(TL);
5927 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5928 VisitArrayTypeLoc(TL);
5931 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5932 DependentSizedArrayTypeLoc TL) {
5933 VisitArrayTypeLoc(TL);
5936 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5937 DependentSizedExtVectorTypeLoc TL) {
5938 TL.setNameLoc(ReadSourceLocation());
5941 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5942 TL.setNameLoc(ReadSourceLocation());
5945 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5946 TL.setNameLoc(ReadSourceLocation());
5949 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5950 TL.setLocalRangeBegin(ReadSourceLocation());
5951 TL.setLParenLoc(ReadSourceLocation());
5952 TL.setRParenLoc(ReadSourceLocation());
5953 TL.setLocalRangeEnd(ReadSourceLocation());
5954 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5955 TL.setParam(i, Reader.ReadDeclAs<ParmVarDecl>(Idx));
5959 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5960 VisitFunctionTypeLoc(TL);
5963 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5964 VisitFunctionTypeLoc(TL);
5966 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5967 TL.setNameLoc(ReadSourceLocation());
5969 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5970 TL.setNameLoc(ReadSourceLocation());
5972 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5973 TL.setTypeofLoc(ReadSourceLocation());
5974 TL.setLParenLoc(ReadSourceLocation());
5975 TL.setRParenLoc(ReadSourceLocation());
5977 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5978 TL.setTypeofLoc(ReadSourceLocation());
5979 TL.setLParenLoc(ReadSourceLocation());
5980 TL.setRParenLoc(ReadSourceLocation());
5981 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(Idx));
5983 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5984 TL.setNameLoc(ReadSourceLocation());
5987 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5988 TL.setKWLoc(ReadSourceLocation());
5989 TL.setLParenLoc(ReadSourceLocation());
5990 TL.setRParenLoc(ReadSourceLocation());
5991 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(Idx));
5994 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5995 TL.setNameLoc(ReadSourceLocation());
5998 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5999 TL.setNameLoc(ReadSourceLocation());
6002 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6003 TL.setNameLoc(ReadSourceLocation());
6006 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6007 TL.setAttrNameLoc(ReadSourceLocation());
6008 if (TL.hasAttrOperand()) {
6010 range.setBegin(ReadSourceLocation());
6011 range.setEnd(ReadSourceLocation());
6012 TL.setAttrOperandParensRange(range);
6014 if (TL.hasAttrExprOperand()) {
6016 TL.setAttrExprOperand(Reader.ReadExpr());
6018 TL.setAttrExprOperand(nullptr);
6019 } else if (TL.hasAttrEnumOperand())
6020 TL.setAttrEnumOperandLoc(ReadSourceLocation());
6023 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6024 TL.setNameLoc(ReadSourceLocation());
6027 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6028 SubstTemplateTypeParmTypeLoc TL) {
6029 TL.setNameLoc(ReadSourceLocation());
6031 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6032 SubstTemplateTypeParmPackTypeLoc TL) {
6033 TL.setNameLoc(ReadSourceLocation());
6035 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6036 TemplateSpecializationTypeLoc TL) {
6037 TL.setTemplateKeywordLoc(ReadSourceLocation());
6038 TL.setTemplateNameLoc(ReadSourceLocation());
6039 TL.setLAngleLoc(ReadSourceLocation());
6040 TL.setRAngleLoc(ReadSourceLocation());
6041 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6043 Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind(),
6046 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6047 TL.setLParenLoc(ReadSourceLocation());
6048 TL.setRParenLoc(ReadSourceLocation());
6051 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6052 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6053 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
6056 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6057 TL.setNameLoc(ReadSourceLocation());
6060 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6061 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6062 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
6063 TL.setNameLoc(ReadSourceLocation());
6066 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6067 DependentTemplateSpecializationTypeLoc TL) {
6068 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6069 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
6070 TL.setTemplateKeywordLoc(ReadSourceLocation());
6071 TL.setTemplateNameLoc(ReadSourceLocation());
6072 TL.setLAngleLoc(ReadSourceLocation());
6073 TL.setRAngleLoc(ReadSourceLocation());
6074 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6076 Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
6080 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6081 TL.setEllipsisLoc(ReadSourceLocation());
6084 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6085 TL.setNameLoc(ReadSourceLocation());
6088 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6089 if (TL.getNumProtocols()) {
6090 TL.setProtocolLAngleLoc(ReadSourceLocation());
6091 TL.setProtocolRAngleLoc(ReadSourceLocation());
6093 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6094 TL.setProtocolLoc(i, ReadSourceLocation());
6097 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6098 TL.setHasBaseTypeAsWritten(Reader[Idx++]);
6099 TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6100 TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6101 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6102 TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(Idx));
6103 TL.setProtocolLAngleLoc(ReadSourceLocation());
6104 TL.setProtocolRAngleLoc(ReadSourceLocation());
6105 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6106 TL.setProtocolLoc(i, ReadSourceLocation());
6109 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6110 TL.setStarLoc(ReadSourceLocation());
6113 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6114 TL.setKWLoc(ReadSourceLocation());
6115 TL.setLParenLoc(ReadSourceLocation());
6116 TL.setRParenLoc(ReadSourceLocation());
6119 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6120 TL.setKWLoc(ReadSourceLocation());
6123 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
6124 const RecordData &Record,
6126 QualType InfoTy = readType(F, Record, Idx);
6127 if (InfoTy.isNull())
6130 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6131 TypeLocReader TLR(*this, F, Record, Idx);
6132 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
6137 QualType ASTReader::GetType(TypeID ID) {
6138 unsigned FastQuals = ID & Qualifiers::FastMask;
6139 unsigned Index = ID >> Qualifiers::FastWidth;
6141 if (Index < NUM_PREDEF_TYPE_IDS) {
6143 switch ((PredefinedTypeIDs)Index) {
6144 case PREDEF_TYPE_NULL_ID:
6146 case PREDEF_TYPE_VOID_ID:
6149 case PREDEF_TYPE_BOOL_ID:
6153 case PREDEF_TYPE_CHAR_U_ID:
6154 case PREDEF_TYPE_CHAR_S_ID:
6155 // FIXME: Check that the signedness of CharTy is correct!
6159 case PREDEF_TYPE_UCHAR_ID:
6160 T = Context.UnsignedCharTy;
6162 case PREDEF_TYPE_USHORT_ID:
6163 T = Context.UnsignedShortTy;
6165 case PREDEF_TYPE_UINT_ID:
6166 T = Context.UnsignedIntTy;
6168 case PREDEF_TYPE_ULONG_ID:
6169 T = Context.UnsignedLongTy;
6171 case PREDEF_TYPE_ULONGLONG_ID:
6172 T = Context.UnsignedLongLongTy;
6174 case PREDEF_TYPE_UINT128_ID:
6175 T = Context.UnsignedInt128Ty;
6177 case PREDEF_TYPE_SCHAR_ID:
6178 T = Context.SignedCharTy;
6180 case PREDEF_TYPE_WCHAR_ID:
6181 T = Context.WCharTy;
6183 case PREDEF_TYPE_SHORT_ID:
6184 T = Context.ShortTy;
6186 case PREDEF_TYPE_INT_ID:
6189 case PREDEF_TYPE_LONG_ID:
6192 case PREDEF_TYPE_LONGLONG_ID:
6193 T = Context.LongLongTy;
6195 case PREDEF_TYPE_INT128_ID:
6196 T = Context.Int128Ty;
6198 case PREDEF_TYPE_HALF_ID:
6201 case PREDEF_TYPE_FLOAT_ID:
6202 T = Context.FloatTy;
6204 case PREDEF_TYPE_DOUBLE_ID:
6205 T = Context.DoubleTy;
6207 case PREDEF_TYPE_LONGDOUBLE_ID:
6208 T = Context.LongDoubleTy;
6210 case PREDEF_TYPE_FLOAT128_ID:
6211 T = Context.Float128Ty;
6213 case PREDEF_TYPE_OVERLOAD_ID:
6214 T = Context.OverloadTy;
6216 case PREDEF_TYPE_BOUND_MEMBER:
6217 T = Context.BoundMemberTy;
6219 case PREDEF_TYPE_PSEUDO_OBJECT:
6220 T = Context.PseudoObjectTy;
6222 case PREDEF_TYPE_DEPENDENT_ID:
6223 T = Context.DependentTy;
6225 case PREDEF_TYPE_UNKNOWN_ANY:
6226 T = Context.UnknownAnyTy;
6228 case PREDEF_TYPE_NULLPTR_ID:
6229 T = Context.NullPtrTy;
6231 case PREDEF_TYPE_CHAR16_ID:
6232 T = Context.Char16Ty;
6234 case PREDEF_TYPE_CHAR32_ID:
6235 T = Context.Char32Ty;
6237 case PREDEF_TYPE_OBJC_ID:
6238 T = Context.ObjCBuiltinIdTy;
6240 case PREDEF_TYPE_OBJC_CLASS:
6241 T = Context.ObjCBuiltinClassTy;
6243 case PREDEF_TYPE_OBJC_SEL:
6244 T = Context.ObjCBuiltinSelTy;
6246 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6247 case PREDEF_TYPE_##Id##_ID: \
6248 T = Context.SingletonId; \
6250 #include "clang/Basic/OpenCLImageTypes.def"
6251 case PREDEF_TYPE_SAMPLER_ID:
6252 T = Context.OCLSamplerTy;
6254 case PREDEF_TYPE_EVENT_ID:
6255 T = Context.OCLEventTy;
6257 case PREDEF_TYPE_CLK_EVENT_ID:
6258 T = Context.OCLClkEventTy;
6260 case PREDEF_TYPE_QUEUE_ID:
6261 T = Context.OCLQueueTy;
6263 case PREDEF_TYPE_NDRANGE_ID:
6264 T = Context.OCLNDRangeTy;
6266 case PREDEF_TYPE_RESERVE_ID_ID:
6267 T = Context.OCLReserveIDTy;
6269 case PREDEF_TYPE_AUTO_DEDUCT:
6270 T = Context.getAutoDeductType();
6273 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
6274 T = Context.getAutoRRefDeductType();
6277 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
6278 T = Context.ARCUnbridgedCastTy;
6281 case PREDEF_TYPE_BUILTIN_FN:
6282 T = Context.BuiltinFnTy;
6285 case PREDEF_TYPE_OMP_ARRAY_SECTION:
6286 T = Context.OMPArraySectionTy;
6290 assert(!T.isNull() && "Unknown predefined type");
6291 return T.withFastQualifiers(FastQuals);
6294 Index -= NUM_PREDEF_TYPE_IDS;
6295 assert(Index < TypesLoaded.size() && "Type index out-of-range");
6296 if (TypesLoaded[Index].isNull()) {
6297 TypesLoaded[Index] = readTypeRecord(Index);
6298 if (TypesLoaded[Index].isNull())
6301 TypesLoaded[Index]->setFromAST();
6302 if (DeserializationListener)
6303 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6304 TypesLoaded[Index]);
6307 return TypesLoaded[Index].withFastQualifiers(FastQuals);
6310 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6311 return GetType(getGlobalTypeID(F, LocalID));
6314 serialization::TypeID
6315 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6316 unsigned FastQuals = LocalID & Qualifiers::FastMask;
6317 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6319 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6322 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6323 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6324 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6326 unsigned GlobalIndex = LocalIndex + I->second;
6327 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6330 TemplateArgumentLocInfo
6331 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
6332 TemplateArgument::ArgKind Kind,
6333 const RecordData &Record,
6336 case TemplateArgument::Expression:
6338 case TemplateArgument::Type:
6339 return GetTypeSourceInfo(F, Record, Index);
6340 case TemplateArgument::Template: {
6341 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6343 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6344 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6347 case TemplateArgument::TemplateExpansion: {
6348 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6350 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6351 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6352 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6355 case TemplateArgument::Null:
6356 case TemplateArgument::Integral:
6357 case TemplateArgument::Declaration:
6358 case TemplateArgument::NullPtr:
6359 case TemplateArgument::Pack:
6360 // FIXME: Is this right?
6361 return TemplateArgumentLocInfo();
6363 llvm_unreachable("unexpected template argument loc");
6367 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6368 const RecordData &Record, unsigned &Index) {
6369 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6371 if (Arg.getKind() == TemplateArgument::Expression) {
6372 if (Record[Index++]) // bool InfoHasSameExpr.
6373 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6375 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6379 const ASTTemplateArgumentListInfo*
6380 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6381 const RecordData &Record,
6383 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6384 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6385 unsigned NumArgsAsWritten = Record[Index++];
6386 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6387 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6388 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6389 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6392 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6396 template<typename TemplateSpecializationDecl>
6397 static void completeRedeclChainForTemplateSpecialization(Decl *D) {
6398 if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D))
6399 TSD->getSpecializedTemplate()->LoadLazySpecializations();
6402 void ASTReader::CompleteRedeclChain(const Decl *D) {
6403 if (NumCurrentElementsDeserializing) {
6404 // We arrange to not care about the complete redeclaration chain while we're
6405 // deserializing. Just remember that the AST has marked this one as complete
6406 // but that it's not actually complete yet, so we know we still need to
6407 // complete it later.
6408 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6412 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6414 // If this is a named declaration, complete it by looking it up
6415 // within its context.
6417 // FIXME: Merging a function definition should merge
6418 // all mergeable entities within it.
6419 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6420 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6421 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6422 if (!getContext().getLangOpts().CPlusPlus &&
6423 isa<TranslationUnitDecl>(DC)) {
6424 // Outside of C++, we don't have a lookup table for the TU, so update
6425 // the identifier instead. (For C++ modules, we don't store decls
6426 // in the serialized identifier table, so we do the lookup in the TU.)
6427 auto *II = Name.getAsIdentifierInfo();
6428 assert(II && "non-identifier name in C?");
6429 if (II->isOutOfDate())
6430 updateOutOfDateIdentifier(*II);
6433 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6434 // Find all declarations of this kind from the relevant context.
6435 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6436 auto *DC = cast<DeclContext>(DCDecl);
6437 SmallVector<Decl*, 8> Decls;
6438 FindExternalLexicalDecls(
6439 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
6444 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
6445 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
6446 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
6447 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
6448 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6449 if (auto *Template = FD->getPrimaryTemplate())
6450 Template->LoadLazySpecializations();
6454 CXXCtorInitializer **
6455 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
6456 RecordLocation Loc = getLocalBitOffset(Offset);
6457 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6458 SavedStreamPosition SavedPosition(Cursor);
6459 Cursor.JumpToBit(Loc.Offset);
6460 ReadingKindTracker ReadingKind(Read_Decl, *this);
6463 unsigned Code = Cursor.ReadCode();
6464 unsigned RecCode = Cursor.readRecord(Code, Record);
6465 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
6466 Error("malformed AST file: missing C++ ctor initializers");
6471 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
6474 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
6475 RecordLocation Loc = getLocalBitOffset(Offset);
6476 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6477 SavedStreamPosition SavedPosition(Cursor);
6478 Cursor.JumpToBit(Loc.Offset);
6479 ReadingKindTracker ReadingKind(Read_Decl, *this);
6481 unsigned Code = Cursor.ReadCode();
6482 unsigned RecCode = Cursor.readRecord(Code, Record);
6483 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
6484 Error("malformed AST file: missing C++ base specifiers");
6489 unsigned NumBases = Record[Idx++];
6490 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6491 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6492 for (unsigned I = 0; I != NumBases; ++I)
6493 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6497 serialization::DeclID
6498 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6499 if (LocalID < NUM_PREDEF_DECL_IDS)
6502 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6503 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6504 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6506 return LocalID + I->second;
6509 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
6510 ModuleFile &M) const {
6511 // Predefined decls aren't from any module.
6512 if (ID < NUM_PREDEF_DECL_IDS)
6515 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
6516 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
6519 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
6520 if (!D->isFromASTFile())
6522 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6523 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6527 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
6528 if (ID < NUM_PREDEF_DECL_IDS)
6529 return SourceLocation();
6531 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6533 if (Index > DeclsLoaded.size()) {
6534 Error("declaration ID out-of-range for AST file");
6535 return SourceLocation();
6538 if (Decl *D = DeclsLoaded[Index])
6539 return D->getLocation();
6542 DeclCursorForID(ID, Loc);
6546 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
6548 case PREDEF_DECL_NULL_ID:
6551 case PREDEF_DECL_TRANSLATION_UNIT_ID:
6552 return Context.getTranslationUnitDecl();
6554 case PREDEF_DECL_OBJC_ID_ID:
6555 return Context.getObjCIdDecl();
6557 case PREDEF_DECL_OBJC_SEL_ID:
6558 return Context.getObjCSelDecl();
6560 case PREDEF_DECL_OBJC_CLASS_ID:
6561 return Context.getObjCClassDecl();
6563 case PREDEF_DECL_OBJC_PROTOCOL_ID:
6564 return Context.getObjCProtocolDecl();
6566 case PREDEF_DECL_INT_128_ID:
6567 return Context.getInt128Decl();
6569 case PREDEF_DECL_UNSIGNED_INT_128_ID:
6570 return Context.getUInt128Decl();
6572 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
6573 return Context.getObjCInstanceTypeDecl();
6575 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
6576 return Context.getBuiltinVaListDecl();
6578 case PREDEF_DECL_VA_LIST_TAG:
6579 return Context.getVaListTagDecl();
6581 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
6582 return Context.getBuiltinMSVaListDecl();
6584 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
6585 return Context.getExternCContextDecl();
6587 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
6588 return Context.getMakeIntegerSeqDecl();
6590 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
6591 return Context.getCFConstantStringDecl();
6593 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
6594 return Context.getCFConstantStringTagDecl();
6596 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
6597 return Context.getTypePackElementDecl();
6599 llvm_unreachable("PredefinedDeclIDs unknown enum value");
6602 Decl *ASTReader::GetExistingDecl(DeclID ID) {
6603 if (ID < NUM_PREDEF_DECL_IDS) {
6604 Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID);
6606 // Track that we have merged the declaration with ID \p ID into the
6607 // pre-existing predefined declaration \p D.
6608 auto &Merged = KeyDecls[D->getCanonicalDecl()];
6610 Merged.push_back(ID);
6615 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6617 if (Index >= DeclsLoaded.size()) {
6618 assert(0 && "declaration ID out-of-range for AST file");
6619 Error("declaration ID out-of-range for AST file");
6623 return DeclsLoaded[Index];
6626 Decl *ASTReader::GetDecl(DeclID ID) {
6627 if (ID < NUM_PREDEF_DECL_IDS)
6628 return GetExistingDecl(ID);
6630 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6632 if (Index >= DeclsLoaded.size()) {
6633 assert(0 && "declaration ID out-of-range for AST file");
6634 Error("declaration ID out-of-range for AST file");
6638 if (!DeclsLoaded[Index]) {
6640 if (DeserializationListener)
6641 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
6644 return DeclsLoaded[Index];
6647 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
6649 if (GlobalID < NUM_PREDEF_DECL_IDS)
6652 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
6653 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6654 ModuleFile *Owner = I->second;
6656 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
6657 = M.GlobalToLocalDeclIDs.find(Owner);
6658 if (Pos == M.GlobalToLocalDeclIDs.end())
6661 return GlobalID - Owner->BaseDeclID + Pos->second;
6664 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
6665 const RecordData &Record,
6667 if (Idx >= Record.size()) {
6668 Error("Corrupted AST file");
6672 return getGlobalDeclID(F, Record[Idx++]);
6675 /// \brief Resolve the offset of a statement into a statement.
6677 /// This operation will read a new statement from the external
6678 /// source each time it is called, and is meant to be used via a
6679 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
6680 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
6681 // Switch case IDs are per Decl.
6682 ClearSwitchCaseIDs();
6684 // Offset here is a global offset across the entire chain.
6685 RecordLocation Loc = getLocalBitOffset(Offset);
6686 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
6687 return ReadStmtFromStream(*Loc.F);
6690 void ASTReader::FindExternalLexicalDecls(
6691 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
6692 SmallVectorImpl<Decl *> &Decls) {
6693 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
6695 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
6696 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
6697 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
6698 auto K = (Decl::Kind)+LexicalDecls[I];
6699 if (!IsKindWeWant(K))
6702 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
6704 // Don't add predefined declarations to the lexical context more
6706 if (ID < NUM_PREDEF_DECL_IDS) {
6707 if (PredefsVisited[ID])
6710 PredefsVisited[ID] = true;
6713 if (Decl *D = GetLocalDecl(*M, ID)) {
6714 assert(D->getKind() == K && "wrong kind for lexical decl");
6715 if (!DC->isDeclInLexicalTraversal(D))
6721 if (isa<TranslationUnitDecl>(DC)) {
6722 for (auto Lexical : TULexicalDecls)
6723 Visit(Lexical.first, Lexical.second);
6725 auto I = LexicalDecls.find(DC);
6726 if (I != LexicalDecls.end())
6727 Visit(I->second.first, I->second.second);
6730 ++NumLexicalDeclContextsRead;
6740 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
6742 bool operator()(LocalDeclID L, LocalDeclID R) const {
6743 SourceLocation LHS = getLocation(L);
6744 SourceLocation RHS = getLocation(R);
6745 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6748 bool operator()(SourceLocation LHS, LocalDeclID R) const {
6749 SourceLocation RHS = getLocation(R);
6750 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6753 bool operator()(LocalDeclID L, SourceLocation RHS) const {
6754 SourceLocation LHS = getLocation(L);
6755 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6758 SourceLocation getLocation(LocalDeclID ID) const {
6759 return Reader.getSourceManager().getFileLoc(
6760 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
6764 } // end anonymous namespace
6766 void ASTReader::FindFileRegionDecls(FileID File,
6767 unsigned Offset, unsigned Length,
6768 SmallVectorImpl<Decl *> &Decls) {
6769 SourceManager &SM = getSourceManager();
6771 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
6772 if (I == FileDeclIDs.end())
6775 FileDeclsInfo &DInfo = I->second;
6776 if (DInfo.Decls.empty())
6780 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
6781 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
6783 DeclIDComp DIDComp(*this, *DInfo.Mod);
6784 ArrayRef<serialization::LocalDeclID>::iterator
6785 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6787 if (BeginIt != DInfo.Decls.begin())
6790 // If we are pointing at a top-level decl inside an objc container, we need
6791 // to backtrack until we find it otherwise we will fail to report that the
6792 // region overlaps with an objc container.
6793 while (BeginIt != DInfo.Decls.begin() &&
6794 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
6795 ->isTopLevelDeclInObjCContainer())
6798 ArrayRef<serialization::LocalDeclID>::iterator
6799 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6801 if (EndIt != DInfo.Decls.end())
6804 for (ArrayRef<serialization::LocalDeclID>::iterator
6805 DIt = BeginIt; DIt != EndIt; ++DIt)
6806 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
6810 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
6811 DeclarationName Name) {
6812 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
6813 "DeclContext has no visible decls in storage");
6817 auto It = Lookups.find(DC);
6818 if (It == Lookups.end())
6821 Deserializing LookupResults(this);
6823 // Load the list of declarations.
6824 SmallVector<NamedDecl *, 64> Decls;
6825 for (DeclID ID : It->second.Table.find(Name)) {
6826 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6827 if (ND->getDeclName() == Name)
6828 Decls.push_back(ND);
6831 ++NumVisibleDeclContextsRead;
6832 SetExternalVisibleDeclsForName(DC, Name, Decls);
6833 return !Decls.empty();
6836 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
6837 if (!DC->hasExternalVisibleStorage())
6840 auto It = Lookups.find(DC);
6841 assert(It != Lookups.end() &&
6842 "have external visible storage but no lookup tables");
6846 for (DeclID ID : It->second.Table.findAll()) {
6847 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6848 Decls[ND->getDeclName()].push_back(ND);
6851 ++NumVisibleDeclContextsRead;
6853 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
6854 SetExternalVisibleDeclsForName(DC, I->first, I->second);
6856 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
6859 const serialization::reader::DeclContextLookupTable *
6860 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
6861 auto I = Lookups.find(Primary);
6862 return I == Lookups.end() ? nullptr : &I->second;
6865 /// \brief Under non-PCH compilation the consumer receives the objc methods
6866 /// before receiving the implementation, and codegen depends on this.
6867 /// We simulate this by deserializing and passing to consumer the methods of the
6868 /// implementation before passing the deserialized implementation decl.
6869 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
6870 ASTConsumer *Consumer) {
6871 assert(ImplD && Consumer);
6873 for (auto *I : ImplD->methods())
6874 Consumer->HandleInterestingDecl(DeclGroupRef(I));
6876 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
6879 void ASTReader::PassInterestingDeclsToConsumer() {
6882 if (PassingDeclsToConsumer)
6885 // Guard variable to avoid recursively redoing the process of passing
6886 // decls to consumer.
6887 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6890 // Ensure that we've loaded all potentially-interesting declarations
6891 // that need to be eagerly loaded.
6892 for (auto ID : EagerlyDeserializedDecls)
6894 EagerlyDeserializedDecls.clear();
6896 while (!InterestingDecls.empty()) {
6897 Decl *D = InterestingDecls.front();
6898 InterestingDecls.pop_front();
6900 PassInterestingDeclToConsumer(D);
6904 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
6905 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6906 PassObjCImplDeclToConsumer(ImplD, Consumer);
6908 Consumer->HandleInterestingDecl(DeclGroupRef(D));
6911 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
6912 this->Consumer = Consumer;
6915 PassInterestingDeclsToConsumer();
6917 if (DeserializationListener)
6918 DeserializationListener->ReaderInitialized(this);
6921 void ASTReader::PrintStats() {
6922 std::fprintf(stderr, "*** AST File Statistics:\n");
6924 unsigned NumTypesLoaded
6925 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
6927 unsigned NumDeclsLoaded
6928 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
6930 unsigned NumIdentifiersLoaded
6931 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
6932 IdentifiersLoaded.end(),
6933 (IdentifierInfo *)nullptr);
6934 unsigned NumMacrosLoaded
6935 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
6937 (MacroInfo *)nullptr);
6938 unsigned NumSelectorsLoaded
6939 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
6940 SelectorsLoaded.end(),
6943 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
6944 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
6945 NumSLocEntriesRead, TotalNumSLocEntries,
6946 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
6947 if (!TypesLoaded.empty())
6948 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
6949 NumTypesLoaded, (unsigned)TypesLoaded.size(),
6950 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
6951 if (!DeclsLoaded.empty())
6952 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
6953 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
6954 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
6955 if (!IdentifiersLoaded.empty())
6956 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
6957 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
6958 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
6959 if (!MacrosLoaded.empty())
6960 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6961 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
6962 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
6963 if (!SelectorsLoaded.empty())
6964 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
6965 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
6966 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
6967 if (TotalNumStatements)
6968 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
6969 NumStatementsRead, TotalNumStatements,
6970 ((float)NumStatementsRead/TotalNumStatements * 100));
6972 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6973 NumMacrosRead, TotalNumMacros,
6974 ((float)NumMacrosRead/TotalNumMacros * 100));
6975 if (TotalLexicalDeclContexts)
6976 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
6977 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
6978 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
6980 if (TotalVisibleDeclContexts)
6981 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
6982 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
6983 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
6985 if (TotalNumMethodPoolEntries) {
6986 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
6987 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
6988 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
6991 if (NumMethodPoolLookups) {
6992 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
6993 NumMethodPoolHits, NumMethodPoolLookups,
6994 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
6996 if (NumMethodPoolTableLookups) {
6997 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
6998 NumMethodPoolTableHits, NumMethodPoolTableLookups,
6999 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7003 if (NumIdentifierLookupHits) {
7004 std::fprintf(stderr,
7005 " %u / %u identifier table lookups succeeded (%f%%)\n",
7006 NumIdentifierLookupHits, NumIdentifierLookups,
7007 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7011 std::fprintf(stderr, "\n");
7012 GlobalIndex->printStats();
7015 std::fprintf(stderr, "\n");
7017 std::fprintf(stderr, "\n");
7020 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7022 dumpModuleIDMap(StringRef Name,
7023 const ContinuousRangeMap<Key, ModuleFile *,
7024 InitialCapacity> &Map) {
7025 if (Map.begin() == Map.end())
7028 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
7029 llvm::errs() << Name << ":\n";
7030 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7032 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7037 LLVM_DUMP_METHOD void ASTReader::dump() {
7038 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7039 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7040 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7041 dumpModuleIDMap("Global type map", GlobalTypeMap);
7042 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7043 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7044 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7045 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7046 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7047 dumpModuleIDMap("Global preprocessed entity map",
7048 GlobalPreprocessedEntityMap);
7050 llvm::errs() << "\n*** PCH/Modules Loaded:";
7051 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
7052 MEnd = ModuleMgr.end();
7057 /// Return the amount of memory used by memory buffers, breaking down
7058 /// by heap-backed versus mmap'ed memory.
7059 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7060 for (ModuleConstIterator I = ModuleMgr.begin(),
7061 E = ModuleMgr.end(); I != E; ++I) {
7062 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
7063 size_t bytes = buf->getBufferSize();
7064 switch (buf->getBufferKind()) {
7065 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7066 sizes.malloc_bytes += bytes;
7068 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7069 sizes.mmap_bytes += bytes;
7076 void ASTReader::InitializeSema(Sema &S) {
7078 S.addExternalSource(this);
7080 // Makes sure any declarations that were deserialized "too early"
7081 // still get added to the identifier's declaration chains.
7082 for (uint64_t ID : PreloadedDeclIDs) {
7083 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7084 pushExternalDeclIntoScope(D, D->getDeclName());
7086 PreloadedDeclIDs.clear();
7088 // FIXME: What happens if these are changed by a module import?
7089 if (!FPPragmaOptions.empty()) {
7090 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7091 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
7094 // FIXME: What happens if these are changed by a module import?
7095 if (!OpenCLExtensions.empty()) {
7097 #define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
7098 #include "clang/Basic/OpenCLExtensions.def"
7100 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
7106 void ASTReader::UpdateSema() {
7107 assert(SemaObj && "no Sema to update");
7109 // Load the offsets of the declarations that Sema references.
7110 // They will be lazily deserialized when needed.
7111 if (!SemaDeclRefs.empty()) {
7112 assert(SemaDeclRefs.size() % 3 == 0);
7113 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7114 if (!SemaObj->StdNamespace)
7115 SemaObj->StdNamespace = SemaDeclRefs[I];
7116 if (!SemaObj->StdBadAlloc)
7117 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7118 if (!SemaObj->StdAlignValT)
7119 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7121 SemaDeclRefs.clear();
7124 // Update the state of pragmas. Use the same API as if we had encountered the
7125 // pragma in the source.
7126 if(OptimizeOffPragmaLocation.isValid())
7127 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7128 if (PragmaMSStructState != -1)
7129 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7130 if (PointersToMembersPragmaLocation.isValid()) {
7131 SemaObj->ActOnPragmaMSPointersToMembers(
7132 (LangOptions::PragmaMSPointersToMembersKind)
7133 PragmaMSPointersToMembersState,
7134 PointersToMembersPragmaLocation);
7136 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7139 IdentifierInfo *ASTReader::get(StringRef Name) {
7140 // Note that we are loading an identifier.
7141 Deserializing AnIdentifier(this);
7143 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7144 NumIdentifierLookups,
7145 NumIdentifierLookupHits);
7147 // We don't need to do identifier table lookups in C++ modules (we preload
7148 // all interesting declarations, and don't need to use the scope for name
7149 // lookups). Perform the lookup in PCH files, though, since we don't build
7150 // a complete initial identifier table if we're carrying on from a PCH.
7151 if (Context.getLangOpts().CPlusPlus) {
7152 for (auto F : ModuleMgr.pch_modules())
7156 // If there is a global index, look there first to determine which modules
7157 // provably do not have any results for this identifier.
7158 GlobalModuleIndex::HitSet Hits;
7159 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7160 if (!loadGlobalIndex()) {
7161 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7166 ModuleMgr.visit(Visitor, HitsPtr);
7169 IdentifierInfo *II = Visitor.getIdentifierInfo();
7170 markIdentifierUpToDate(II);
7176 /// \brief An identifier-lookup iterator that enumerates all of the
7177 /// identifiers stored within a set of AST files.
7178 class ASTIdentifierIterator : public IdentifierIterator {
7179 /// \brief The AST reader whose identifiers are being enumerated.
7180 const ASTReader &Reader;
7182 /// \brief The current index into the chain of AST files stored in
7186 /// \brief The current position within the identifier lookup table
7187 /// of the current AST file.
7188 ASTIdentifierLookupTable::key_iterator Current;
7190 /// \brief The end position within the identifier lookup table of
7191 /// the current AST file.
7192 ASTIdentifierLookupTable::key_iterator End;
7194 /// \brief Whether to skip any modules in the ASTReader.
7198 explicit ASTIdentifierIterator(const ASTReader &Reader,
7199 bool SkipModules = false);
7201 StringRef Next() override;
7204 } // end namespace clang
7206 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
7208 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7211 StringRef ASTIdentifierIterator::Next() {
7212 while (Current == End) {
7213 // If we have exhausted all of our AST files, we're done.
7218 ModuleFile &F = Reader.ModuleMgr[Index];
7219 if (SkipModules && F.isModule())
7222 ASTIdentifierLookupTable *IdTable =
7223 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7224 Current = IdTable->key_begin();
7225 End = IdTable->key_end();
7228 // We have any identifiers remaining in the current AST file; return
7230 StringRef Result = *Current;
7237 /// A utility for appending two IdentifierIterators.
7238 class ChainedIdentifierIterator : public IdentifierIterator {
7239 std::unique_ptr<IdentifierIterator> Current;
7240 std::unique_ptr<IdentifierIterator> Queued;
7243 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7244 std::unique_ptr<IdentifierIterator> Second)
7245 : Current(std::move(First)), Queued(std::move(Second)) {}
7247 StringRef Next() override {
7251 StringRef result = Current->Next();
7252 if (!result.empty())
7255 // Try the queued iterator, which may itself be empty.
7257 std::swap(Current, Queued);
7262 } // end anonymous namespace.
7264 IdentifierIterator *ASTReader::getIdentifiers() {
7265 if (!loadGlobalIndex()) {
7266 std::unique_ptr<IdentifierIterator> ReaderIter(
7267 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7268 std::unique_ptr<IdentifierIterator> ModulesIter(
7269 GlobalIndex->createIdentifierIterator());
7270 return new ChainedIdentifierIterator(std::move(ReaderIter),
7271 std::move(ModulesIter));
7274 return new ASTIdentifierIterator(*this);
7278 namespace serialization {
7280 class ReadMethodPoolVisitor {
7283 unsigned PriorGeneration;
7284 unsigned InstanceBits;
7285 unsigned FactoryBits;
7286 bool InstanceHasMoreThanOneDecl;
7287 bool FactoryHasMoreThanOneDecl;
7288 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7289 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7292 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
7293 unsigned PriorGeneration)
7294 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
7295 InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
7296 FactoryHasMoreThanOneDecl(false) {}
7298 bool operator()(ModuleFile &M) {
7299 if (!M.SelectorLookupTable)
7302 // If we've already searched this module file, skip it now.
7303 if (M.Generation <= PriorGeneration)
7306 ++Reader.NumMethodPoolTableLookups;
7307 ASTSelectorLookupTable *PoolTable
7308 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
7309 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
7310 if (Pos == PoolTable->end())
7313 ++Reader.NumMethodPoolTableHits;
7314 ++Reader.NumSelectorsRead;
7315 // FIXME: Not quite happy with the statistics here. We probably should
7316 // disable this tracking when called via LoadSelector.
7317 // Also, should entries without methods count as misses?
7318 ++Reader.NumMethodPoolEntriesRead;
7319 ASTSelectorLookupTrait::data_type Data = *Pos;
7320 if (Reader.DeserializationListener)
7321 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
7323 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7324 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7325 InstanceBits = Data.InstanceBits;
7326 FactoryBits = Data.FactoryBits;
7327 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7328 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
7332 /// \brief Retrieve the instance methods found by this visitor.
7333 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
7334 return InstanceMethods;
7337 /// \brief Retrieve the instance methods found by this visitor.
7338 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
7339 return FactoryMethods;
7342 unsigned getInstanceBits() const { return InstanceBits; }
7343 unsigned getFactoryBits() const { return FactoryBits; }
7344 bool instanceHasMoreThanOneDecl() const {
7345 return InstanceHasMoreThanOneDecl;
7347 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
7350 } // end namespace serialization
7351 } // end namespace clang
7353 /// \brief Add the given set of methods to the method list.
7354 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
7355 ObjCMethodList &List) {
7356 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7357 S.addMethodToGlobalList(&List, Methods[I]);
7361 void ASTReader::ReadMethodPool(Selector Sel) {
7362 // Get the selector generation and update it to the current generation.
7363 unsigned &Generation = SelectorGeneration[Sel];
7364 unsigned PriorGeneration = Generation;
7365 Generation = getGeneration();
7366 SelectorOutOfDate[Sel] = false;
7368 // Search for methods defined with this selector.
7369 ++NumMethodPoolLookups;
7370 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7371 ModuleMgr.visit(Visitor);
7373 if (Visitor.getInstanceMethods().empty() &&
7374 Visitor.getFactoryMethods().empty())
7377 ++NumMethodPoolHits;
7382 Sema &S = *getSema();
7383 Sema::GlobalMethodPool::iterator Pos
7384 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7386 Pos->second.first.setBits(Visitor.getInstanceBits());
7387 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
7388 Pos->second.second.setBits(Visitor.getFactoryBits());
7389 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
7391 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7392 // when building a module we keep every method individually and may need to
7393 // update hasMoreThanOneDecl as we add the methods.
7394 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7395 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7398 void ASTReader::updateOutOfDateSelector(Selector Sel) {
7399 if (SelectorOutOfDate[Sel])
7400 ReadMethodPool(Sel);
7403 void ASTReader::ReadKnownNamespaces(
7404 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7407 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7408 if (NamespaceDecl *Namespace
7409 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7410 Namespaces.push_back(Namespace);
7414 void ASTReader::ReadUndefinedButUsed(
7415 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
7416 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7417 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7418 SourceLocation Loc =
7419 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7420 Undefined.insert(std::make_pair(D, Loc));
7424 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
7425 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7427 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7428 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7429 uint64_t Count = DelayedDeleteExprs[Idx++];
7430 for (uint64_t C = 0; C < Count; ++C) {
7431 SourceLocation DeleteLoc =
7432 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7433 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7434 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7439 void ASTReader::ReadTentativeDefinitions(
7440 SmallVectorImpl<VarDecl *> &TentativeDefs) {
7441 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7442 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7444 TentativeDefs.push_back(Var);
7446 TentativeDefinitions.clear();
7449 void ASTReader::ReadUnusedFileScopedDecls(
7450 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
7451 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7453 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7457 UnusedFileScopedDecls.clear();
7460 void ASTReader::ReadDelegatingConstructors(
7461 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
7462 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7463 CXXConstructorDecl *D
7464 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7468 DelegatingCtorDecls.clear();
7471 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
7472 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7474 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7478 ExtVectorDecls.clear();
7481 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
7482 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
7483 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7485 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7486 GetDecl(UnusedLocalTypedefNameCandidates[I]));
7490 UnusedLocalTypedefNameCandidates.clear();
7493 void ASTReader::ReadReferencedSelectors(
7494 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7495 if (ReferencedSelectorsData.empty())
7498 // If there are @selector references added them to its pool. This is for
7499 // implementation of -Wselector.
7500 unsigned int DataSize = ReferencedSelectorsData.size()-1;
7502 while (I < DataSize) {
7503 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7504 SourceLocation SelLoc
7505 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7506 Sels.push_back(std::make_pair(Sel, SelLoc));
7508 ReferencedSelectorsData.clear();
7511 void ASTReader::ReadWeakUndeclaredIdentifiers(
7512 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7513 if (WeakUndeclaredIdentifiers.empty())
7516 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7517 IdentifierInfo *WeakId
7518 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7519 IdentifierInfo *AliasId
7520 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7522 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7523 bool Used = WeakUndeclaredIdentifiers[I++];
7524 WeakInfo WI(AliasId, Loc);
7526 WeakIDs.push_back(std::make_pair(WeakId, WI));
7528 WeakUndeclaredIdentifiers.clear();
7531 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7532 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7533 ExternalVTableUse VT;
7534 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7535 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7536 VT.DefinitionRequired = VTableUses[Idx++];
7537 VTables.push_back(VT);
7543 void ASTReader::ReadPendingInstantiations(
7544 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7545 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7546 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7548 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7550 Pending.push_back(std::make_pair(D, Loc));
7552 PendingInstantiations.clear();
7555 void ASTReader::ReadLateParsedTemplates(
7556 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
7558 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7560 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7562 auto LT = llvm::make_unique<LateParsedTemplate>();
7563 LT->D = GetDecl(LateParsedTemplates[Idx++]);
7565 ModuleFile *F = getOwningModuleFile(LT->D);
7566 assert(F && "No module");
7568 unsigned TokN = LateParsedTemplates[Idx++];
7569 LT->Toks.reserve(TokN);
7570 for (unsigned T = 0; T < TokN; ++T)
7571 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7573 LPTMap.insert(std::make_pair(FD, std::move(LT)));
7576 LateParsedTemplates.clear();
7579 void ASTReader::LoadSelector(Selector Sel) {
7580 // It would be complicated to avoid reading the methods anyway. So don't.
7581 ReadMethodPool(Sel);
7584 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7585 assert(ID && "Non-zero identifier ID required");
7586 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7587 IdentifiersLoaded[ID - 1] = II;
7588 if (DeserializationListener)
7589 DeserializationListener->IdentifierRead(ID, II);
7592 /// \brief Set the globally-visible declarations associated with the given
7595 /// If the AST reader is currently in a state where the given declaration IDs
7596 /// cannot safely be resolved, they are queued until it is safe to resolve
7599 /// \param II an IdentifierInfo that refers to one or more globally-visible
7602 /// \param DeclIDs the set of declaration IDs with the name @p II that are
7603 /// visible at global scope.
7605 /// \param Decls if non-null, this vector will be populated with the set of
7606 /// deserialized declarations. These declarations will not be pushed into
7609 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7610 const SmallVectorImpl<uint32_t> &DeclIDs,
7611 SmallVectorImpl<Decl *> *Decls) {
7612 if (NumCurrentElementsDeserializing && !Decls) {
7613 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
7617 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
7619 // Queue this declaration so that it will be added to the
7620 // translation unit scope and identifier's declaration chain
7621 // once a Sema object is known.
7622 PreloadedDeclIDs.push_back(DeclIDs[I]);
7626 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7628 // If we're simply supposed to record the declarations, do so now.
7630 Decls->push_back(D);
7634 // Introduce this declaration into the translation-unit scope
7635 // and add it to the declaration chain for this identifier, so
7636 // that (unqualified) name lookup will find it.
7637 pushExternalDeclIntoScope(D, II);
7641 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
7645 if (IdentifiersLoaded.empty()) {
7646 Error("no identifier table in AST file");
7651 if (!IdentifiersLoaded[ID]) {
7652 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7653 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7654 ModuleFile *M = I->second;
7655 unsigned Index = ID - M->BaseIdentifierID;
7656 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7658 // All of the strings in the AST file are preceded by a 16-bit length.
7659 // Extract that 16-bit length to avoid having to execute strlen().
7660 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7661 // unsigned integers. This is important to avoid integer overflow when
7662 // we cast them to 'unsigned'.
7663 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7664 unsigned StrLen = (((unsigned) StrLenPtr[0])
7665 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
7666 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
7667 IdentifiersLoaded[ID] = &II;
7668 markIdentifierFromAST(*this, II);
7669 if (DeserializationListener)
7670 DeserializationListener->IdentifierRead(ID + 1, &II);
7673 return IdentifiersLoaded[ID];
7676 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7677 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
7680 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7681 if (LocalID < NUM_PREDEF_IDENT_IDS)
7684 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7685 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7686 assert(I != M.IdentifierRemap.end()
7687 && "Invalid index into identifier index remap");
7689 return LocalID + I->second;
7692 MacroInfo *ASTReader::getMacro(MacroID ID) {
7696 if (MacrosLoaded.empty()) {
7697 Error("no macro table in AST file");
7701 ID -= NUM_PREDEF_MACRO_IDS;
7702 if (!MacrosLoaded[ID]) {
7703 GlobalMacroMapType::iterator I
7704 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7705 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7706 ModuleFile *M = I->second;
7707 unsigned Index = ID - M->BaseMacroID;
7708 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7710 if (DeserializationListener)
7711 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7715 return MacrosLoaded[ID];
7718 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7719 if (LocalID < NUM_PREDEF_MACRO_IDS)
7722 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7723 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7724 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7726 return LocalID + I->second;
7729 serialization::SubmoduleID
7730 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7731 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7734 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7735 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7736 assert(I != M.SubmoduleRemap.end()
7737 && "Invalid index into submodule index remap");
7739 return LocalID + I->second;
7742 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7743 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7744 assert(GlobalID == 0 && "Unhandled global submodule ID");
7748 if (GlobalID > SubmodulesLoaded.size()) {
7749 Error("submodule ID out of range in AST file");
7753 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7756 Module *ASTReader::getModule(unsigned ID) {
7757 return getSubmodule(ID);
7760 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
7762 // It's a module, look it up by submodule ID.
7763 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
7764 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
7766 // It's a prefix (preamble, PCH, ...). Look it up by index.
7767 unsigned IndexFromEnd = ID >> 1;
7768 assert(IndexFromEnd && "got reference to unknown module file");
7769 return getModuleManager().pch_modules().end()[-IndexFromEnd];
7773 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
7777 // For a file representing a module, use the submodule ID of the top-level
7778 // module as the file ID. For any other kind of file, the number of such
7779 // files loaded beforehand will be the same on reload.
7780 // FIXME: Is this true even if we have an explicit module file and a PCH?
7782 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
7784 auto PCHModules = getModuleManager().pch_modules();
7785 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
7786 assert(I != PCHModules.end() && "emitting reference to unknown file");
7787 return (I - PCHModules.end()) << 1;
7790 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
7791 ASTReader::getSourceDescriptor(unsigned ID) {
7792 if (const Module *M = getSubmodule(ID))
7793 return ExternalASTSource::ASTSourceDescriptor(*M);
7795 // If there is only a single PCH, return it instead.
7796 // Chained PCH are not suported.
7797 if (ModuleMgr.size() == 1) {
7798 ModuleFile &MF = ModuleMgr.getPrimaryModule();
7799 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
7800 StringRef FileName = llvm::sys::path::filename(MF.FileName);
7801 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
7807 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7808 return DecodeSelector(getGlobalSelectorID(M, LocalID));
7811 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7815 if (ID > SelectorsLoaded.size()) {
7816 Error("selector ID out of range in AST file");
7820 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
7821 // Load this selector from the selector table.
7822 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7823 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7824 ModuleFile &M = *I->second;
7825 ASTSelectorLookupTrait Trait(*this, M);
7826 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7827 SelectorsLoaded[ID - 1] =
7828 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7829 if (DeserializationListener)
7830 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7833 return SelectorsLoaded[ID - 1];
7836 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7837 return DecodeSelector(ID);
7840 uint32_t ASTReader::GetNumExternalSelectors() {
7841 // ID 0 (the null selector) is considered an external selector.
7842 return getTotalNumSelectors() + 1;
7845 serialization::SelectorID
7846 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7847 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7850 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7851 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7852 assert(I != M.SelectorRemap.end()
7853 && "Invalid index into selector index remap");
7855 return LocalID + I->second;
7859 ASTReader::ReadDeclarationName(ModuleFile &F,
7860 const RecordData &Record, unsigned &Idx) {
7861 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7863 case DeclarationName::Identifier:
7864 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
7866 case DeclarationName::ObjCZeroArgSelector:
7867 case DeclarationName::ObjCOneArgSelector:
7868 case DeclarationName::ObjCMultiArgSelector:
7869 return DeclarationName(ReadSelector(F, Record, Idx));
7871 case DeclarationName::CXXConstructorName:
7872 return Context.DeclarationNames.getCXXConstructorName(
7873 Context.getCanonicalType(readType(F, Record, Idx)));
7875 case DeclarationName::CXXDestructorName:
7876 return Context.DeclarationNames.getCXXDestructorName(
7877 Context.getCanonicalType(readType(F, Record, Idx)));
7879 case DeclarationName::CXXConversionFunctionName:
7880 return Context.DeclarationNames.getCXXConversionFunctionName(
7881 Context.getCanonicalType(readType(F, Record, Idx)));
7883 case DeclarationName::CXXOperatorName:
7884 return Context.DeclarationNames.getCXXOperatorName(
7885 (OverloadedOperatorKind)Record[Idx++]);
7887 case DeclarationName::CXXLiteralOperatorName:
7888 return Context.DeclarationNames.getCXXLiteralOperatorName(
7889 GetIdentifierInfo(F, Record, Idx));
7891 case DeclarationName::CXXUsingDirective:
7892 return DeclarationName::getUsingDirectiveName();
7895 llvm_unreachable("Invalid NameKind!");
7898 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7899 DeclarationNameLoc &DNLoc,
7900 DeclarationName Name,
7901 const RecordData &Record, unsigned &Idx) {
7902 switch (Name.getNameKind()) {
7903 case DeclarationName::CXXConstructorName:
7904 case DeclarationName::CXXDestructorName:
7905 case DeclarationName::CXXConversionFunctionName:
7906 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7909 case DeclarationName::CXXOperatorName:
7910 DNLoc.CXXOperatorName.BeginOpNameLoc
7911 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7912 DNLoc.CXXOperatorName.EndOpNameLoc
7913 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7916 case DeclarationName::CXXLiteralOperatorName:
7917 DNLoc.CXXLiteralOperatorName.OpNameLoc
7918 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7921 case DeclarationName::Identifier:
7922 case DeclarationName::ObjCZeroArgSelector:
7923 case DeclarationName::ObjCOneArgSelector:
7924 case DeclarationName::ObjCMultiArgSelector:
7925 case DeclarationName::CXXUsingDirective:
7930 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7931 DeclarationNameInfo &NameInfo,
7932 const RecordData &Record, unsigned &Idx) {
7933 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7934 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7935 DeclarationNameLoc DNLoc;
7936 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7937 NameInfo.setInfo(DNLoc);
7940 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7941 const RecordData &Record, unsigned &Idx) {
7942 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7943 unsigned NumTPLists = Record[Idx++];
7944 Info.NumTemplParamLists = NumTPLists;
7946 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7947 for (unsigned i = 0; i != NumTPLists; ++i)
7948 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7953 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7955 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7957 case TemplateName::Template:
7958 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7960 case TemplateName::OverloadedTemplate: {
7961 unsigned size = Record[Idx++];
7962 UnresolvedSet<8> Decls;
7964 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7966 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7969 case TemplateName::QualifiedTemplate: {
7970 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7971 bool hasTemplKeyword = Record[Idx++];
7972 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7973 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7976 case TemplateName::DependentTemplate: {
7977 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7978 if (Record[Idx++]) // isIdentifier
7979 return Context.getDependentTemplateName(NNS,
7980 GetIdentifierInfo(F, Record,
7982 return Context.getDependentTemplateName(NNS,
7983 (OverloadedOperatorKind)Record[Idx++]);
7986 case TemplateName::SubstTemplateTemplateParm: {
7987 TemplateTemplateParmDecl *param
7988 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7989 if (!param) return TemplateName();
7990 TemplateName replacement = ReadTemplateName(F, Record, Idx);
7991 return Context.getSubstTemplateTemplateParm(param, replacement);
7994 case TemplateName::SubstTemplateTemplateParmPack: {
7995 TemplateTemplateParmDecl *Param
7996 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7998 return TemplateName();
8000 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8001 if (ArgPack.getKind() != TemplateArgument::Pack)
8002 return TemplateName();
8004 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8008 llvm_unreachable("Unhandled template name kind!");
8011 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
8012 const RecordData &Record,
8014 bool Canonicalize) {
8016 // The caller wants a canonical template argument. Sometimes the AST only
8017 // wants template arguments in canonical form (particularly as the template
8018 // argument lists of template specializations) so ensure we preserve that
8019 // canonical form across serialization.
8020 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8021 return Context.getCanonicalTemplateArgument(Arg);
8024 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
8026 case TemplateArgument::Null:
8027 return TemplateArgument();
8028 case TemplateArgument::Type:
8029 return TemplateArgument(readType(F, Record, Idx));
8030 case TemplateArgument::Declaration: {
8031 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8032 return TemplateArgument(D, readType(F, Record, Idx));
8034 case TemplateArgument::NullPtr:
8035 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8036 case TemplateArgument::Integral: {
8037 llvm::APSInt Value = ReadAPSInt(Record, Idx);
8038 QualType T = readType(F, Record, Idx);
8039 return TemplateArgument(Context, Value, T);
8041 case TemplateArgument::Template:
8042 return TemplateArgument(ReadTemplateName(F, Record, Idx));
8043 case TemplateArgument::TemplateExpansion: {
8044 TemplateName Name = ReadTemplateName(F, Record, Idx);
8045 Optional<unsigned> NumTemplateExpansions;
8046 if (unsigned NumExpansions = Record[Idx++])
8047 NumTemplateExpansions = NumExpansions - 1;
8048 return TemplateArgument(Name, NumTemplateExpansions);
8050 case TemplateArgument::Expression:
8051 return TemplateArgument(ReadExpr(F));
8052 case TemplateArgument::Pack: {
8053 unsigned NumArgs = Record[Idx++];
8054 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8055 for (unsigned I = 0; I != NumArgs; ++I)
8056 Args[I] = ReadTemplateArgument(F, Record, Idx);
8057 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8061 llvm_unreachable("Unhandled template argument kind!");
8064 TemplateParameterList *
8065 ASTReader::ReadTemplateParameterList(ModuleFile &F,
8066 const RecordData &Record, unsigned &Idx) {
8067 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8068 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8069 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8071 unsigned NumParams = Record[Idx++];
8072 SmallVector<NamedDecl *, 16> Params;
8073 Params.reserve(NumParams);
8075 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8078 TemplateParameterList* TemplateParams =
8079 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
8080 Params, RAngleLoc, nullptr);
8081 return TemplateParams;
8086 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
8087 ModuleFile &F, const RecordData &Record,
8088 unsigned &Idx, bool Canonicalize) {
8089 unsigned NumTemplateArgs = Record[Idx++];
8090 TemplArgs.reserve(NumTemplateArgs);
8091 while (NumTemplateArgs--)
8092 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8095 /// \brief Read a UnresolvedSet structure.
8096 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
8097 const RecordData &Record, unsigned &Idx) {
8098 unsigned NumDecls = Record[Idx++];
8099 Set.reserve(Context, NumDecls);
8100 while (NumDecls--) {
8101 DeclID ID = ReadDeclID(F, Record, Idx);
8102 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8103 Set.addLazyDecl(Context, ID, AS);
8108 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
8109 const RecordData &Record, unsigned &Idx) {
8110 bool isVirtual = static_cast<bool>(Record[Idx++]);
8111 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8112 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8113 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8114 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8115 SourceRange Range = ReadSourceRange(F, Record, Idx);
8116 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8117 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8119 Result.setInheritConstructors(inheritConstructors);
8123 CXXCtorInitializer **
8124 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8126 unsigned NumInitializers = Record[Idx++];
8127 assert(NumInitializers && "wrote ctor initializers but have no inits");
8128 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8129 for (unsigned i = 0; i != NumInitializers; ++i) {
8130 TypeSourceInfo *TInfo = nullptr;
8131 bool IsBaseVirtual = false;
8132 FieldDecl *Member = nullptr;
8133 IndirectFieldDecl *IndirectMember = nullptr;
8135 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8137 case CTOR_INITIALIZER_BASE:
8138 TInfo = GetTypeSourceInfo(F, Record, Idx);
8139 IsBaseVirtual = Record[Idx++];
8142 case CTOR_INITIALIZER_DELEGATING:
8143 TInfo = GetTypeSourceInfo(F, Record, Idx);
8146 case CTOR_INITIALIZER_MEMBER:
8147 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8150 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8151 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8155 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8156 Expr *Init = ReadExpr(F);
8157 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8158 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8160 CXXCtorInitializer *BOMInit;
8161 if (Type == CTOR_INITIALIZER_BASE)
8162 BOMInit = new (Context)
8163 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8164 RParenLoc, MemberOrEllipsisLoc);
8165 else if (Type == CTOR_INITIALIZER_DELEGATING)
8166 BOMInit = new (Context)
8167 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8169 BOMInit = new (Context)
8170 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8173 BOMInit = new (Context)
8174 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8175 LParenLoc, Init, RParenLoc);
8177 if (/*IsWritten*/Record[Idx++]) {
8178 unsigned SourceOrder = Record[Idx++];
8179 BOMInit->setSourceOrder(SourceOrder);
8182 CtorInitializers[i] = BOMInit;
8185 return CtorInitializers;
8188 NestedNameSpecifier *
8189 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8190 const RecordData &Record, unsigned &Idx) {
8191 unsigned N = Record[Idx++];
8192 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8193 for (unsigned I = 0; I != N; ++I) {
8194 NestedNameSpecifier::SpecifierKind Kind
8195 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8197 case NestedNameSpecifier::Identifier: {
8198 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8199 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8203 case NestedNameSpecifier::Namespace: {
8204 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8205 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8209 case NestedNameSpecifier::NamespaceAlias: {
8210 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8211 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8215 case NestedNameSpecifier::TypeSpec:
8216 case NestedNameSpecifier::TypeSpecWithTemplate: {
8217 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8221 bool Template = Record[Idx++];
8222 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8226 case NestedNameSpecifier::Global: {
8227 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8228 // No associated value, and there can't be a prefix.
8232 case NestedNameSpecifier::Super: {
8233 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8234 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8243 NestedNameSpecifierLoc
8244 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
8246 unsigned N = Record[Idx++];
8247 NestedNameSpecifierLocBuilder Builder;
8248 for (unsigned I = 0; I != N; ++I) {
8249 NestedNameSpecifier::SpecifierKind Kind
8250 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8252 case NestedNameSpecifier::Identifier: {
8253 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8254 SourceRange Range = ReadSourceRange(F, Record, Idx);
8255 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8259 case NestedNameSpecifier::Namespace: {
8260 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8261 SourceRange Range = ReadSourceRange(F, Record, Idx);
8262 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8266 case NestedNameSpecifier::NamespaceAlias: {
8267 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8268 SourceRange Range = ReadSourceRange(F, Record, Idx);
8269 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8273 case NestedNameSpecifier::TypeSpec:
8274 case NestedNameSpecifier::TypeSpecWithTemplate: {
8275 bool Template = Record[Idx++];
8276 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8278 return NestedNameSpecifierLoc();
8279 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8281 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8282 Builder.Extend(Context,
8283 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8284 T->getTypeLoc(), ColonColonLoc);
8288 case NestedNameSpecifier::Global: {
8289 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8290 Builder.MakeGlobal(Context, ColonColonLoc);
8294 case NestedNameSpecifier::Super: {
8295 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8296 SourceRange Range = ReadSourceRange(F, Record, Idx);
8297 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8303 return Builder.getWithLocInContext(Context);
8307 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8309 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8310 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8311 return SourceRange(beg, end);
8314 /// \brief Read an integral value
8315 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8316 unsigned BitWidth = Record[Idx++];
8317 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8318 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8323 /// \brief Read a signed integral value
8324 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8325 bool isUnsigned = Record[Idx++];
8326 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8329 /// \brief Read a floating-point value
8330 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8331 const llvm::fltSemantics &Sem,
8333 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8336 // \brief Read a string
8337 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8338 unsigned Len = Record[Idx++];
8339 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8344 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8346 std::string Filename = ReadString(Record, Idx);
8347 ResolveImportedPath(F, Filename);
8351 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8353 unsigned Major = Record[Idx++];
8354 unsigned Minor = Record[Idx++];
8355 unsigned Subminor = Record[Idx++];
8357 return VersionTuple(Major);
8359 return VersionTuple(Major, Minor - 1);
8360 return VersionTuple(Major, Minor - 1, Subminor - 1);
8363 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8364 const RecordData &Record,
8366 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8367 return CXXTemporary::Create(Context, Decl);
8370 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
8371 return Diag(CurrentImportLoc, DiagID);
8374 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8375 return Diags.Report(Loc, DiagID);
8378 /// \brief Retrieve the identifier table associated with the
8380 IdentifierTable &ASTReader::getIdentifierTable() {
8381 return PP.getIdentifierTable();
8384 /// \brief Record that the given ID maps to the given switch-case
8386 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
8387 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8388 "Already have a SwitchCase with this ID");
8389 (*CurrSwitchCaseStmts)[ID] = SC;
8392 /// \brief Retrieve the switch-case statement with the given ID.
8393 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
8394 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8395 return (*CurrSwitchCaseStmts)[ID];
8398 void ASTReader::ClearSwitchCaseIDs() {
8399 CurrSwitchCaseStmts->clear();
8402 void ASTReader::ReadComments() {
8403 std::vector<RawComment *> Comments;
8404 for (SmallVectorImpl<std::pair<BitstreamCursor,
8405 serialization::ModuleFile *> >::iterator
8406 I = CommentsCursors.begin(),
8407 E = CommentsCursors.end();
8410 BitstreamCursor &Cursor = I->first;
8411 serialization::ModuleFile &F = *I->second;
8412 SavedStreamPosition SavedPosition(Cursor);
8416 llvm::BitstreamEntry Entry =
8417 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8419 switch (Entry.Kind) {
8420 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8421 case llvm::BitstreamEntry::Error:
8422 Error("malformed block record in AST file");
8424 case llvm::BitstreamEntry::EndBlock:
8426 case llvm::BitstreamEntry::Record:
8427 // The interesting case.
8433 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8434 case COMMENTS_RAW_COMMENT: {
8436 SourceRange SR = ReadSourceRange(F, Record, Idx);
8437 RawComment::CommentKind Kind =
8438 (RawComment::CommentKind) Record[Idx++];
8439 bool IsTrailingComment = Record[Idx++];
8440 bool IsAlmostTrailingComment = Record[Idx++];
8441 Comments.push_back(new (Context) RawComment(
8442 SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8443 Context.getLangOpts().CommentOpts.ParseAllComments));
8449 Context.Comments.addDeserializedComments(Comments);
8453 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8454 // If we know the owning module, use it.
8455 if (Module *M = D->getImportedOwningModule())
8456 return M->getFullModuleName();
8458 // Otherwise, use the name of the top-level module the decl is within.
8459 if (ModuleFile *M = getOwningModuleFile(D))
8460 return M->ModuleName;
8462 // Not from a module.
8466 void ASTReader::finishPendingActions() {
8467 while (!PendingIdentifierInfos.empty() ||
8468 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8469 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8470 !PendingUpdateRecords.empty()) {
8471 // If any identifiers with corresponding top-level declarations have
8472 // been loaded, load those declarations now.
8473 typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8475 TopLevelDeclsMap TopLevelDecls;
8477 while (!PendingIdentifierInfos.empty()) {
8478 IdentifierInfo *II = PendingIdentifierInfos.back().first;
8479 SmallVector<uint32_t, 4> DeclIDs =
8480 std::move(PendingIdentifierInfos.back().second);
8481 PendingIdentifierInfos.pop_back();
8483 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
8486 // For each decl chain that we wanted to complete while deserializing, mark
8487 // it as "still needs to be completed".
8488 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8489 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8491 PendingIncompleteDeclChains.clear();
8493 // Load pending declaration chains.
8494 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
8495 loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
8496 PendingDeclChains.clear();
8498 // Make the most recent of the top-level declarations visible.
8499 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8500 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
8501 IdentifierInfo *II = TLD->first;
8502 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
8503 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
8507 // Load any pending macro definitions.
8508 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
8509 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8510 SmallVector<PendingMacroInfo, 2> GlobalIDs;
8511 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8512 // Initialize the macro history from chained-PCHs ahead of module imports.
8513 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8515 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8516 if (!Info.M->isModule())
8517 resolvePendingMacro(II, Info);
8519 // Handle module imports.
8520 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8522 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8523 if (Info.M->isModule())
8524 resolvePendingMacro(II, Info);
8527 PendingMacroIDs.clear();
8529 // Wire up the DeclContexts for Decls that we delayed setting until
8530 // recursive loading is completed.
8531 while (!PendingDeclContextInfos.empty()) {
8532 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8533 PendingDeclContextInfos.pop_front();
8534 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8535 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8536 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8539 // Perform any pending declaration updates.
8540 while (!PendingUpdateRecords.empty()) {
8541 auto Update = PendingUpdateRecords.pop_back_val();
8542 ReadingKindTracker ReadingKind(Read_Decl, *this);
8543 loadDeclUpdateRecords(Update.first, Update.second);
8547 // At this point, all update records for loaded decls are in place, so any
8548 // fake class definitions should have become real.
8549 assert(PendingFakeDefinitionData.empty() &&
8550 "faked up a class definition but never saw the real one");
8552 // If we deserialized any C++ or Objective-C class definitions, any
8553 // Objective-C protocol definitions, or any redeclarable templates, make sure
8554 // that all redeclarations point to the definitions. Note that this can only
8555 // happen now, after the redeclaration chains have been fully wired.
8556 for (Decl *D : PendingDefinitions) {
8557 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
8558 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
8559 // Make sure that the TagType points at the definition.
8560 const_cast<TagType*>(TagT)->decl = TD;
8563 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
8564 for (auto *R = getMostRecentExistingDecl(RD); R;
8565 R = R->getPreviousDecl()) {
8567 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
8568 "declaration thinks it's the definition but it isn't");
8569 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
8576 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
8577 // Make sure that the ObjCInterfaceType points at the definition.
8578 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8581 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
8582 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
8587 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
8588 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
8589 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
8594 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
8595 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
8596 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
8598 PendingDefinitions.clear();
8600 // Load the bodies of any functions or methods we've encountered. We do
8601 // this now (delayed) so that we can be sure that the declaration chains
8602 // have been fully wired up (hasBody relies on this).
8603 // FIXME: We shouldn't require complete redeclaration chains here.
8604 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8605 PBEnd = PendingBodies.end();
8606 PB != PBEnd; ++PB) {
8607 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8608 // FIXME: Check for =delete/=default?
8609 // FIXME: Complain about ODR violations here?
8610 const FunctionDecl *Defn = nullptr;
8611 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn))
8612 FD->setLazyBody(PB->second);
8614 mergeDefinitionVisibility(const_cast<FunctionDecl*>(Defn), FD);
8618 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8619 if (!getContext().getLangOpts().Modules || !MD->hasBody())
8620 MD->setLazyBody(PB->second);
8622 PendingBodies.clear();
8625 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
8626 getContext().deduplicateMergedDefinitonsFor(ND);
8627 PendingMergedDefinitionsToDeduplicate.clear();
8630 void ASTReader::diagnoseOdrViolations() {
8631 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8634 // Trigger the import of the full definition of each class that had any
8635 // odr-merging problems, so we can produce better diagnostics for them.
8636 // These updates may in turn find and diagnose some ODR failures, so take
8637 // ownership of the set first.
8638 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8639 PendingOdrMergeFailures.clear();
8640 for (auto &Merge : OdrMergeFailures) {
8641 Merge.first->buildLookup();
8642 Merge.first->decls_begin();
8643 Merge.first->bases_begin();
8644 Merge.first->vbases_begin();
8645 for (auto *RD : Merge.second) {
8652 // For each declaration from a merged context, check that the canonical
8653 // definition of that context also contains a declaration of the same
8656 // Caution: this loop does things that might invalidate iterators into
8657 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8658 while (!PendingOdrMergeChecks.empty()) {
8659 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8661 // FIXME: Skip over implicit declarations for now. This matters for things
8662 // like implicitly-declared special member functions. This isn't entirely
8663 // correct; we can end up with multiple unmerged declarations of the same
8665 if (D->isImplicit())
8668 DeclContext *CanonDef = D->getDeclContext();
8671 const Decl *DCanon = D->getCanonicalDecl();
8673 for (auto RI : D->redecls()) {
8674 if (RI->getLexicalDeclContext() == CanonDef) {
8682 // Quick check failed, time to do the slow thing. Note, we can't just
8683 // look up the name of D in CanonDef here, because the member that is
8684 // in CanonDef might not be found by name lookup (it might have been
8685 // replaced by a more recent declaration in the lookup table), and we
8686 // can't necessarily find it in the redeclaration chain because it might
8687 // be merely mergeable, not redeclarable.
8688 llvm::SmallVector<const NamedDecl*, 4> Candidates;
8689 for (auto *CanonMember : CanonDef->decls()) {
8690 if (CanonMember->getCanonicalDecl() == DCanon) {
8691 // This can happen if the declaration is merely mergeable and not
8692 // actually redeclarable (we looked for redeclarations earlier).
8694 // FIXME: We should be able to detect this more efficiently, without
8695 // pulling in all of the members of CanonDef.
8699 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
8700 if (ND->getDeclName() == D->getDeclName())
8701 Candidates.push_back(ND);
8705 // The AST doesn't like TagDecls becoming invalid after they've been
8706 // completed. We only really need to mark FieldDecls as invalid here.
8707 if (!isa<TagDecl>(D))
8708 D->setInvalidDecl();
8710 // Ensure we don't accidentally recursively enter deserialization while
8711 // we're producing our diagnostic.
8712 Deserializing RecursionGuard(this);
8714 std::string CanonDefModule =
8715 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8716 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8717 << D << getOwningModuleNameForDiagnostic(D)
8718 << CanonDef << CanonDefModule.empty() << CanonDefModule;
8720 if (Candidates.empty())
8721 Diag(cast<Decl>(CanonDef)->getLocation(),
8722 diag::note_module_odr_violation_no_possible_decls) << D;
8724 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8725 Diag(Candidates[I]->getLocation(),
8726 diag::note_module_odr_violation_possible_decl)
8730 DiagnosedOdrMergeFailures.insert(CanonDef);
8734 if (OdrMergeFailures.empty())
8737 // Ensure we don't accidentally recursively enter deserialization while
8738 // we're producing our diagnostics.
8739 Deserializing RecursionGuard(this);
8741 // Issue any pending ODR-failure diagnostics.
8742 for (auto &Merge : OdrMergeFailures) {
8743 // If we've already pointed out a specific problem with this class, don't
8744 // bother issuing a general "something's different" diagnostic.
8745 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
8748 bool Diagnosed = false;
8749 for (auto *RD : Merge.second) {
8750 // Multiple different declarations got merged together; tell the user
8751 // where they came from.
8752 if (Merge.first != RD) {
8753 // FIXME: Walk the definition, figure out what's different,
8754 // and diagnose that.
8756 std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8757 Diag(Merge.first->getLocation(),
8758 diag::err_module_odr_violation_different_definitions)
8759 << Merge.first << Module.empty() << Module;
8763 Diag(RD->getLocation(),
8764 diag::note_module_odr_violation_different_definitions)
8765 << getOwningModuleNameForDiagnostic(RD);
8770 // All definitions are updates to the same declaration. This happens if a
8771 // module instantiates the declaration of a class template specialization
8772 // and two or more other modules instantiate its definition.
8774 // FIXME: Indicate which modules had instantiations of this definition.
8775 // FIXME: How can this even happen?
8776 Diag(Merge.first->getLocation(),
8777 diag::err_module_odr_violation_different_instantiations)
8783 void ASTReader::StartedDeserializing() {
8784 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
8785 ReadTimer->startTimer();
8788 void ASTReader::FinishedDeserializing() {
8789 assert(NumCurrentElementsDeserializing &&
8790 "FinishedDeserializing not paired with StartedDeserializing");
8791 if (NumCurrentElementsDeserializing == 1) {
8792 // We decrease NumCurrentElementsDeserializing only after pending actions
8793 // are finished, to avoid recursively re-calling finishPendingActions().
8794 finishPendingActions();
8796 --NumCurrentElementsDeserializing;
8798 if (NumCurrentElementsDeserializing == 0) {
8799 // Propagate exception specification updates along redeclaration chains.
8800 while (!PendingExceptionSpecUpdates.empty()) {
8801 auto Updates = std::move(PendingExceptionSpecUpdates);
8802 PendingExceptionSpecUpdates.clear();
8803 for (auto Update : Updates) {
8804 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
8805 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
8806 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
8807 if (auto *Listener = Context.getASTMutationListener())
8808 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
8809 for (auto *Redecl : Update.second->redecls())
8810 Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
8815 ReadTimer->stopTimer();
8817 diagnoseOdrViolations();
8819 // We are not in recursive loading, so it's safe to pass the "interesting"
8820 // decls to the consumer.
8822 PassInterestingDeclsToConsumer();
8826 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
8827 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
8828 // Remove any fake results before adding any real ones.
8829 auto It = PendingFakeLookupResults.find(II);
8830 if (It != PendingFakeLookupResults.end()) {
8831 for (auto *ND : It->second)
8832 SemaObj->IdResolver.RemoveDecl(ND);
8833 // FIXME: this works around module+PCH performance issue.
8834 // Rather than erase the result from the map, which is O(n), just clear
8835 // the vector of NamedDecls.
8840 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8841 SemaObj->TUScope->AddDecl(D);
8842 } else if (SemaObj->TUScope) {
8843 // Adding the decl to IdResolver may have failed because it was already in
8844 // (even though it was not added in scope). If it is already in, make sure
8845 // it gets in the scope as well.
8846 if (std::find(SemaObj->IdResolver.begin(Name),
8847 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8848 SemaObj->TUScope->AddDecl(D);
8852 ASTReader::ASTReader(
8853 Preprocessor &PP, ASTContext &Context,
8854 const PCHContainerReader &PCHContainerRdr,
8855 ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
8856 StringRef isysroot, bool DisableValidation,
8857 bool AllowASTWithCompilerErrors,
8858 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8859 bool UseGlobalIndex,
8860 std::unique_ptr<llvm::Timer> ReadTimer)
8861 : Listener(DisableValidation ?
8862 cast<ASTReaderListener>(new SimpleASTReaderListener(PP)) :
8863 cast<ASTReaderListener>(new PCHValidator(PP, *this))),
8864 DeserializationListener(nullptr),
8865 OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
8866 FileMgr(PP.getFileManager()), PCHContainerRdr(PCHContainerRdr),
8867 Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context),
8868 Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerRdr),
8869 DummyIdResolver(PP),
8870 ReadTimer(std::move(ReadTimer)),
8871 PragmaMSStructState(-1),
8872 PragmaMSPointersToMembersState(-1),
8873 isysroot(isysroot), DisableValidation(DisableValidation),
8874 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8875 AllowConfigurationMismatch(AllowConfigurationMismatch),
8876 ValidateSystemInputs(ValidateSystemInputs),
8877 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
8878 ProcessingUpdateRecords(false),
8879 CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0),
8880 TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0),
8881 NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0),
8882 NumIdentifierLookupHits(0), NumSelectorsRead(0),
8883 NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8884 NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8885 NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8886 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8887 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8888 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
8889 PassingDeclsToConsumer(false), ReadingKind(Read_None) {
8890 SourceMgr.setExternalSLocEntrySource(this);
8892 for (const auto &Ext : Extensions) {
8893 auto BlockName = Ext->getExtensionMetadata().BlockName;
8894 auto Known = ModuleFileExtensions.find(BlockName);
8895 if (Known != ModuleFileExtensions.end()) {
8896 Diags.Report(diag::warn_duplicate_module_file_extension)
8901 ModuleFileExtensions.insert({BlockName, Ext});
8905 ASTReader::~ASTReader() {
8906 if (OwnsDeserializationListener)
8907 delete DeserializationListener;
8910 IdentifierResolver &ASTReader::getIdResolver() {
8911 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;