xref: /freebsd/contrib/llvm-project/clang/lib/Serialization/ASTReader.cpp (revision e1c4c8dd8d2d10b6104f06856a77bd5b4813a801)
1 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file defines the ASTReader class, which reads AST files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "ASTCommon.h"
14 #include "ASTReaderInternals.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/ASTStructuralEquivalence.h"
19 #include "clang/AST/ASTUnresolvedSet.h"
20 #include "clang/AST/AbstractTypeReader.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclarationName.h"
29 #include "clang/AST/Expr.h"
30 #include "clang/AST/ExprCXX.h"
31 #include "clang/AST/ExternalASTSource.h"
32 #include "clang/AST/NestedNameSpecifier.h"
33 #include "clang/AST/ODRDiagsEmitter.h"
34 #include "clang/AST/ODRHash.h"
35 #include "clang/AST/OpenMPClause.h"
36 #include "clang/AST/RawCommentList.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/TemplateName.h"
39 #include "clang/AST/Type.h"
40 #include "clang/AST/TypeLoc.h"
41 #include "clang/AST/TypeLocVisitor.h"
42 #include "clang/AST/UnresolvedSet.h"
43 #include "clang/Basic/CommentOptions.h"
44 #include "clang/Basic/Diagnostic.h"
45 #include "clang/Basic/DiagnosticError.h"
46 #include "clang/Basic/DiagnosticOptions.h"
47 #include "clang/Basic/DiagnosticSema.h"
48 #include "clang/Basic/ExceptionSpecificationType.h"
49 #include "clang/Basic/FileManager.h"
50 #include "clang/Basic/FileSystemOptions.h"
51 #include "clang/Basic/IdentifierTable.h"
52 #include "clang/Basic/LLVM.h"
53 #include "clang/Basic/LangOptions.h"
54 #include "clang/Basic/Module.h"
55 #include "clang/Basic/ObjCRuntime.h"
56 #include "clang/Basic/OpenMPKinds.h"
57 #include "clang/Basic/OperatorKinds.h"
58 #include "clang/Basic/PragmaKinds.h"
59 #include "clang/Basic/Sanitizers.h"
60 #include "clang/Basic/SourceLocation.h"
61 #include "clang/Basic/SourceManager.h"
62 #include "clang/Basic/SourceManagerInternals.h"
63 #include "clang/Basic/Specifiers.h"
64 #include "clang/Basic/TargetInfo.h"
65 #include "clang/Basic/TargetOptions.h"
66 #include "clang/Basic/TokenKinds.h"
67 #include "clang/Basic/Version.h"
68 #include "clang/Lex/HeaderSearch.h"
69 #include "clang/Lex/HeaderSearchOptions.h"
70 #include "clang/Lex/MacroInfo.h"
71 #include "clang/Lex/ModuleMap.h"
72 #include "clang/Lex/PreprocessingRecord.h"
73 #include "clang/Lex/Preprocessor.h"
74 #include "clang/Lex/PreprocessorOptions.h"
75 #include "clang/Lex/Token.h"
76 #include "clang/Sema/ObjCMethodList.h"
77 #include "clang/Sema/Scope.h"
78 #include "clang/Sema/Sema.h"
79 #include "clang/Sema/Weak.h"
80 #include "clang/Serialization/ASTBitCodes.h"
81 #include "clang/Serialization/ASTDeserializationListener.h"
82 #include "clang/Serialization/ASTRecordReader.h"
83 #include "clang/Serialization/ContinuousRangeMap.h"
84 #include "clang/Serialization/GlobalModuleIndex.h"
85 #include "clang/Serialization/InMemoryModuleCache.h"
86 #include "clang/Serialization/ModuleFile.h"
87 #include "clang/Serialization/ModuleFileExtension.h"
88 #include "clang/Serialization/ModuleManager.h"
89 #include "clang/Serialization/PCHContainerOperations.h"
90 #include "clang/Serialization/SerializationDiagnostic.h"
91 #include "llvm/ADT/APFloat.h"
92 #include "llvm/ADT/APInt.h"
93 #include "llvm/ADT/APSInt.h"
94 #include "llvm/ADT/ArrayRef.h"
95 #include "llvm/ADT/DenseMap.h"
96 #include "llvm/ADT/FloatingPointMode.h"
97 #include "llvm/ADT/FoldingSet.h"
98 #include "llvm/ADT/Hashing.h"
99 #include "llvm/ADT/IntrusiveRefCntPtr.h"
100 #include "llvm/ADT/STLExtras.h"
101 #include "llvm/ADT/ScopeExit.h"
102 #include "llvm/ADT/SmallPtrSet.h"
103 #include "llvm/ADT/SmallString.h"
104 #include "llvm/ADT/SmallVector.h"
105 #include "llvm/ADT/StringExtras.h"
106 #include "llvm/ADT/StringMap.h"
107 #include "llvm/ADT/StringRef.h"
108 #include "llvm/ADT/iterator_range.h"
109 #include "llvm/Bitstream/BitstreamReader.h"
110 #include "llvm/Support/Casting.h"
111 #include "llvm/Support/Compiler.h"
112 #include "llvm/Support/Compression.h"
113 #include "llvm/Support/DJB.h"
114 #include "llvm/Support/Endian.h"
115 #include "llvm/Support/Error.h"
116 #include "llvm/Support/ErrorHandling.h"
117 #include "llvm/Support/FileSystem.h"
118 #include "llvm/Support/LEB128.h"
119 #include "llvm/Support/MemoryBuffer.h"
120 #include "llvm/Support/Path.h"
121 #include "llvm/Support/SaveAndRestore.h"
122 #include "llvm/Support/TimeProfiler.h"
123 #include "llvm/Support/Timer.h"
124 #include "llvm/Support/VersionTuple.h"
125 #include "llvm/Support/raw_ostream.h"
126 #include "llvm/TargetParser/Triple.h"
127 #include <algorithm>
128 #include <cassert>
129 #include <cstddef>
130 #include <cstdint>
131 #include <cstdio>
132 #include <ctime>
133 #include <iterator>
134 #include <limits>
135 #include <map>
136 #include <memory>
137 #include <optional>
138 #include <string>
139 #include <system_error>
140 #include <tuple>
141 #include <utility>
142 #include <vector>
143 
144 using namespace clang;
145 using namespace clang::serialization;
146 using namespace clang::serialization::reader;
147 using llvm::BitstreamCursor;
148 
149 //===----------------------------------------------------------------------===//
150 // ChainedASTReaderListener implementation
151 //===----------------------------------------------------------------------===//
152 
153 bool
154 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
155   return First->ReadFullVersionInformation(FullVersion) ||
156          Second->ReadFullVersionInformation(FullVersion);
157 }
158 
159 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
160   First->ReadModuleName(ModuleName);
161   Second->ReadModuleName(ModuleName);
162 }
163 
164 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
165   First->ReadModuleMapFile(ModuleMapPath);
166   Second->ReadModuleMapFile(ModuleMapPath);
167 }
168 
169 bool
170 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
171                                               bool Complain,
172                                               bool AllowCompatibleDifferences) {
173   return First->ReadLanguageOptions(LangOpts, Complain,
174                                     AllowCompatibleDifferences) ||
175          Second->ReadLanguageOptions(LangOpts, Complain,
176                                      AllowCompatibleDifferences);
177 }
178 
179 bool ChainedASTReaderListener::ReadTargetOptions(
180     const TargetOptions &TargetOpts, bool Complain,
181     bool AllowCompatibleDifferences) {
182   return First->ReadTargetOptions(TargetOpts, Complain,
183                                   AllowCompatibleDifferences) ||
184          Second->ReadTargetOptions(TargetOpts, Complain,
185                                    AllowCompatibleDifferences);
186 }
187 
188 bool ChainedASTReaderListener::ReadDiagnosticOptions(
189     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
190   return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
191          Second->ReadDiagnosticOptions(DiagOpts, Complain);
192 }
193 
194 bool
195 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
196                                                 bool Complain) {
197   return First->ReadFileSystemOptions(FSOpts, Complain) ||
198          Second->ReadFileSystemOptions(FSOpts, Complain);
199 }
200 
201 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
202     const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
203     bool Complain) {
204   return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
205                                         Complain) ||
206          Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
207                                          Complain);
208 }
209 
210 bool ChainedASTReaderListener::ReadPreprocessorOptions(
211     const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain,
212     std::string &SuggestedPredefines) {
213   return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
214                                         SuggestedPredefines) ||
215          Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
216                                          SuggestedPredefines);
217 }
218 
219 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
220                                            unsigned Value) {
221   First->ReadCounter(M, Value);
222   Second->ReadCounter(M, Value);
223 }
224 
225 bool ChainedASTReaderListener::needsInputFileVisitation() {
226   return First->needsInputFileVisitation() ||
227          Second->needsInputFileVisitation();
228 }
229 
230 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
231   return First->needsSystemInputFileVisitation() ||
232   Second->needsSystemInputFileVisitation();
233 }
234 
235 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
236                                                ModuleKind Kind) {
237   First->visitModuleFile(Filename, Kind);
238   Second->visitModuleFile(Filename, Kind);
239 }
240 
241 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
242                                               bool isSystem,
243                                               bool isOverridden,
244                                               bool isExplicitModule) {
245   bool Continue = false;
246   if (First->needsInputFileVisitation() &&
247       (!isSystem || First->needsSystemInputFileVisitation()))
248     Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
249                                       isExplicitModule);
250   if (Second->needsInputFileVisitation() &&
251       (!isSystem || Second->needsSystemInputFileVisitation()))
252     Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
253                                        isExplicitModule);
254   return Continue;
255 }
256 
257 void ChainedASTReaderListener::readModuleFileExtension(
258        const ModuleFileExtensionMetadata &Metadata) {
259   First->readModuleFileExtension(Metadata);
260   Second->readModuleFileExtension(Metadata);
261 }
262 
263 //===----------------------------------------------------------------------===//
264 // PCH validator implementation
265 //===----------------------------------------------------------------------===//
266 
267 ASTReaderListener::~ASTReaderListener() = default;
268 
269 /// Compare the given set of language options against an existing set of
270 /// language options.
271 ///
272 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
273 /// \param AllowCompatibleDifferences If true, differences between compatible
274 ///        language options will be permitted.
275 ///
276 /// \returns true if the languagae options mis-match, false otherwise.
277 static bool checkLanguageOptions(const LangOptions &LangOpts,
278                                  const LangOptions &ExistingLangOpts,
279                                  DiagnosticsEngine *Diags,
280                                  bool AllowCompatibleDifferences = true) {
281 #define LANGOPT(Name, Bits, Default, Description)                   \
282   if (ExistingLangOpts.Name != LangOpts.Name) {                     \
283     if (Diags) {                                                    \
284       if (Bits == 1)                                                \
285         Diags->Report(diag::err_pch_langopt_mismatch)               \
286           << Description << LangOpts.Name << ExistingLangOpts.Name; \
287       else                                                          \
288         Diags->Report(diag::err_pch_langopt_value_mismatch)         \
289           << Description;                                           \
290     }                                                               \
291     return true;                                                    \
292   }
293 
294 #define VALUE_LANGOPT(Name, Bits, Default, Description)   \
295   if (ExistingLangOpts.Name != LangOpts.Name) {           \
296     if (Diags)                                            \
297       Diags->Report(diag::err_pch_langopt_value_mismatch) \
298         << Description;                                   \
299     return true;                                          \
300   }
301 
302 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)   \
303   if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) {  \
304     if (Diags)                                                 \
305       Diags->Report(diag::err_pch_langopt_value_mismatch)      \
306         << Description;                                        \
307     return true;                                               \
308   }
309 
310 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description)  \
311   if (!AllowCompatibleDifferences)                            \
312     LANGOPT(Name, Bits, Default, Description)
313 
314 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description)  \
315   if (!AllowCompatibleDifferences)                                 \
316     ENUM_LANGOPT(Name, Bits, Default, Description)
317 
318 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
319   if (!AllowCompatibleDifferences)                                 \
320     VALUE_LANGOPT(Name, Bits, Default, Description)
321 
322 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
323 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
324 #define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
325 #include "clang/Basic/LangOptions.def"
326 
327   if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
328     if (Diags)
329       Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
330     return true;
331   }
332 
333   if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
334     if (Diags)
335       Diags->Report(diag::err_pch_langopt_value_mismatch)
336       << "target Objective-C runtime";
337     return true;
338   }
339 
340   if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
341       LangOpts.CommentOpts.BlockCommandNames) {
342     if (Diags)
343       Diags->Report(diag::err_pch_langopt_value_mismatch)
344         << "block command names";
345     return true;
346   }
347 
348   // Sanitizer feature mismatches are treated as compatible differences. If
349   // compatible differences aren't allowed, we still only want to check for
350   // mismatches of non-modular sanitizers (the only ones which can affect AST
351   // generation).
352   if (!AllowCompatibleDifferences) {
353     SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
354     SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
355     SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
356     ExistingSanitizers.clear(ModularSanitizers);
357     ImportedSanitizers.clear(ModularSanitizers);
358     if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
359       const std::string Flag = "-fsanitize=";
360       if (Diags) {
361 #define SANITIZER(NAME, ID)                                                    \
362   {                                                                            \
363     bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID);         \
364     bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID);         \
365     if (InExistingModule != InImportedModule)                                  \
366       Diags->Report(diag::err_pch_targetopt_feature_mismatch)                  \
367           << InExistingModule << (Flag + NAME);                                \
368   }
369 #include "clang/Basic/Sanitizers.def"
370       }
371       return true;
372     }
373   }
374 
375   return false;
376 }
377 
378 /// Compare the given set of target options against an existing set of
379 /// target options.
380 ///
381 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
382 ///
383 /// \returns true if the target options mis-match, false otherwise.
384 static bool checkTargetOptions(const TargetOptions &TargetOpts,
385                                const TargetOptions &ExistingTargetOpts,
386                                DiagnosticsEngine *Diags,
387                                bool AllowCompatibleDifferences = true) {
388 #define CHECK_TARGET_OPT(Field, Name)                             \
389   if (TargetOpts.Field != ExistingTargetOpts.Field) {             \
390     if (Diags)                                                    \
391       Diags->Report(diag::err_pch_targetopt_mismatch)             \
392         << Name << TargetOpts.Field << ExistingTargetOpts.Field;  \
393     return true;                                                  \
394   }
395 
396   // The triple and ABI must match exactly.
397   CHECK_TARGET_OPT(Triple, "target");
398   CHECK_TARGET_OPT(ABI, "target ABI");
399 
400   // We can tolerate different CPUs in many cases, notably when one CPU
401   // supports a strict superset of another. When allowing compatible
402   // differences skip this check.
403   if (!AllowCompatibleDifferences) {
404     CHECK_TARGET_OPT(CPU, "target CPU");
405     CHECK_TARGET_OPT(TuneCPU, "tune CPU");
406   }
407 
408 #undef CHECK_TARGET_OPT
409 
410   // Compare feature sets.
411   SmallVector<StringRef, 4> ExistingFeatures(
412                                              ExistingTargetOpts.FeaturesAsWritten.begin(),
413                                              ExistingTargetOpts.FeaturesAsWritten.end());
414   SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
415                                          TargetOpts.FeaturesAsWritten.end());
416   llvm::sort(ExistingFeatures);
417   llvm::sort(ReadFeatures);
418 
419   // We compute the set difference in both directions explicitly so that we can
420   // diagnose the differences differently.
421   SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
422   std::set_difference(
423       ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
424       ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
425   std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
426                       ExistingFeatures.begin(), ExistingFeatures.end(),
427                       std::back_inserter(UnmatchedReadFeatures));
428 
429   // If we are allowing compatible differences and the read feature set is
430   // a strict subset of the existing feature set, there is nothing to diagnose.
431   if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
432     return false;
433 
434   if (Diags) {
435     for (StringRef Feature : UnmatchedReadFeatures)
436       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
437           << /* is-existing-feature */ false << Feature;
438     for (StringRef Feature : UnmatchedExistingFeatures)
439       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
440           << /* is-existing-feature */ true << Feature;
441   }
442 
443   return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
444 }
445 
446 bool
447 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
448                                   bool Complain,
449                                   bool AllowCompatibleDifferences) {
450   const LangOptions &ExistingLangOpts = PP.getLangOpts();
451   return checkLanguageOptions(LangOpts, ExistingLangOpts,
452                               Complain ? &Reader.Diags : nullptr,
453                               AllowCompatibleDifferences);
454 }
455 
456 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
457                                      bool Complain,
458                                      bool AllowCompatibleDifferences) {
459   const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
460   return checkTargetOptions(TargetOpts, ExistingTargetOpts,
461                             Complain ? &Reader.Diags : nullptr,
462                             AllowCompatibleDifferences);
463 }
464 
465 namespace {
466 
467 using MacroDefinitionsMap =
468     llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
469 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
470 
471 } // namespace
472 
473 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
474                                          DiagnosticsEngine &Diags,
475                                          bool Complain) {
476   using Level = DiagnosticsEngine::Level;
477 
478   // Check current mappings for new -Werror mappings, and the stored mappings
479   // for cases that were explicitly mapped to *not* be errors that are now
480   // errors because of options like -Werror.
481   DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
482 
483   for (DiagnosticsEngine *MappingSource : MappingSources) {
484     for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
485       diag::kind DiagID = DiagIDMappingPair.first;
486       Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
487       if (CurLevel < DiagnosticsEngine::Error)
488         continue; // not significant
489       Level StoredLevel =
490           StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
491       if (StoredLevel < DiagnosticsEngine::Error) {
492         if (Complain)
493           Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
494               Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
495         return true;
496       }
497     }
498   }
499 
500   return false;
501 }
502 
503 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
504   diag::Severity Ext = Diags.getExtensionHandlingBehavior();
505   if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
506     return true;
507   return Ext >= diag::Severity::Error;
508 }
509 
510 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
511                                     DiagnosticsEngine &Diags, bool IsSystem,
512                                     bool SystemHeaderWarningsInModule,
513                                     bool Complain) {
514   // Top-level options
515   if (IsSystem) {
516     if (Diags.getSuppressSystemWarnings())
517       return false;
518     // If -Wsystem-headers was not enabled before, and it was not explicit,
519     // be conservative
520     if (StoredDiags.getSuppressSystemWarnings() &&
521         !SystemHeaderWarningsInModule) {
522       if (Complain)
523         Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
524       return true;
525     }
526   }
527 
528   if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
529     if (Complain)
530       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
531     return true;
532   }
533 
534   if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
535       !StoredDiags.getEnableAllWarnings()) {
536     if (Complain)
537       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
538     return true;
539   }
540 
541   if (isExtHandlingFromDiagsError(Diags) &&
542       !isExtHandlingFromDiagsError(StoredDiags)) {
543     if (Complain)
544       Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
545     return true;
546   }
547 
548   return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
549 }
550 
551 /// Return the top import module if it is implicit, nullptr otherwise.
552 static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
553                                           Preprocessor &PP) {
554   // If the original import came from a file explicitly generated by the user,
555   // don't check the diagnostic mappings.
556   // FIXME: currently this is approximated by checking whether this is not a
557   // module import of an implicitly-loaded module file.
558   // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
559   // the transitive closure of its imports, since unrelated modules cannot be
560   // imported until after this module finishes validation.
561   ModuleFile *TopImport = &*ModuleMgr.rbegin();
562   while (!TopImport->ImportedBy.empty())
563     TopImport = TopImport->ImportedBy[0];
564   if (TopImport->Kind != MK_ImplicitModule)
565     return nullptr;
566 
567   StringRef ModuleName = TopImport->ModuleName;
568   assert(!ModuleName.empty() && "diagnostic options read before module name");
569 
570   Module *M =
571       PP.getHeaderSearchInfo().lookupModule(ModuleName, TopImport->ImportLoc);
572   assert(M && "missing module");
573   return M;
574 }
575 
576 bool PCHValidator::ReadDiagnosticOptions(
577     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
578   DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
579   IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
580   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
581       new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
582   // This should never fail, because we would have processed these options
583   // before writing them to an ASTFile.
584   ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
585 
586   ModuleManager &ModuleMgr = Reader.getModuleManager();
587   assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
588 
589   Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
590   if (!TopM)
591     return false;
592 
593   Module *Importer = PP.getCurrentModule();
594 
595   DiagnosticOptions &ExistingOpts = ExistingDiags.getDiagnosticOptions();
596   bool SystemHeaderWarningsInModule =
597       Importer && llvm::is_contained(ExistingOpts.SystemHeaderWarningsModules,
598                                      Importer->Name);
599 
600   // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
601   // contains the union of their flags.
602   return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
603                                  SystemHeaderWarningsInModule, Complain);
604 }
605 
606 /// Collect the macro definitions provided by the given preprocessor
607 /// options.
608 static void
609 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
610                         MacroDefinitionsMap &Macros,
611                         SmallVectorImpl<StringRef> *MacroNames = nullptr) {
612   for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
613     StringRef Macro = PPOpts.Macros[I].first;
614     bool IsUndef = PPOpts.Macros[I].second;
615 
616     std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
617     StringRef MacroName = MacroPair.first;
618     StringRef MacroBody = MacroPair.second;
619 
620     // For an #undef'd macro, we only care about the name.
621     if (IsUndef) {
622       if (MacroNames && !Macros.count(MacroName))
623         MacroNames->push_back(MacroName);
624 
625       Macros[MacroName] = std::make_pair("", true);
626       continue;
627     }
628 
629     // For a #define'd macro, figure out the actual definition.
630     if (MacroName.size() == Macro.size())
631       MacroBody = "1";
632     else {
633       // Note: GCC drops anything following an end-of-line character.
634       StringRef::size_type End = MacroBody.find_first_of("\n\r");
635       MacroBody = MacroBody.substr(0, End);
636     }
637 
638     if (MacroNames && !Macros.count(MacroName))
639       MacroNames->push_back(MacroName);
640     Macros[MacroName] = std::make_pair(MacroBody, false);
641   }
642 }
643 
644 enum OptionValidation {
645   OptionValidateNone,
646   OptionValidateContradictions,
647   OptionValidateStrictMatches,
648 };
649 
650 /// Check the preprocessor options deserialized from the control block
651 /// against the preprocessor options in an existing preprocessor.
652 ///
653 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
654 /// \param Validation If set to OptionValidateNone, ignore differences in
655 ///        preprocessor options. If set to OptionValidateContradictions,
656 ///        require that options passed both in the AST file and on the command
657 ///        line (-D or -U) match, but tolerate options missing in one or the
658 ///        other. If set to OptionValidateContradictions, require that there
659 ///        are no differences in the options between the two.
660 static bool checkPreprocessorOptions(
661     const PreprocessorOptions &PPOpts,
662     const PreprocessorOptions &ExistingPPOpts, bool ReadMacros,
663     DiagnosticsEngine *Diags, FileManager &FileMgr,
664     std::string &SuggestedPredefines, const LangOptions &LangOpts,
665     OptionValidation Validation = OptionValidateContradictions) {
666   if (ReadMacros) {
667     // Check macro definitions.
668     MacroDefinitionsMap ASTFileMacros;
669     collectMacroDefinitions(PPOpts, ASTFileMacros);
670     MacroDefinitionsMap ExistingMacros;
671     SmallVector<StringRef, 4> ExistingMacroNames;
672     collectMacroDefinitions(ExistingPPOpts, ExistingMacros,
673                             &ExistingMacroNames);
674 
675     // Use a line marker to enter the <command line> file, as the defines and
676     // undefines here will have come from the command line.
677     SuggestedPredefines += "# 1 \"<command line>\" 1\n";
678 
679     for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
680       // Dig out the macro definition in the existing preprocessor options.
681       StringRef MacroName = ExistingMacroNames[I];
682       std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
683 
684       // Check whether we know anything about this macro name or not.
685       llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
686           ASTFileMacros.find(MacroName);
687       if (Validation == OptionValidateNone || Known == ASTFileMacros.end()) {
688         if (Validation == OptionValidateStrictMatches) {
689           // If strict matches are requested, don't tolerate any extra defines
690           // on the command line that are missing in the AST file.
691           if (Diags) {
692             Diags->Report(diag::err_pch_macro_def_undef) << MacroName << true;
693           }
694           return true;
695         }
696         // FIXME: Check whether this identifier was referenced anywhere in the
697         // AST file. If so, we should reject the AST file. Unfortunately, this
698         // information isn't in the control block. What shall we do about it?
699 
700         if (Existing.second) {
701           SuggestedPredefines += "#undef ";
702           SuggestedPredefines += MacroName.str();
703           SuggestedPredefines += '\n';
704         } else {
705           SuggestedPredefines += "#define ";
706           SuggestedPredefines += MacroName.str();
707           SuggestedPredefines += ' ';
708           SuggestedPredefines += Existing.first.str();
709           SuggestedPredefines += '\n';
710         }
711         continue;
712       }
713 
714       // If the macro was defined in one but undef'd in the other, we have a
715       // conflict.
716       if (Existing.second != Known->second.second) {
717         if (Diags) {
718           Diags->Report(diag::err_pch_macro_def_undef)
719               << MacroName << Known->second.second;
720         }
721         return true;
722       }
723 
724       // If the macro was #undef'd in both, or if the macro bodies are
725       // identical, it's fine.
726       if (Existing.second || Existing.first == Known->second.first) {
727         ASTFileMacros.erase(Known);
728         continue;
729       }
730 
731       // The macro bodies differ; complain.
732       if (Diags) {
733         Diags->Report(diag::err_pch_macro_def_conflict)
734             << MacroName << Known->second.first << Existing.first;
735       }
736       return true;
737     }
738 
739     // Leave the <command line> file and return to <built-in>.
740     SuggestedPredefines += "# 1 \"<built-in>\" 2\n";
741 
742     if (Validation == OptionValidateStrictMatches) {
743       // If strict matches are requested, don't tolerate any extra defines in
744       // the AST file that are missing on the command line.
745       for (const auto &MacroName : ASTFileMacros.keys()) {
746         if (Diags) {
747           Diags->Report(diag::err_pch_macro_def_undef) << MacroName << false;
748         }
749         return true;
750       }
751     }
752   }
753 
754   // Check whether we're using predefines.
755   if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines &&
756       Validation != OptionValidateNone) {
757     if (Diags) {
758       Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
759     }
760     return true;
761   }
762 
763   // Detailed record is important since it is used for the module cache hash.
764   if (LangOpts.Modules &&
765       PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord &&
766       Validation != OptionValidateNone) {
767     if (Diags) {
768       Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
769     }
770     return true;
771   }
772 
773   // Compute the #include and #include_macros lines we need.
774   for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
775     StringRef File = ExistingPPOpts.Includes[I];
776 
777     if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
778         !ExistingPPOpts.PCHThroughHeader.empty()) {
779       // In case the through header is an include, we must add all the includes
780       // to the predefines so the start point can be determined.
781       SuggestedPredefines += "#include \"";
782       SuggestedPredefines += File;
783       SuggestedPredefines += "\"\n";
784       continue;
785     }
786 
787     if (File == ExistingPPOpts.ImplicitPCHInclude)
788       continue;
789 
790     if (llvm::is_contained(PPOpts.Includes, File))
791       continue;
792 
793     SuggestedPredefines += "#include \"";
794     SuggestedPredefines += File;
795     SuggestedPredefines += "\"\n";
796   }
797 
798   for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
799     StringRef File = ExistingPPOpts.MacroIncludes[I];
800     if (llvm::is_contained(PPOpts.MacroIncludes, File))
801       continue;
802 
803     SuggestedPredefines += "#__include_macros \"";
804     SuggestedPredefines += File;
805     SuggestedPredefines += "\"\n##\n";
806   }
807 
808   return false;
809 }
810 
811 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
812                                            bool ReadMacros, bool Complain,
813                                            std::string &SuggestedPredefines) {
814   const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
815 
816   return checkPreprocessorOptions(
817       PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags : nullptr,
818       PP.getFileManager(), SuggestedPredefines, PP.getLangOpts());
819 }
820 
821 bool SimpleASTReaderListener::ReadPreprocessorOptions(
822     const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain,
823     std::string &SuggestedPredefines) {
824   return checkPreprocessorOptions(PPOpts, PP.getPreprocessorOpts(), ReadMacros,
825                                   nullptr, PP.getFileManager(),
826                                   SuggestedPredefines, PP.getLangOpts(),
827                                   OptionValidateNone);
828 }
829 
830 /// Check the header search options deserialized from the control block
831 /// against the header search options in an existing preprocessor.
832 ///
833 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
834 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
835                                      StringRef SpecificModuleCachePath,
836                                      StringRef ExistingModuleCachePath,
837                                      DiagnosticsEngine *Diags,
838                                      const LangOptions &LangOpts,
839                                      const PreprocessorOptions &PPOpts) {
840   if (LangOpts.Modules) {
841     if (SpecificModuleCachePath != ExistingModuleCachePath &&
842         !PPOpts.AllowPCHWithDifferentModulesCachePath) {
843       if (Diags)
844         Diags->Report(diag::err_pch_modulecache_mismatch)
845           << SpecificModuleCachePath << ExistingModuleCachePath;
846       return true;
847     }
848   }
849 
850   return false;
851 }
852 
853 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
854                                            StringRef SpecificModuleCachePath,
855                                            bool Complain) {
856   return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
857                                   PP.getHeaderSearchInfo().getModuleCachePath(),
858                                   Complain ? &Reader.Diags : nullptr,
859                                   PP.getLangOpts(), PP.getPreprocessorOpts());
860 }
861 
862 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
863   PP.setCounterValue(Value);
864 }
865 
866 //===----------------------------------------------------------------------===//
867 // AST reader implementation
868 //===----------------------------------------------------------------------===//
869 
870 static uint64_t readULEB(const unsigned char *&P) {
871   unsigned Length = 0;
872   const char *Error = nullptr;
873 
874   uint64_t Val = llvm::decodeULEB128(P, &Length, nullptr, &Error);
875   if (Error)
876     llvm::report_fatal_error(Error);
877   P += Length;
878   return Val;
879 }
880 
881 /// Read ULEB-encoded key length and data length.
882 static std::pair<unsigned, unsigned>
883 readULEBKeyDataLength(const unsigned char *&P) {
884   unsigned KeyLen = readULEB(P);
885   if ((unsigned)KeyLen != KeyLen)
886     llvm::report_fatal_error("key too large");
887 
888   unsigned DataLen = readULEB(P);
889   if ((unsigned)DataLen != DataLen)
890     llvm::report_fatal_error("data too large");
891 
892   return std::make_pair(KeyLen, DataLen);
893 }
894 
895 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
896                                            bool TakeOwnership) {
897   DeserializationListener = Listener;
898   OwnsDeserializationListener = TakeOwnership;
899 }
900 
901 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
902   return serialization::ComputeHash(Sel);
903 }
904 
905 std::pair<unsigned, unsigned>
906 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
907   return readULEBKeyDataLength(d);
908 }
909 
910 ASTSelectorLookupTrait::internal_key_type
911 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
912   using namespace llvm::support;
913 
914   SelectorTable &SelTable = Reader.getContext().Selectors;
915   unsigned N =
916       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
917   IdentifierInfo *FirstII = Reader.getLocalIdentifier(
918       F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
919   if (N == 0)
920     return SelTable.getNullarySelector(FirstII);
921   else if (N == 1)
922     return SelTable.getUnarySelector(FirstII);
923 
924   SmallVector<IdentifierInfo *, 16> Args;
925   Args.push_back(FirstII);
926   for (unsigned I = 1; I != N; ++I)
927     Args.push_back(Reader.getLocalIdentifier(
928         F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
929 
930   return SelTable.getSelector(N, Args.data());
931 }
932 
933 ASTSelectorLookupTrait::data_type
934 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
935                                  unsigned DataLen) {
936   using namespace llvm::support;
937 
938   data_type Result;
939 
940   Result.ID = Reader.getGlobalSelectorID(
941       F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
942   unsigned FullInstanceBits =
943       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
944   unsigned FullFactoryBits =
945       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
946   Result.InstanceBits = FullInstanceBits & 0x3;
947   Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
948   Result.FactoryBits = FullFactoryBits & 0x3;
949   Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
950   unsigned NumInstanceMethods = FullInstanceBits >> 3;
951   unsigned NumFactoryMethods = FullFactoryBits >> 3;
952 
953   // Load instance methods
954   for (unsigned I = 0; I != NumInstanceMethods; ++I) {
955     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
956             F,
957             endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
958       Result.Instance.push_back(Method);
959   }
960 
961   // Load factory methods
962   for (unsigned I = 0; I != NumFactoryMethods; ++I) {
963     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
964             F,
965             endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
966       Result.Factory.push_back(Method);
967   }
968 
969   return Result;
970 }
971 
972 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
973   return llvm::djbHash(a);
974 }
975 
976 std::pair<unsigned, unsigned>
977 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
978   return readULEBKeyDataLength(d);
979 }
980 
981 ASTIdentifierLookupTraitBase::internal_key_type
982 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
983   assert(n >= 2 && d[n-1] == '\0');
984   return StringRef((const char*) d, n-1);
985 }
986 
987 /// Whether the given identifier is "interesting".
988 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
989                                     bool IsModule) {
990   return II.hadMacroDefinition() || II.isPoisoned() ||
991          (!IsModule && II.getObjCOrBuiltinID()) ||
992          II.hasRevertedTokenIDToIdentifier() ||
993          (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
994           II.getFETokenInfo());
995 }
996 
997 static bool readBit(unsigned &Bits) {
998   bool Value = Bits & 0x1;
999   Bits >>= 1;
1000   return Value;
1001 }
1002 
1003 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
1004   using namespace llvm::support;
1005 
1006   unsigned RawID =
1007       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1008   return Reader.getGlobalIdentifierID(F, RawID >> 1);
1009 }
1010 
1011 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
1012   if (!II.isFromAST()) {
1013     II.setIsFromAST();
1014     bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
1015     if (isInterestingIdentifier(Reader, II, IsModule))
1016       II.setChangedSinceDeserialization();
1017   }
1018 }
1019 
1020 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
1021                                                    const unsigned char* d,
1022                                                    unsigned DataLen) {
1023   using namespace llvm::support;
1024 
1025   unsigned RawID =
1026       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1027   bool IsInteresting = RawID & 0x01;
1028 
1029   // Wipe out the "is interesting" bit.
1030   RawID = RawID >> 1;
1031 
1032   // Build the IdentifierInfo and link the identifier ID with it.
1033   IdentifierInfo *II = KnownII;
1034   if (!II) {
1035     II = &Reader.getIdentifierTable().getOwn(k);
1036     KnownII = II;
1037   }
1038   markIdentifierFromAST(Reader, *II);
1039   Reader.markIdentifierUpToDate(II);
1040 
1041   IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
1042   if (!IsInteresting) {
1043     // For uninteresting identifiers, there's nothing else to do. Just notify
1044     // the reader that we've finished loading this identifier.
1045     Reader.SetIdentifierInfo(ID, II);
1046     return II;
1047   }
1048 
1049   unsigned ObjCOrBuiltinID =
1050       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
1051   unsigned Bits =
1052       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
1053   bool CPlusPlusOperatorKeyword = readBit(Bits);
1054   bool HasRevertedTokenIDToIdentifier = readBit(Bits);
1055   bool Poisoned = readBit(Bits);
1056   bool ExtensionToken = readBit(Bits);
1057   bool HadMacroDefinition = readBit(Bits);
1058 
1059   assert(Bits == 0 && "Extra bits in the identifier?");
1060   DataLen -= 8;
1061 
1062   // Set or check the various bits in the IdentifierInfo structure.
1063   // Token IDs are read-only.
1064   if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
1065     II->revertTokenIDToIdentifier();
1066   if (!F.isModule())
1067     II->setObjCOrBuiltinID(ObjCOrBuiltinID);
1068   assert(II->isExtensionToken() == ExtensionToken &&
1069          "Incorrect extension token flag");
1070   (void)ExtensionToken;
1071   if (Poisoned)
1072     II->setIsPoisoned(true);
1073   assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
1074          "Incorrect C++ operator keyword flag");
1075   (void)CPlusPlusOperatorKeyword;
1076 
1077   // If this identifier is a macro, deserialize the macro
1078   // definition.
1079   if (HadMacroDefinition) {
1080     uint32_t MacroDirectivesOffset =
1081         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1082     DataLen -= 4;
1083 
1084     Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1085   }
1086 
1087   Reader.SetIdentifierInfo(ID, II);
1088 
1089   // Read all of the declarations visible at global scope with this
1090   // name.
1091   if (DataLen > 0) {
1092     SmallVector<uint32_t, 4> DeclIDs;
1093     for (; DataLen > 0; DataLen -= 4)
1094       DeclIDs.push_back(Reader.getGlobalDeclID(
1095           F,
1096           endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
1097     Reader.SetGloballyVisibleDecls(II, DeclIDs);
1098   }
1099 
1100   return II;
1101 }
1102 
1103 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1104     : Kind(Name.getNameKind()) {
1105   switch (Kind) {
1106   case DeclarationName::Identifier:
1107     Data = (uint64_t)Name.getAsIdentifierInfo();
1108     break;
1109   case DeclarationName::ObjCZeroArgSelector:
1110   case DeclarationName::ObjCOneArgSelector:
1111   case DeclarationName::ObjCMultiArgSelector:
1112     Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1113     break;
1114   case DeclarationName::CXXOperatorName:
1115     Data = Name.getCXXOverloadedOperator();
1116     break;
1117   case DeclarationName::CXXLiteralOperatorName:
1118     Data = (uint64_t)Name.getCXXLiteralIdentifier();
1119     break;
1120   case DeclarationName::CXXDeductionGuideName:
1121     Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1122                ->getDeclName().getAsIdentifierInfo();
1123     break;
1124   case DeclarationName::CXXConstructorName:
1125   case DeclarationName::CXXDestructorName:
1126   case DeclarationName::CXXConversionFunctionName:
1127   case DeclarationName::CXXUsingDirective:
1128     Data = 0;
1129     break;
1130   }
1131 }
1132 
1133 unsigned DeclarationNameKey::getHash() const {
1134   llvm::FoldingSetNodeID ID;
1135   ID.AddInteger(Kind);
1136 
1137   switch (Kind) {
1138   case DeclarationName::Identifier:
1139   case DeclarationName::CXXLiteralOperatorName:
1140   case DeclarationName::CXXDeductionGuideName:
1141     ID.AddString(((IdentifierInfo*)Data)->getName());
1142     break;
1143   case DeclarationName::ObjCZeroArgSelector:
1144   case DeclarationName::ObjCOneArgSelector:
1145   case DeclarationName::ObjCMultiArgSelector:
1146     ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1147     break;
1148   case DeclarationName::CXXOperatorName:
1149     ID.AddInteger((OverloadedOperatorKind)Data);
1150     break;
1151   case DeclarationName::CXXConstructorName:
1152   case DeclarationName::CXXDestructorName:
1153   case DeclarationName::CXXConversionFunctionName:
1154   case DeclarationName::CXXUsingDirective:
1155     break;
1156   }
1157 
1158   return ID.ComputeHash();
1159 }
1160 
1161 ModuleFile *
1162 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1163   using namespace llvm::support;
1164 
1165   uint32_t ModuleFileID =
1166       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1167   return Reader.getLocalModuleFile(F, ModuleFileID);
1168 }
1169 
1170 std::pair<unsigned, unsigned>
1171 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1172   return readULEBKeyDataLength(d);
1173 }
1174 
1175 ASTDeclContextNameLookupTrait::internal_key_type
1176 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1177   using namespace llvm::support;
1178 
1179   auto Kind = (DeclarationName::NameKind)*d++;
1180   uint64_t Data;
1181   switch (Kind) {
1182   case DeclarationName::Identifier:
1183   case DeclarationName::CXXLiteralOperatorName:
1184   case DeclarationName::CXXDeductionGuideName:
1185     Data = (uint64_t)Reader.getLocalIdentifier(
1186         F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
1187     break;
1188   case DeclarationName::ObjCZeroArgSelector:
1189   case DeclarationName::ObjCOneArgSelector:
1190   case DeclarationName::ObjCMultiArgSelector:
1191     Data =
1192         (uint64_t)Reader
1193             .getLocalSelector(
1194                 F,
1195                 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
1196                     d))
1197             .getAsOpaquePtr();
1198     break;
1199   case DeclarationName::CXXOperatorName:
1200     Data = *d++; // OverloadedOperatorKind
1201     break;
1202   case DeclarationName::CXXConstructorName:
1203   case DeclarationName::CXXDestructorName:
1204   case DeclarationName::CXXConversionFunctionName:
1205   case DeclarationName::CXXUsingDirective:
1206     Data = 0;
1207     break;
1208   }
1209 
1210   return DeclarationNameKey(Kind, Data);
1211 }
1212 
1213 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1214                                                  const unsigned char *d,
1215                                                  unsigned DataLen,
1216                                                  data_type_builder &Val) {
1217   using namespace llvm::support;
1218 
1219   for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1220     uint32_t LocalID =
1221         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1222     Val.insert(Reader.getGlobalDeclID(F, LocalID));
1223   }
1224 }
1225 
1226 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1227                                               BitstreamCursor &Cursor,
1228                                               uint64_t Offset,
1229                                               DeclContext *DC) {
1230   assert(Offset != 0);
1231 
1232   SavedStreamPosition SavedPosition(Cursor);
1233   if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1234     Error(std::move(Err));
1235     return true;
1236   }
1237 
1238   RecordData Record;
1239   StringRef Blob;
1240   Expected<unsigned> MaybeCode = Cursor.ReadCode();
1241   if (!MaybeCode) {
1242     Error(MaybeCode.takeError());
1243     return true;
1244   }
1245   unsigned Code = MaybeCode.get();
1246 
1247   Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1248   if (!MaybeRecCode) {
1249     Error(MaybeRecCode.takeError());
1250     return true;
1251   }
1252   unsigned RecCode = MaybeRecCode.get();
1253   if (RecCode != DECL_CONTEXT_LEXICAL) {
1254     Error("Expected lexical block");
1255     return true;
1256   }
1257 
1258   assert(!isa<TranslationUnitDecl>(DC) &&
1259          "expected a TU_UPDATE_LEXICAL record for TU");
1260   // If we are handling a C++ class template instantiation, we can see multiple
1261   // lexical updates for the same record. It's important that we select only one
1262   // of them, so that field numbering works properly. Just pick the first one we
1263   // see.
1264   auto &Lex = LexicalDecls[DC];
1265   if (!Lex.first) {
1266     Lex = std::make_pair(
1267         &M, llvm::ArrayRef(
1268                 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1269                     Blob.data()),
1270                 Blob.size() / 4));
1271   }
1272   DC->setHasExternalLexicalStorage(true);
1273   return false;
1274 }
1275 
1276 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1277                                               BitstreamCursor &Cursor,
1278                                               uint64_t Offset,
1279                                               DeclID ID) {
1280   assert(Offset != 0);
1281 
1282   SavedStreamPosition SavedPosition(Cursor);
1283   if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1284     Error(std::move(Err));
1285     return true;
1286   }
1287 
1288   RecordData Record;
1289   StringRef Blob;
1290   Expected<unsigned> MaybeCode = Cursor.ReadCode();
1291   if (!MaybeCode) {
1292     Error(MaybeCode.takeError());
1293     return true;
1294   }
1295   unsigned Code = MaybeCode.get();
1296 
1297   Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1298   if (!MaybeRecCode) {
1299     Error(MaybeRecCode.takeError());
1300     return true;
1301   }
1302   unsigned RecCode = MaybeRecCode.get();
1303   if (RecCode != DECL_CONTEXT_VISIBLE) {
1304     Error("Expected visible lookup table block");
1305     return true;
1306   }
1307 
1308   // We can't safely determine the primary context yet, so delay attaching the
1309   // lookup table until we're done with recursive deserialization.
1310   auto *Data = (const unsigned char*)Blob.data();
1311   PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1312   return false;
1313 }
1314 
1315 void ASTReader::Error(StringRef Msg) const {
1316   Error(diag::err_fe_pch_malformed, Msg);
1317   if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1318       !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1319     Diag(diag::note_module_cache_path)
1320       << PP.getHeaderSearchInfo().getModuleCachePath();
1321   }
1322 }
1323 
1324 void ASTReader::Error(unsigned DiagID, StringRef Arg1, StringRef Arg2,
1325                       StringRef Arg3) const {
1326   if (Diags.isDiagnosticInFlight())
1327     Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1328   else
1329     Diag(DiagID) << Arg1 << Arg2 << Arg3;
1330 }
1331 
1332 void ASTReader::Error(llvm::Error &&Err) const {
1333   llvm::Error RemainingErr =
1334       handleErrors(std::move(Err), [this](const DiagnosticError &E) {
1335         auto Diag = E.getDiagnostic().second;
1336 
1337         // Ideally we'd just emit it, but have to handle a possible in-flight
1338         // diagnostic. Note that the location is currently ignored as well.
1339         auto NumArgs = Diag.getStorage()->NumDiagArgs;
1340         assert(NumArgs <= 3 && "Can only have up to 3 arguments");
1341         StringRef Arg1, Arg2, Arg3;
1342         switch (NumArgs) {
1343         case 3:
1344           Arg3 = Diag.getStringArg(2);
1345           [[fallthrough]];
1346         case 2:
1347           Arg2 = Diag.getStringArg(1);
1348           [[fallthrough]];
1349         case 1:
1350           Arg1 = Diag.getStringArg(0);
1351         }
1352         Error(Diag.getDiagID(), Arg1, Arg2, Arg3);
1353       });
1354   if (RemainingErr)
1355     Error(toString(std::move(RemainingErr)));
1356 }
1357 
1358 //===----------------------------------------------------------------------===//
1359 // Source Manager Deserialization
1360 //===----------------------------------------------------------------------===//
1361 
1362 /// Read the line table in the source manager block.
1363 void ASTReader::ParseLineTable(ModuleFile &F, const RecordData &Record) {
1364   unsigned Idx = 0;
1365   LineTableInfo &LineTable = SourceMgr.getLineTable();
1366 
1367   // Parse the file names
1368   std::map<int, int> FileIDs;
1369   FileIDs[-1] = -1; // For unspecified filenames.
1370   for (unsigned I = 0; Record[Idx]; ++I) {
1371     // Extract the file name
1372     auto Filename = ReadPath(F, Record, Idx);
1373     FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1374   }
1375   ++Idx;
1376 
1377   // Parse the line entries
1378   std::vector<LineEntry> Entries;
1379   while (Idx < Record.size()) {
1380     FileID FID = ReadFileID(F, Record, Idx);
1381 
1382     // Extract the line entries
1383     unsigned NumEntries = Record[Idx++];
1384     assert(NumEntries && "no line entries for file ID");
1385     Entries.clear();
1386     Entries.reserve(NumEntries);
1387     for (unsigned I = 0; I != NumEntries; ++I) {
1388       unsigned FileOffset = Record[Idx++];
1389       unsigned LineNo = Record[Idx++];
1390       int FilenameID = FileIDs[Record[Idx++]];
1391       SrcMgr::CharacteristicKind FileKind
1392         = (SrcMgr::CharacteristicKind)Record[Idx++];
1393       unsigned IncludeOffset = Record[Idx++];
1394       Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1395                                        FileKind, IncludeOffset));
1396     }
1397     LineTable.AddEntry(FID, Entries);
1398   }
1399 }
1400 
1401 /// Read a source manager block
1402 llvm::Error ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1403   using namespace SrcMgr;
1404 
1405   BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1406 
1407   // Set the source-location entry cursor to the current position in
1408   // the stream. This cursor will be used to read the contents of the
1409   // source manager block initially, and then lazily read
1410   // source-location entries as needed.
1411   SLocEntryCursor = F.Stream;
1412 
1413   // The stream itself is going to skip over the source manager block.
1414   if (llvm::Error Err = F.Stream.SkipBlock())
1415     return Err;
1416 
1417   // Enter the source manager block.
1418   if (llvm::Error Err = SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID))
1419     return Err;
1420   F.SourceManagerBlockStartOffset = SLocEntryCursor.GetCurrentBitNo();
1421 
1422   RecordData Record;
1423   while (true) {
1424     Expected<llvm::BitstreamEntry> MaybeE =
1425         SLocEntryCursor.advanceSkippingSubblocks();
1426     if (!MaybeE)
1427       return MaybeE.takeError();
1428     llvm::BitstreamEntry E = MaybeE.get();
1429 
1430     switch (E.Kind) {
1431     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1432     case llvm::BitstreamEntry::Error:
1433       return llvm::createStringError(std::errc::illegal_byte_sequence,
1434                                      "malformed block record in AST file");
1435     case llvm::BitstreamEntry::EndBlock:
1436       return llvm::Error::success();
1437     case llvm::BitstreamEntry::Record:
1438       // The interesting case.
1439       break;
1440     }
1441 
1442     // Read a record.
1443     Record.clear();
1444     StringRef Blob;
1445     Expected<unsigned> MaybeRecord =
1446         SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1447     if (!MaybeRecord)
1448       return MaybeRecord.takeError();
1449     switch (MaybeRecord.get()) {
1450     default:  // Default behavior: ignore.
1451       break;
1452 
1453     case SM_SLOC_FILE_ENTRY:
1454     case SM_SLOC_BUFFER_ENTRY:
1455     case SM_SLOC_EXPANSION_ENTRY:
1456       // Once we hit one of the source location entries, we're done.
1457       return llvm::Error::success();
1458     }
1459   }
1460 }
1461 
1462 llvm::Expected<SourceLocation::UIntTy>
1463 ASTReader::readSLocOffset(ModuleFile *F, unsigned Index) {
1464   BitstreamCursor &Cursor = F->SLocEntryCursor;
1465   SavedStreamPosition SavedPosition(Cursor);
1466   if (llvm::Error Err = Cursor.JumpToBit(F->SLocEntryOffsetsBase +
1467                                          F->SLocEntryOffsets[Index]))
1468     return std::move(Err);
1469 
1470   Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
1471   if (!MaybeEntry)
1472     return MaybeEntry.takeError();
1473 
1474   llvm::BitstreamEntry Entry = MaybeEntry.get();
1475   if (Entry.Kind != llvm::BitstreamEntry::Record)
1476     return llvm::createStringError(
1477         std::errc::illegal_byte_sequence,
1478         "incorrectly-formatted source location entry in AST file");
1479 
1480   RecordData Record;
1481   StringRef Blob;
1482   Expected<unsigned> MaybeSLOC = Cursor.readRecord(Entry.ID, Record, &Blob);
1483   if (!MaybeSLOC)
1484     return MaybeSLOC.takeError();
1485 
1486   switch (MaybeSLOC.get()) {
1487   default:
1488     return llvm::createStringError(
1489         std::errc::illegal_byte_sequence,
1490         "incorrectly-formatted source location entry in AST file");
1491   case SM_SLOC_FILE_ENTRY:
1492   case SM_SLOC_BUFFER_ENTRY:
1493   case SM_SLOC_EXPANSION_ENTRY:
1494     return F->SLocEntryBaseOffset + Record[0];
1495   }
1496 }
1497 
1498 int ASTReader::getSLocEntryID(SourceLocation::UIntTy SLocOffset) {
1499   auto SLocMapI =
1500       GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - SLocOffset - 1);
1501   assert(SLocMapI != GlobalSLocOffsetMap.end() &&
1502          "Corrupted global sloc offset map");
1503   ModuleFile *F = SLocMapI->second;
1504 
1505   bool Invalid = false;
1506 
1507   auto It = llvm::upper_bound(
1508       llvm::index_range(0, F->LocalNumSLocEntries), SLocOffset,
1509       [&](SourceLocation::UIntTy Offset, std::size_t LocalIndex) {
1510         int ID = F->SLocEntryBaseID + LocalIndex;
1511         std::size_t Index = -ID - 2;
1512         if (!SourceMgr.SLocEntryOffsetLoaded[Index]) {
1513           assert(!SourceMgr.SLocEntryLoaded[Index]);
1514           auto MaybeEntryOffset = readSLocOffset(F, LocalIndex);
1515           if (!MaybeEntryOffset) {
1516             Error(MaybeEntryOffset.takeError());
1517             Invalid = true;
1518             return true;
1519           }
1520           SourceMgr.LoadedSLocEntryTable[Index] =
1521               SrcMgr::SLocEntry::getOffsetOnly(*MaybeEntryOffset);
1522           SourceMgr.SLocEntryOffsetLoaded[Index] = true;
1523         }
1524         return Offset < SourceMgr.LoadedSLocEntryTable[Index].getOffset();
1525       });
1526 
1527   if (Invalid)
1528     return 0;
1529 
1530   // The iterator points to the first entry with start offset greater than the
1531   // offset of interest. The previous entry must contain the offset of interest.
1532   return F->SLocEntryBaseID + *std::prev(It);
1533 }
1534 
1535 bool ASTReader::ReadSLocEntry(int ID) {
1536   if (ID == 0)
1537     return false;
1538 
1539   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1540     Error("source location entry ID out-of-range for AST file");
1541     return true;
1542   }
1543 
1544   // Local helper to read the (possibly-compressed) buffer data following the
1545   // entry record.
1546   auto ReadBuffer = [this](
1547       BitstreamCursor &SLocEntryCursor,
1548       StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1549     RecordData Record;
1550     StringRef Blob;
1551     Expected<unsigned> MaybeCode = SLocEntryCursor.ReadCode();
1552     if (!MaybeCode) {
1553       Error(MaybeCode.takeError());
1554       return nullptr;
1555     }
1556     unsigned Code = MaybeCode.get();
1557 
1558     Expected<unsigned> MaybeRecCode =
1559         SLocEntryCursor.readRecord(Code, Record, &Blob);
1560     if (!MaybeRecCode) {
1561       Error(MaybeRecCode.takeError());
1562       return nullptr;
1563     }
1564     unsigned RecCode = MaybeRecCode.get();
1565 
1566     if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1567       // Inspect the first byte to differentiate zlib (\x78) and zstd
1568       // (little-endian 0xFD2FB528).
1569       const llvm::compression::Format F =
1570           Blob.size() > 0 && Blob.data()[0] == 0x78
1571               ? llvm::compression::Format::Zlib
1572               : llvm::compression::Format::Zstd;
1573       if (const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1574         Error(Reason);
1575         return nullptr;
1576       }
1577       SmallVector<uint8_t, 0> Decompressed;
1578       if (llvm::Error E = llvm::compression::decompress(
1579               F, llvm::arrayRefFromStringRef(Blob), Decompressed, Record[0])) {
1580         Error("could not decompress embedded file contents: " +
1581               llvm::toString(std::move(E)));
1582         return nullptr;
1583       }
1584       return llvm::MemoryBuffer::getMemBufferCopy(
1585           llvm::toStringRef(Decompressed), Name);
1586     } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1587       return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1588     } else {
1589       Error("AST record has invalid code");
1590       return nullptr;
1591     }
1592   };
1593 
1594   ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1595   if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
1596           F->SLocEntryOffsetsBase +
1597           F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
1598     Error(std::move(Err));
1599     return true;
1600   }
1601 
1602   BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1603   SourceLocation::UIntTy BaseOffset = F->SLocEntryBaseOffset;
1604 
1605   ++NumSLocEntriesRead;
1606   Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
1607   if (!MaybeEntry) {
1608     Error(MaybeEntry.takeError());
1609     return true;
1610   }
1611   llvm::BitstreamEntry Entry = MaybeEntry.get();
1612 
1613   if (Entry.Kind != llvm::BitstreamEntry::Record) {
1614     Error("incorrectly-formatted source location entry in AST file");
1615     return true;
1616   }
1617 
1618   RecordData Record;
1619   StringRef Blob;
1620   Expected<unsigned> MaybeSLOC =
1621       SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1622   if (!MaybeSLOC) {
1623     Error(MaybeSLOC.takeError());
1624     return true;
1625   }
1626   switch (MaybeSLOC.get()) {
1627   default:
1628     Error("incorrectly-formatted source location entry in AST file");
1629     return true;
1630 
1631   case SM_SLOC_FILE_ENTRY: {
1632     // We will detect whether a file changed and return 'Failure' for it, but
1633     // we will also try to fail gracefully by setting up the SLocEntry.
1634     unsigned InputID = Record[4];
1635     InputFile IF = getInputFile(*F, InputID);
1636     OptionalFileEntryRef File = IF.getFile();
1637     bool OverriddenBuffer = IF.isOverridden();
1638 
1639     // Note that we only check if a File was returned. If it was out-of-date
1640     // we have complained but we will continue creating a FileID to recover
1641     // gracefully.
1642     if (!File)
1643       return true;
1644 
1645     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1646     if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1647       // This is the module's main file.
1648       IncludeLoc = getImportLocation(F);
1649     }
1650     SrcMgr::CharacteristicKind
1651       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1652     FileID FID = SourceMgr.createFileID(*File, IncludeLoc, FileCharacter, ID,
1653                                         BaseOffset + Record[0]);
1654     SrcMgr::FileInfo &FileInfo =
1655           const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1656     FileInfo.NumCreatedFIDs = Record[5];
1657     if (Record[3])
1658       FileInfo.setHasLineDirectives();
1659 
1660     unsigned NumFileDecls = Record[7];
1661     if (NumFileDecls && ContextObj) {
1662       const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1663       assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1664       FileDeclIDs[FID] =
1665           FileDeclsInfo(F, llvm::ArrayRef(FirstDecl, NumFileDecls));
1666     }
1667 
1668     const SrcMgr::ContentCache &ContentCache =
1669         SourceMgr.getOrCreateContentCache(*File, isSystem(FileCharacter));
1670     if (OverriddenBuffer && !ContentCache.BufferOverridden &&
1671         ContentCache.ContentsEntry == ContentCache.OrigEntry &&
1672         !ContentCache.getBufferIfLoaded()) {
1673       auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1674       if (!Buffer)
1675         return true;
1676       SourceMgr.overrideFileContents(*File, std::move(Buffer));
1677     }
1678 
1679     break;
1680   }
1681 
1682   case SM_SLOC_BUFFER_ENTRY: {
1683     const char *Name = Blob.data();
1684     unsigned Offset = Record[0];
1685     SrcMgr::CharacteristicKind
1686       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1687     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1688     if (IncludeLoc.isInvalid() && F->isModule()) {
1689       IncludeLoc = getImportLocation(F);
1690     }
1691 
1692     auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1693     if (!Buffer)
1694       return true;
1695     FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1696                                         BaseOffset + Offset, IncludeLoc);
1697     if (Record[3]) {
1698       auto &FileInfo =
1699           const_cast<SrcMgr::FileInfo &>(SourceMgr.getSLocEntry(FID).getFile());
1700       FileInfo.setHasLineDirectives();
1701     }
1702     break;
1703   }
1704 
1705   case SM_SLOC_EXPANSION_ENTRY: {
1706     LocSeq::State Seq;
1707     SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1], Seq);
1708     SourceLocation ExpansionBegin = ReadSourceLocation(*F, Record[2], Seq);
1709     SourceLocation ExpansionEnd = ReadSourceLocation(*F, Record[3], Seq);
1710     SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1711                                  Record[5], Record[4], ID,
1712                                  BaseOffset + Record[0]);
1713     break;
1714   }
1715   }
1716 
1717   return false;
1718 }
1719 
1720 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1721   if (ID == 0)
1722     return std::make_pair(SourceLocation(), "");
1723 
1724   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1725     Error("source location entry ID out-of-range for AST file");
1726     return std::make_pair(SourceLocation(), "");
1727   }
1728 
1729   // Find which module file this entry lands in.
1730   ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1731   if (!M->isModule())
1732     return std::make_pair(SourceLocation(), "");
1733 
1734   // FIXME: Can we map this down to a particular submodule? That would be
1735   // ideal.
1736   return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1737 }
1738 
1739 /// Find the location where the module F is imported.
1740 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1741   if (F->ImportLoc.isValid())
1742     return F->ImportLoc;
1743 
1744   // Otherwise we have a PCH. It's considered to be "imported" at the first
1745   // location of its includer.
1746   if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1747     // Main file is the importer.
1748     assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1749     return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1750   }
1751   return F->ImportedBy[0]->FirstLoc;
1752 }
1753 
1754 /// Enter a subblock of the specified BlockID with the specified cursor. Read
1755 /// the abbreviations that are at the top of the block and then leave the cursor
1756 /// pointing into the block.
1757 llvm::Error ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor,
1758                                         unsigned BlockID,
1759                                         uint64_t *StartOfBlockOffset) {
1760   if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1761     return Err;
1762 
1763   if (StartOfBlockOffset)
1764     *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1765 
1766   while (true) {
1767     uint64_t Offset = Cursor.GetCurrentBitNo();
1768     Expected<unsigned> MaybeCode = Cursor.ReadCode();
1769     if (!MaybeCode)
1770       return MaybeCode.takeError();
1771     unsigned Code = MaybeCode.get();
1772 
1773     // We expect all abbrevs to be at the start of the block.
1774     if (Code != llvm::bitc::DEFINE_ABBREV) {
1775       if (llvm::Error Err = Cursor.JumpToBit(Offset))
1776         return Err;
1777       return llvm::Error::success();
1778     }
1779     if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1780       return Err;
1781   }
1782 }
1783 
1784 Token ASTReader::ReadToken(ModuleFile &M, const RecordDataImpl &Record,
1785                            unsigned &Idx) {
1786   Token Tok;
1787   Tok.startToken();
1788   Tok.setLocation(ReadSourceLocation(M, Record, Idx));
1789   Tok.setKind((tok::TokenKind)Record[Idx++]);
1790   Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1791 
1792   if (Tok.isAnnotation()) {
1793     Tok.setAnnotationEndLoc(ReadSourceLocation(M, Record, Idx));
1794     switch (Tok.getKind()) {
1795     case tok::annot_pragma_loop_hint: {
1796       auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
1797       Info->PragmaName = ReadToken(M, Record, Idx);
1798       Info->Option = ReadToken(M, Record, Idx);
1799       unsigned NumTokens = Record[Idx++];
1800       SmallVector<Token, 4> Toks;
1801       Toks.reserve(NumTokens);
1802       for (unsigned I = 0; I < NumTokens; ++I)
1803         Toks.push_back(ReadToken(M, Record, Idx));
1804       Info->Toks = llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1805       Tok.setAnnotationValue(static_cast<void *>(Info));
1806       break;
1807     }
1808     case tok::annot_pragma_pack: {
1809       auto *Info = new (PP.getPreprocessorAllocator()) Sema::PragmaPackInfo;
1810       Info->Action = static_cast<Sema::PragmaMsStackAction>(Record[Idx++]);
1811       auto SlotLabel = ReadString(Record, Idx);
1812       Info->SlotLabel =
1813           llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1814       Info->Alignment = ReadToken(M, Record, Idx);
1815       Tok.setAnnotationValue(static_cast<void *>(Info));
1816       break;
1817     }
1818     // Some annotation tokens do not use the PtrData field.
1819     case tok::annot_pragma_openmp:
1820     case tok::annot_pragma_openmp_end:
1821     case tok::annot_pragma_unused:
1822     case tok::annot_pragma_openacc:
1823     case tok::annot_pragma_openacc_end:
1824       break;
1825     default:
1826       llvm_unreachable("missing deserialization code for annotation token");
1827     }
1828   } else {
1829     Tok.setLength(Record[Idx++]);
1830     if (IdentifierInfo *II = getLocalIdentifier(M, Record[Idx++]))
1831       Tok.setIdentifierInfo(II);
1832   }
1833   return Tok;
1834 }
1835 
1836 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1837   BitstreamCursor &Stream = F.MacroCursor;
1838 
1839   // Keep track of where we are in the stream, then jump back there
1840   // after reading this macro.
1841   SavedStreamPosition SavedPosition(Stream);
1842 
1843   if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1844     // FIXME this drops errors on the floor.
1845     consumeError(std::move(Err));
1846     return nullptr;
1847   }
1848   RecordData Record;
1849   SmallVector<IdentifierInfo*, 16> MacroParams;
1850   MacroInfo *Macro = nullptr;
1851   llvm::MutableArrayRef<Token> MacroTokens;
1852 
1853   while (true) {
1854     // Advance to the next record, but if we get to the end of the block, don't
1855     // pop it (removing all the abbreviations from the cursor) since we want to
1856     // be able to reseek within the block and read entries.
1857     unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1858     Expected<llvm::BitstreamEntry> MaybeEntry =
1859         Stream.advanceSkippingSubblocks(Flags);
1860     if (!MaybeEntry) {
1861       Error(MaybeEntry.takeError());
1862       return Macro;
1863     }
1864     llvm::BitstreamEntry Entry = MaybeEntry.get();
1865 
1866     switch (Entry.Kind) {
1867     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1868     case llvm::BitstreamEntry::Error:
1869       Error("malformed block record in AST file");
1870       return Macro;
1871     case llvm::BitstreamEntry::EndBlock:
1872       return Macro;
1873     case llvm::BitstreamEntry::Record:
1874       // The interesting case.
1875       break;
1876     }
1877 
1878     // Read a record.
1879     Record.clear();
1880     PreprocessorRecordTypes RecType;
1881     if (Expected<unsigned> MaybeRecType = Stream.readRecord(Entry.ID, Record))
1882       RecType = (PreprocessorRecordTypes)MaybeRecType.get();
1883     else {
1884       Error(MaybeRecType.takeError());
1885       return Macro;
1886     }
1887     switch (RecType) {
1888     case PP_MODULE_MACRO:
1889     case PP_MACRO_DIRECTIVE_HISTORY:
1890       return Macro;
1891 
1892     case PP_MACRO_OBJECT_LIKE:
1893     case PP_MACRO_FUNCTION_LIKE: {
1894       // If we already have a macro, that means that we've hit the end
1895       // of the definition of the macro we were looking for. We're
1896       // done.
1897       if (Macro)
1898         return Macro;
1899 
1900       unsigned NextIndex = 1; // Skip identifier ID.
1901       SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1902       MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1903       MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1904       MI->setIsUsed(Record[NextIndex++]);
1905       MI->setUsedForHeaderGuard(Record[NextIndex++]);
1906       MacroTokens = MI->allocateTokens(Record[NextIndex++],
1907                                        PP.getPreprocessorAllocator());
1908       if (RecType == PP_MACRO_FUNCTION_LIKE) {
1909         // Decode function-like macro info.
1910         bool isC99VarArgs = Record[NextIndex++];
1911         bool isGNUVarArgs = Record[NextIndex++];
1912         bool hasCommaPasting = Record[NextIndex++];
1913         MacroParams.clear();
1914         unsigned NumArgs = Record[NextIndex++];
1915         for (unsigned i = 0; i != NumArgs; ++i)
1916           MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1917 
1918         // Install function-like macro info.
1919         MI->setIsFunctionLike();
1920         if (isC99VarArgs) MI->setIsC99Varargs();
1921         if (isGNUVarArgs) MI->setIsGNUVarargs();
1922         if (hasCommaPasting) MI->setHasCommaPasting();
1923         MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1924       }
1925 
1926       // Remember that we saw this macro last so that we add the tokens that
1927       // form its body to it.
1928       Macro = MI;
1929 
1930       if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1931           Record[NextIndex]) {
1932         // We have a macro definition. Register the association
1933         PreprocessedEntityID
1934             GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1935         PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1936         PreprocessingRecord::PPEntityID PPID =
1937             PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1938         MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1939             PPRec.getPreprocessedEntity(PPID));
1940         if (PPDef)
1941           PPRec.RegisterMacroDefinition(Macro, PPDef);
1942       }
1943 
1944       ++NumMacrosRead;
1945       break;
1946     }
1947 
1948     case PP_TOKEN: {
1949       // If we see a TOKEN before a PP_MACRO_*, then the file is
1950       // erroneous, just pretend we didn't see this.
1951       if (!Macro) break;
1952       if (MacroTokens.empty()) {
1953         Error("unexpected number of macro tokens for a macro in AST file");
1954         return Macro;
1955       }
1956 
1957       unsigned Idx = 0;
1958       MacroTokens[0] = ReadToken(F, Record, Idx);
1959       MacroTokens = MacroTokens.drop_front();
1960       break;
1961     }
1962     }
1963   }
1964 }
1965 
1966 PreprocessedEntityID
1967 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1968                                          unsigned LocalID) const {
1969   if (!M.ModuleOffsetMap.empty())
1970     ReadModuleOffsetMap(M);
1971 
1972   ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1973     I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1974   assert(I != M.PreprocessedEntityRemap.end()
1975          && "Invalid index into preprocessed entity index remap");
1976 
1977   return LocalID + I->second;
1978 }
1979 
1980 const FileEntry *HeaderFileInfoTrait::getFile(const internal_key_type &Key) {
1981   FileManager &FileMgr = Reader.getFileManager();
1982   if (!Key.Imported) {
1983     if (auto File = FileMgr.getFile(Key.Filename))
1984       return *File;
1985     return nullptr;
1986   }
1987 
1988   std::string Resolved = std::string(Key.Filename);
1989   Reader.ResolveImportedPath(M, Resolved);
1990   if (auto File = FileMgr.getFile(Resolved))
1991     return *File;
1992   return nullptr;
1993 }
1994 
1995 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1996   return llvm::hash_combine(ikey.Size, ikey.ModTime);
1997 }
1998 
1999 HeaderFileInfoTrait::internal_key_type
2000 HeaderFileInfoTrait::GetInternalKey(external_key_type ekey) {
2001   internal_key_type ikey = {ekey.getSize(),
2002                             M.HasTimestamps ? ekey.getModificationTime() : 0,
2003                             ekey.getName(), /*Imported*/ false};
2004   return ikey;
2005 }
2006 
2007 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
2008   if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
2009     return false;
2010 
2011   if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
2012     return true;
2013 
2014   // Determine whether the actual files are equivalent.
2015   const FileEntry *FEA = getFile(a);
2016   const FileEntry *FEB = getFile(b);
2017   return FEA && FEA == FEB;
2018 }
2019 
2020 std::pair<unsigned, unsigned>
2021 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
2022   return readULEBKeyDataLength(d);
2023 }
2024 
2025 HeaderFileInfoTrait::internal_key_type
2026 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
2027   using namespace llvm::support;
2028 
2029   internal_key_type ikey;
2030   ikey.Size =
2031       off_t(endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
2032   ikey.ModTime = time_t(
2033       endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
2034   ikey.Filename = (const char *)d;
2035   ikey.Imported = true;
2036   return ikey;
2037 }
2038 
2039 HeaderFileInfoTrait::data_type
2040 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
2041                               unsigned DataLen) {
2042   using namespace llvm::support;
2043 
2044   const unsigned char *End = d + DataLen;
2045   HeaderFileInfo HFI;
2046   unsigned Flags = *d++;
2047 
2048   bool Included = (Flags >> 6) & 0x01;
2049   if (Included)
2050     if (const FileEntry *FE = getFile(key))
2051       // Not using \c Preprocessor::markIncluded(), since that would attempt to
2052       // deserialize this header file info again.
2053       Reader.getPreprocessor().getIncludedFiles().insert(FE);
2054 
2055   // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
2056   HFI.isImport |= (Flags >> 5) & 0x01;
2057   HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
2058   HFI.DirInfo = (Flags >> 1) & 0x07;
2059   HFI.IndexHeaderMapHeader = Flags & 0x01;
2060   HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
2061       M, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
2062   if (unsigned FrameworkOffset =
2063           endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)) {
2064     // The framework offset is 1 greater than the actual offset,
2065     // since 0 is used as an indicator for "no framework name".
2066     StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
2067     HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
2068   }
2069 
2070   assert((End - d) % 4 == 0 &&
2071          "Wrong data length in HeaderFileInfo deserialization");
2072   while (d != End) {
2073     uint32_t LocalSMID =
2074         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
2075     auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 7);
2076     LocalSMID >>= 3;
2077 
2078     // This header is part of a module. Associate it with the module to enable
2079     // implicit module import.
2080     SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
2081     Module *Mod = Reader.getSubmodule(GlobalSMID);
2082     FileManager &FileMgr = Reader.getFileManager();
2083     ModuleMap &ModMap =
2084         Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
2085 
2086     std::string Filename = std::string(key.Filename);
2087     if (key.Imported)
2088       Reader.ResolveImportedPath(M, Filename);
2089     if (auto FE = FileMgr.getOptionalFileRef(Filename)) {
2090       // FIXME: NameAsWritten
2091       Module::Header H = {std::string(key.Filename), "", *FE};
2092       ModMap.addHeader(Mod, H, HeaderRole, /*Imported=*/true);
2093     }
2094     HFI.isModuleHeader |= ModuleMap::isModular(HeaderRole);
2095   }
2096 
2097   // This HeaderFileInfo was externally loaded.
2098   HFI.External = true;
2099   HFI.IsValid = true;
2100   return HFI;
2101 }
2102 
2103 void ASTReader::addPendingMacro(IdentifierInfo *II, ModuleFile *M,
2104                                 uint32_t MacroDirectivesOffset) {
2105   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
2106   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2107 }
2108 
2109 void ASTReader::ReadDefinedMacros() {
2110   // Note that we are loading defined macros.
2111   Deserializing Macros(this);
2112 
2113   for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
2114     BitstreamCursor &MacroCursor = I.MacroCursor;
2115 
2116     // If there was no preprocessor block, skip this file.
2117     if (MacroCursor.getBitcodeBytes().empty())
2118       continue;
2119 
2120     BitstreamCursor Cursor = MacroCursor;
2121     if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2122       Error(std::move(Err));
2123       return;
2124     }
2125 
2126     RecordData Record;
2127     while (true) {
2128       Expected<llvm::BitstreamEntry> MaybeE = Cursor.advanceSkippingSubblocks();
2129       if (!MaybeE) {
2130         Error(MaybeE.takeError());
2131         return;
2132       }
2133       llvm::BitstreamEntry E = MaybeE.get();
2134 
2135       switch (E.Kind) {
2136       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2137       case llvm::BitstreamEntry::Error:
2138         Error("malformed block record in AST file");
2139         return;
2140       case llvm::BitstreamEntry::EndBlock:
2141         goto NextCursor;
2142 
2143       case llvm::BitstreamEntry::Record: {
2144         Record.clear();
2145         Expected<unsigned> MaybeRecord = Cursor.readRecord(E.ID, Record);
2146         if (!MaybeRecord) {
2147           Error(MaybeRecord.takeError());
2148           return;
2149         }
2150         switch (MaybeRecord.get()) {
2151         default:  // Default behavior: ignore.
2152           break;
2153 
2154         case PP_MACRO_OBJECT_LIKE:
2155         case PP_MACRO_FUNCTION_LIKE: {
2156           IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
2157           if (II->isOutOfDate())
2158             updateOutOfDateIdentifier(*II);
2159           break;
2160         }
2161 
2162         case PP_TOKEN:
2163           // Ignore tokens.
2164           break;
2165         }
2166         break;
2167       }
2168       }
2169     }
2170     NextCursor:  ;
2171   }
2172 }
2173 
2174 namespace {
2175 
2176   /// Visitor class used to look up identifirs in an AST file.
2177   class IdentifierLookupVisitor {
2178     StringRef Name;
2179     unsigned NameHash;
2180     unsigned PriorGeneration;
2181     unsigned &NumIdentifierLookups;
2182     unsigned &NumIdentifierLookupHits;
2183     IdentifierInfo *Found = nullptr;
2184 
2185   public:
2186     IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
2187                             unsigned &NumIdentifierLookups,
2188                             unsigned &NumIdentifierLookupHits)
2189       : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
2190         PriorGeneration(PriorGeneration),
2191         NumIdentifierLookups(NumIdentifierLookups),
2192         NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2193 
2194     bool operator()(ModuleFile &M) {
2195       // If we've already searched this module file, skip it now.
2196       if (M.Generation <= PriorGeneration)
2197         return true;
2198 
2199       ASTIdentifierLookupTable *IdTable
2200         = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2201       if (!IdTable)
2202         return false;
2203 
2204       ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
2205                                      Found);
2206       ++NumIdentifierLookups;
2207       ASTIdentifierLookupTable::iterator Pos =
2208           IdTable->find_hashed(Name, NameHash, &Trait);
2209       if (Pos == IdTable->end())
2210         return false;
2211 
2212       // Dereferencing the iterator has the effect of building the
2213       // IdentifierInfo node and populating it with the various
2214       // declarations it needs.
2215       ++NumIdentifierLookupHits;
2216       Found = *Pos;
2217       return true;
2218     }
2219 
2220     // Retrieve the identifier info found within the module
2221     // files.
2222     IdentifierInfo *getIdentifierInfo() const { return Found; }
2223   };
2224 
2225 } // namespace
2226 
2227 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
2228   // Note that we are loading an identifier.
2229   Deserializing AnIdentifier(this);
2230 
2231   unsigned PriorGeneration = 0;
2232   if (getContext().getLangOpts().Modules)
2233     PriorGeneration = IdentifierGeneration[&II];
2234 
2235   // If there is a global index, look there first to determine which modules
2236   // provably do not have any results for this identifier.
2237   GlobalModuleIndex::HitSet Hits;
2238   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
2239   if (!loadGlobalIndex()) {
2240     if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
2241       HitsPtr = &Hits;
2242     }
2243   }
2244 
2245   IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
2246                                   NumIdentifierLookups,
2247                                   NumIdentifierLookupHits);
2248   ModuleMgr.visit(Visitor, HitsPtr);
2249   markIdentifierUpToDate(&II);
2250 }
2251 
2252 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
2253   if (!II)
2254     return;
2255 
2256   II->setOutOfDate(false);
2257 
2258   // Update the generation for this identifier.
2259   if (getContext().getLangOpts().Modules)
2260     IdentifierGeneration[II] = getGeneration();
2261 }
2262 
2263 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
2264                                     const PendingMacroInfo &PMInfo) {
2265   ModuleFile &M = *PMInfo.M;
2266 
2267   BitstreamCursor &Cursor = M.MacroCursor;
2268   SavedStreamPosition SavedPosition(Cursor);
2269   if (llvm::Error Err =
2270           Cursor.JumpToBit(M.MacroOffsetsBase + PMInfo.MacroDirectivesOffset)) {
2271     Error(std::move(Err));
2272     return;
2273   }
2274 
2275   struct ModuleMacroRecord {
2276     SubmoduleID SubModID;
2277     MacroInfo *MI;
2278     SmallVector<SubmoduleID, 8> Overrides;
2279   };
2280   llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
2281 
2282   // We expect to see a sequence of PP_MODULE_MACRO records listing exported
2283   // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
2284   // macro histroy.
2285   RecordData Record;
2286   while (true) {
2287     Expected<llvm::BitstreamEntry> MaybeEntry =
2288         Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2289     if (!MaybeEntry) {
2290       Error(MaybeEntry.takeError());
2291       return;
2292     }
2293     llvm::BitstreamEntry Entry = MaybeEntry.get();
2294 
2295     if (Entry.Kind != llvm::BitstreamEntry::Record) {
2296       Error("malformed block record in AST file");
2297       return;
2298     }
2299 
2300     Record.clear();
2301     Expected<unsigned> MaybePP = Cursor.readRecord(Entry.ID, Record);
2302     if (!MaybePP) {
2303       Error(MaybePP.takeError());
2304       return;
2305     }
2306     switch ((PreprocessorRecordTypes)MaybePP.get()) {
2307     case PP_MACRO_DIRECTIVE_HISTORY:
2308       break;
2309 
2310     case PP_MODULE_MACRO: {
2311       ModuleMacros.push_back(ModuleMacroRecord());
2312       auto &Info = ModuleMacros.back();
2313       Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2314       Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2315       for (int I = 2, N = Record.size(); I != N; ++I)
2316         Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2317       continue;
2318     }
2319 
2320     default:
2321       Error("malformed block record in AST file");
2322       return;
2323     }
2324 
2325     // We found the macro directive history; that's the last record
2326     // for this macro.
2327     break;
2328   }
2329 
2330   // Module macros are listed in reverse dependency order.
2331   {
2332     std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2333     llvm::SmallVector<ModuleMacro*, 8> Overrides;
2334     for (auto &MMR : ModuleMacros) {
2335       Overrides.clear();
2336       for (unsigned ModID : MMR.Overrides) {
2337         Module *Mod = getSubmodule(ModID);
2338         auto *Macro = PP.getModuleMacro(Mod, II);
2339         assert(Macro && "missing definition for overridden macro");
2340         Overrides.push_back(Macro);
2341       }
2342 
2343       bool Inserted = false;
2344       Module *Owner = getSubmodule(MMR.SubModID);
2345       PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2346     }
2347   }
2348 
2349   // Don't read the directive history for a module; we don't have anywhere
2350   // to put it.
2351   if (M.isModule())
2352     return;
2353 
2354   // Deserialize the macro directives history in reverse source-order.
2355   MacroDirective *Latest = nullptr, *Earliest = nullptr;
2356   unsigned Idx = 0, N = Record.size();
2357   while (Idx < N) {
2358     MacroDirective *MD = nullptr;
2359     SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2360     MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2361     switch (K) {
2362     case MacroDirective::MD_Define: {
2363       MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2364       MD = PP.AllocateDefMacroDirective(MI, Loc);
2365       break;
2366     }
2367     case MacroDirective::MD_Undefine:
2368       MD = PP.AllocateUndefMacroDirective(Loc);
2369       break;
2370     case MacroDirective::MD_Visibility:
2371       bool isPublic = Record[Idx++];
2372       MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2373       break;
2374     }
2375 
2376     if (!Latest)
2377       Latest = MD;
2378     if (Earliest)
2379       Earliest->setPrevious(MD);
2380     Earliest = MD;
2381   }
2382 
2383   if (Latest)
2384     PP.setLoadedMacroDirective(II, Earliest, Latest);
2385 }
2386 
2387 bool ASTReader::shouldDisableValidationForFile(
2388     const serialization::ModuleFile &M) const {
2389   if (DisableValidationKind == DisableValidationForModuleKind::None)
2390     return false;
2391 
2392   // If a PCH is loaded and validation is disabled for PCH then disable
2393   // validation for the PCH and the modules it loads.
2394   ModuleKind K = CurrentDeserializingModuleKind.value_or(M.Kind);
2395 
2396   switch (K) {
2397   case MK_MainFile:
2398   case MK_Preamble:
2399   case MK_PCH:
2400     return bool(DisableValidationKind & DisableValidationForModuleKind::PCH);
2401   case MK_ImplicitModule:
2402   case MK_ExplicitModule:
2403   case MK_PrebuiltModule:
2404     return bool(DisableValidationKind & DisableValidationForModuleKind::Module);
2405   }
2406 
2407   return false;
2408 }
2409 
2410 InputFileInfo ASTReader::getInputFileInfo(ModuleFile &F, unsigned ID) {
2411   // If this ID is bogus, just return an empty input file.
2412   if (ID == 0 || ID > F.InputFileInfosLoaded.size())
2413     return InputFileInfo();
2414 
2415   // If we've already loaded this input file, return it.
2416   if (!F.InputFileInfosLoaded[ID - 1].Filename.empty())
2417     return F.InputFileInfosLoaded[ID - 1];
2418 
2419   // Go find this input file.
2420   BitstreamCursor &Cursor = F.InputFilesCursor;
2421   SavedStreamPosition SavedPosition(Cursor);
2422   if (llvm::Error Err = Cursor.JumpToBit(F.InputFilesOffsetBase +
2423                                          F.InputFileOffsets[ID - 1])) {
2424     // FIXME this drops errors on the floor.
2425     consumeError(std::move(Err));
2426   }
2427 
2428   Expected<unsigned> MaybeCode = Cursor.ReadCode();
2429   if (!MaybeCode) {
2430     // FIXME this drops errors on the floor.
2431     consumeError(MaybeCode.takeError());
2432   }
2433   unsigned Code = MaybeCode.get();
2434   RecordData Record;
2435   StringRef Blob;
2436 
2437   if (Expected<unsigned> Maybe = Cursor.readRecord(Code, Record, &Blob))
2438     assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE &&
2439            "invalid record type for input file");
2440   else {
2441     // FIXME this drops errors on the floor.
2442     consumeError(Maybe.takeError());
2443   }
2444 
2445   assert(Record[0] == ID && "Bogus stored ID or offset");
2446   InputFileInfo R;
2447   R.StoredSize = static_cast<off_t>(Record[1]);
2448   R.StoredTime = static_cast<time_t>(Record[2]);
2449   R.Overridden = static_cast<bool>(Record[3]);
2450   R.Transient = static_cast<bool>(Record[4]);
2451   R.TopLevel = static_cast<bool>(Record[5]);
2452   R.ModuleMap = static_cast<bool>(Record[6]);
2453   std::tie(R.FilenameAsRequested, R.Filename) = [&]() {
2454     uint16_t AsRequestedLength = Record[7];
2455 
2456     std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2457     std::string Name = Blob.substr(AsRequestedLength).str();
2458 
2459     ResolveImportedPath(F, NameAsRequested);
2460     ResolveImportedPath(F, Name);
2461 
2462     if (Name.empty())
2463       Name = NameAsRequested;
2464 
2465     return std::make_pair(std::move(NameAsRequested), std::move(Name));
2466   }();
2467 
2468   Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
2469   if (!MaybeEntry) // FIXME this drops errors on the floor.
2470     consumeError(MaybeEntry.takeError());
2471   llvm::BitstreamEntry Entry = MaybeEntry.get();
2472   assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2473          "expected record type for input file hash");
2474 
2475   Record.clear();
2476   if (Expected<unsigned> Maybe = Cursor.readRecord(Entry.ID, Record))
2477     assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE_HASH &&
2478            "invalid record type for input file hash");
2479   else {
2480     // FIXME this drops errors on the floor.
2481     consumeError(Maybe.takeError());
2482   }
2483   R.ContentHash = (static_cast<uint64_t>(Record[1]) << 32) |
2484                   static_cast<uint64_t>(Record[0]);
2485 
2486   // Note that we've loaded this input file info.
2487   F.InputFileInfosLoaded[ID - 1] = R;
2488   return R;
2489 }
2490 
2491 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2492 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2493   // If this ID is bogus, just return an empty input file.
2494   if (ID == 0 || ID > F.InputFilesLoaded.size())
2495     return InputFile();
2496 
2497   // If we've already loaded this input file, return it.
2498   if (F.InputFilesLoaded[ID-1].getFile())
2499     return F.InputFilesLoaded[ID-1];
2500 
2501   if (F.InputFilesLoaded[ID-1].isNotFound())
2502     return InputFile();
2503 
2504   // Go find this input file.
2505   BitstreamCursor &Cursor = F.InputFilesCursor;
2506   SavedStreamPosition SavedPosition(Cursor);
2507   if (llvm::Error Err = Cursor.JumpToBit(F.InputFilesOffsetBase +
2508                                          F.InputFileOffsets[ID - 1])) {
2509     // FIXME this drops errors on the floor.
2510     consumeError(std::move(Err));
2511   }
2512 
2513   InputFileInfo FI = getInputFileInfo(F, ID);
2514   off_t StoredSize = FI.StoredSize;
2515   time_t StoredTime = FI.StoredTime;
2516   bool Overridden = FI.Overridden;
2517   bool Transient = FI.Transient;
2518   StringRef Filename = FI.FilenameAsRequested;
2519   uint64_t StoredContentHash = FI.ContentHash;
2520 
2521   // For standard C++ modules, we don't need to check the inputs.
2522   bool SkipChecks = F.StandardCXXModule;
2523 
2524   const HeaderSearchOptions &HSOpts =
2525       PP.getHeaderSearchInfo().getHeaderSearchOpts();
2526 
2527   // The option ForceCheckCXX20ModulesInputFiles is only meaningful for C++20
2528   // modules.
2529   if (F.StandardCXXModule && HSOpts.ForceCheckCXX20ModulesInputFiles) {
2530     SkipChecks = false;
2531     Overridden = false;
2532   }
2533 
2534   auto File = FileMgr.getOptionalFileRef(Filename, /*OpenFile=*/false);
2535 
2536   // For an overridden file, create a virtual file with the stored
2537   // size/timestamp.
2538   if ((Overridden || Transient || SkipChecks) && !File)
2539     File = FileMgr.getVirtualFileRef(Filename, StoredSize, StoredTime);
2540 
2541   if (!File) {
2542     if (Complain) {
2543       std::string ErrorStr = "could not find file '";
2544       ErrorStr += Filename;
2545       ErrorStr += "' referenced by AST file '";
2546       ErrorStr += F.FileName;
2547       ErrorStr += "'";
2548       Error(ErrorStr);
2549     }
2550     // Record that we didn't find the file.
2551     F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2552     return InputFile();
2553   }
2554 
2555   // Check if there was a request to override the contents of the file
2556   // that was part of the precompiled header. Overriding such a file
2557   // can lead to problems when lexing using the source locations from the
2558   // PCH.
2559   SourceManager &SM = getSourceManager();
2560   // FIXME: Reject if the overrides are different.
2561   if ((!Overridden && !Transient) && !SkipChecks &&
2562       SM.isFileOverridden(*File)) {
2563     if (Complain)
2564       Error(diag::err_fe_pch_file_overridden, Filename);
2565 
2566     // After emitting the diagnostic, bypass the overriding file to recover
2567     // (this creates a separate FileEntry).
2568     File = SM.bypassFileContentsOverride(*File);
2569     if (!File) {
2570       F.InputFilesLoaded[ID - 1] = InputFile::getNotFound();
2571       return InputFile();
2572     }
2573   }
2574 
2575   struct Change {
2576     enum ModificationKind {
2577       Size,
2578       ModTime,
2579       Content,
2580       None,
2581     } Kind;
2582     std::optional<int64_t> Old = std::nullopt;
2583     std::optional<int64_t> New = std::nullopt;
2584   };
2585   auto HasInputContentChanged = [&](Change OriginalChange) {
2586     assert(ValidateASTInputFilesContent &&
2587            "We should only check the content of the inputs with "
2588            "ValidateASTInputFilesContent enabled.");
2589 
2590     if (StoredContentHash == static_cast<uint64_t>(llvm::hash_code(-1)))
2591       return OriginalChange;
2592 
2593     auto MemBuffOrError = FileMgr.getBufferForFile(*File);
2594     if (!MemBuffOrError) {
2595       if (!Complain)
2596         return OriginalChange;
2597       std::string ErrorStr = "could not get buffer for file '";
2598       ErrorStr += File->getName();
2599       ErrorStr += "'";
2600       Error(ErrorStr);
2601       return OriginalChange;
2602     }
2603 
2604     // FIXME: hash_value is not guaranteed to be stable!
2605     auto ContentHash = hash_value(MemBuffOrError.get()->getBuffer());
2606     if (StoredContentHash == static_cast<uint64_t>(ContentHash))
2607       return Change{Change::None};
2608 
2609     return Change{Change::Content};
2610   };
2611   auto HasInputFileChanged = [&]() {
2612     if (StoredSize != File->getSize())
2613       return Change{Change::Size, StoredSize, File->getSize()};
2614     if (!shouldDisableValidationForFile(F) && StoredTime &&
2615         StoredTime != File->getModificationTime()) {
2616       Change MTimeChange = {Change::ModTime, StoredTime,
2617                             File->getModificationTime()};
2618 
2619       // In case the modification time changes but not the content,
2620       // accept the cached file as legit.
2621       if (ValidateASTInputFilesContent)
2622         return HasInputContentChanged(MTimeChange);
2623 
2624       return MTimeChange;
2625     }
2626     return Change{Change::None};
2627   };
2628 
2629   bool IsOutOfDate = false;
2630   auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2631   // When ForceCheckCXX20ModulesInputFiles and ValidateASTInputFilesContent
2632   // enabled, it is better to check the contents of the inputs. Since we can't
2633   // get correct modified time information for inputs from overriden inputs.
2634   if (HSOpts.ForceCheckCXX20ModulesInputFiles && ValidateASTInputFilesContent &&
2635       F.StandardCXXModule && FileChange.Kind == Change::None)
2636     FileChange = HasInputContentChanged(FileChange);
2637 
2638   // For an overridden file, there is nothing to validate.
2639   if (!Overridden && FileChange.Kind != Change::None) {
2640     if (Complain && !Diags.isDiagnosticInFlight()) {
2641       // Build a list of the PCH imports that got us here (in reverse).
2642       SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2643       while (!ImportStack.back()->ImportedBy.empty())
2644         ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2645 
2646       // The top-level PCH is stale.
2647       StringRef TopLevelPCHName(ImportStack.back()->FileName);
2648       Diag(diag::err_fe_ast_file_modified)
2649           << Filename << moduleKindForDiagnostic(ImportStack.back()->Kind)
2650           << TopLevelPCHName << FileChange.Kind
2651           << (FileChange.Old && FileChange.New)
2652           << llvm::itostr(FileChange.Old.value_or(0))
2653           << llvm::itostr(FileChange.New.value_or(0));
2654 
2655       // Print the import stack.
2656       if (ImportStack.size() > 1) {
2657         Diag(diag::note_pch_required_by)
2658           << Filename << ImportStack[0]->FileName;
2659         for (unsigned I = 1; I < ImportStack.size(); ++I)
2660           Diag(diag::note_pch_required_by)
2661             << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2662       }
2663 
2664       Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2665     }
2666 
2667     IsOutOfDate = true;
2668   }
2669   // FIXME: If the file is overridden and we've already opened it,
2670   // issue an error (or split it into a separate FileEntry).
2671 
2672   InputFile IF = InputFile(*File, Overridden || Transient, IsOutOfDate);
2673 
2674   // Note that we've loaded this input file.
2675   F.InputFilesLoaded[ID-1] = IF;
2676   return IF;
2677 }
2678 
2679 /// If we are loading a relocatable PCH or module file, and the filename
2680 /// is not an absolute path, add the system or module root to the beginning of
2681 /// the file name.
2682 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2683   // Resolve relative to the base directory, if we have one.
2684   if (!M.BaseDirectory.empty())
2685     return ResolveImportedPath(Filename, M.BaseDirectory);
2686 }
2687 
2688 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2689   if (Filename.empty() || llvm::sys::path::is_absolute(Filename) ||
2690       Filename == "<built-in>" || Filename == "<command line>")
2691     return;
2692 
2693   SmallString<128> Buffer;
2694   llvm::sys::path::append(Buffer, Prefix, Filename);
2695   Filename.assign(Buffer.begin(), Buffer.end());
2696 }
2697 
2698 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2699   switch (ARR) {
2700   case ASTReader::Failure: return true;
2701   case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2702   case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2703   case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2704   case ASTReader::ConfigurationMismatch:
2705     return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2706   case ASTReader::HadErrors: return true;
2707   case ASTReader::Success: return false;
2708   }
2709 
2710   llvm_unreachable("unknown ASTReadResult");
2711 }
2712 
2713 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2714     BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2715     bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2716     std::string &SuggestedPredefines) {
2717   if (llvm::Error Err = Stream.EnterSubBlock(OPTIONS_BLOCK_ID)) {
2718     // FIXME this drops errors on the floor.
2719     consumeError(std::move(Err));
2720     return Failure;
2721   }
2722 
2723   // Read all of the records in the options block.
2724   RecordData Record;
2725   ASTReadResult Result = Success;
2726   while (true) {
2727     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2728     if (!MaybeEntry) {
2729       // FIXME this drops errors on the floor.
2730       consumeError(MaybeEntry.takeError());
2731       return Failure;
2732     }
2733     llvm::BitstreamEntry Entry = MaybeEntry.get();
2734 
2735     switch (Entry.Kind) {
2736     case llvm::BitstreamEntry::Error:
2737     case llvm::BitstreamEntry::SubBlock:
2738       return Failure;
2739 
2740     case llvm::BitstreamEntry::EndBlock:
2741       return Result;
2742 
2743     case llvm::BitstreamEntry::Record:
2744       // The interesting case.
2745       break;
2746     }
2747 
2748     // Read and process a record.
2749     Record.clear();
2750     Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
2751     if (!MaybeRecordType) {
2752       // FIXME this drops errors on the floor.
2753       consumeError(MaybeRecordType.takeError());
2754       return Failure;
2755     }
2756     switch ((OptionsRecordTypes)MaybeRecordType.get()) {
2757     case LANGUAGE_OPTIONS: {
2758       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2759       if (ParseLanguageOptions(Record, Complain, Listener,
2760                                AllowCompatibleConfigurationMismatch))
2761         Result = ConfigurationMismatch;
2762       break;
2763     }
2764 
2765     case TARGET_OPTIONS: {
2766       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2767       if (ParseTargetOptions(Record, Complain, Listener,
2768                              AllowCompatibleConfigurationMismatch))
2769         Result = ConfigurationMismatch;
2770       break;
2771     }
2772 
2773     case FILE_SYSTEM_OPTIONS: {
2774       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2775       if (!AllowCompatibleConfigurationMismatch &&
2776           ParseFileSystemOptions(Record, Complain, Listener))
2777         Result = ConfigurationMismatch;
2778       break;
2779     }
2780 
2781     case HEADER_SEARCH_OPTIONS: {
2782       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2783       if (!AllowCompatibleConfigurationMismatch &&
2784           ParseHeaderSearchOptions(Record, Complain, Listener))
2785         Result = ConfigurationMismatch;
2786       break;
2787     }
2788 
2789     case PREPROCESSOR_OPTIONS:
2790       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2791       if (!AllowCompatibleConfigurationMismatch &&
2792           ParsePreprocessorOptions(Record, Complain, Listener,
2793                                    SuggestedPredefines))
2794         Result = ConfigurationMismatch;
2795       break;
2796     }
2797   }
2798 }
2799 
2800 ASTReader::ASTReadResult
2801 ASTReader::ReadControlBlock(ModuleFile &F,
2802                             SmallVectorImpl<ImportedModule> &Loaded,
2803                             const ModuleFile *ImportedBy,
2804                             unsigned ClientLoadCapabilities) {
2805   BitstreamCursor &Stream = F.Stream;
2806 
2807   if (llvm::Error Err = Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2808     Error(std::move(Err));
2809     return Failure;
2810   }
2811 
2812   // Lambda to read the unhashed control block the first time it's called.
2813   //
2814   // For PCM files, the unhashed control block cannot be read until after the
2815   // MODULE_NAME record.  However, PCH files have no MODULE_NAME, and yet still
2816   // need to look ahead before reading the IMPORTS record.  For consistency,
2817   // this block is always read somehow (see BitstreamEntry::EndBlock).
2818   bool HasReadUnhashedControlBlock = false;
2819   auto readUnhashedControlBlockOnce = [&]() {
2820     if (!HasReadUnhashedControlBlock) {
2821       HasReadUnhashedControlBlock = true;
2822       if (ASTReadResult Result =
2823               readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2824         return Result;
2825     }
2826     return Success;
2827   };
2828 
2829   bool DisableValidation = shouldDisableValidationForFile(F);
2830 
2831   // Read all of the records and blocks in the control block.
2832   RecordData Record;
2833   unsigned NumInputs = 0;
2834   unsigned NumUserInputs = 0;
2835   StringRef BaseDirectoryAsWritten;
2836   while (true) {
2837     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2838     if (!MaybeEntry) {
2839       Error(MaybeEntry.takeError());
2840       return Failure;
2841     }
2842     llvm::BitstreamEntry Entry = MaybeEntry.get();
2843 
2844     switch (Entry.Kind) {
2845     case llvm::BitstreamEntry::Error:
2846       Error("malformed block record in AST file");
2847       return Failure;
2848     case llvm::BitstreamEntry::EndBlock: {
2849       // Validate the module before returning.  This call catches an AST with
2850       // no module name and no imports.
2851       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2852         return Result;
2853 
2854       // Validate input files.
2855       const HeaderSearchOptions &HSOpts =
2856           PP.getHeaderSearchInfo().getHeaderSearchOpts();
2857 
2858       // All user input files reside at the index range [0, NumUserInputs), and
2859       // system input files reside at [NumUserInputs, NumInputs). For explicitly
2860       // loaded module files, ignore missing inputs.
2861       if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2862           F.Kind != MK_PrebuiltModule) {
2863         bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2864 
2865         // If we are reading a module, we will create a verification timestamp,
2866         // so we verify all input files.  Otherwise, verify only user input
2867         // files.
2868 
2869         unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2870         if (HSOpts.ModulesValidateOncePerBuildSession &&
2871             F.InputFilesValidationTimestamp > HSOpts.BuildSessionTimestamp &&
2872             F.Kind == MK_ImplicitModule)
2873           N = NumUserInputs;
2874 
2875         for (unsigned I = 0; I < N; ++I) {
2876           InputFile IF = getInputFile(F, I+1, Complain);
2877           if (!IF.getFile() || IF.isOutOfDate())
2878             return OutOfDate;
2879         }
2880       }
2881 
2882       if (Listener)
2883         Listener->visitModuleFile(F.FileName, F.Kind);
2884 
2885       if (Listener && Listener->needsInputFileVisitation()) {
2886         unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2887                                                                 : NumUserInputs;
2888         for (unsigned I = 0; I < N; ++I) {
2889           bool IsSystem = I >= NumUserInputs;
2890           InputFileInfo FI = getInputFileInfo(F, I + 1);
2891           Listener->visitInputFile(
2892               FI.FilenameAsRequested, IsSystem, FI.Overridden,
2893               F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule);
2894         }
2895       }
2896 
2897       return Success;
2898     }
2899 
2900     case llvm::BitstreamEntry::SubBlock:
2901       switch (Entry.ID) {
2902       case INPUT_FILES_BLOCK_ID:
2903         F.InputFilesCursor = Stream;
2904         if (llvm::Error Err = Stream.SkipBlock()) {
2905           Error(std::move(Err));
2906           return Failure;
2907         }
2908         if (ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2909           Error("malformed block record in AST file");
2910           return Failure;
2911         }
2912         F.InputFilesOffsetBase = F.InputFilesCursor.GetCurrentBitNo();
2913         continue;
2914 
2915       case OPTIONS_BLOCK_ID:
2916         // If we're reading the first module for this group, check its options
2917         // are compatible with ours. For modules it imports, no further checking
2918         // is required, because we checked them when we built it.
2919         if (Listener && !ImportedBy) {
2920           // Should we allow the configuration of the module file to differ from
2921           // the configuration of the current translation unit in a compatible
2922           // way?
2923           //
2924           // FIXME: Allow this for files explicitly specified with -include-pch.
2925           bool AllowCompatibleConfigurationMismatch =
2926               F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2927 
2928           ASTReadResult Result =
2929               ReadOptionsBlock(Stream, ClientLoadCapabilities,
2930                                AllowCompatibleConfigurationMismatch, *Listener,
2931                                SuggestedPredefines);
2932           if (Result == Failure) {
2933             Error("malformed block record in AST file");
2934             return Result;
2935           }
2936 
2937           if (DisableValidation ||
2938               (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2939             Result = Success;
2940 
2941           // If we can't load the module, exit early since we likely
2942           // will rebuild the module anyway. The stream may be in the
2943           // middle of a block.
2944           if (Result != Success)
2945             return Result;
2946         } else if (llvm::Error Err = Stream.SkipBlock()) {
2947           Error(std::move(Err));
2948           return Failure;
2949         }
2950         continue;
2951 
2952       default:
2953         if (llvm::Error Err = Stream.SkipBlock()) {
2954           Error(std::move(Err));
2955           return Failure;
2956         }
2957         continue;
2958       }
2959 
2960     case llvm::BitstreamEntry::Record:
2961       // The interesting case.
2962       break;
2963     }
2964 
2965     // Read and process a record.
2966     Record.clear();
2967     StringRef Blob;
2968     Expected<unsigned> MaybeRecordType =
2969         Stream.readRecord(Entry.ID, Record, &Blob);
2970     if (!MaybeRecordType) {
2971       Error(MaybeRecordType.takeError());
2972       return Failure;
2973     }
2974     switch ((ControlRecordTypes)MaybeRecordType.get()) {
2975     case METADATA: {
2976       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2977         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2978           Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2979                                         : diag::err_pch_version_too_new);
2980         return VersionMismatch;
2981       }
2982 
2983       bool hasErrors = Record[7];
2984       if (hasErrors && !DisableValidation) {
2985         // If requested by the caller and the module hasn't already been read
2986         // or compiled, mark modules on error as out-of-date.
2987         if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2988             canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
2989           return OutOfDate;
2990 
2991         if (!AllowASTWithCompilerErrors) {
2992           Diag(diag::err_pch_with_compiler_errors);
2993           return HadErrors;
2994         }
2995       }
2996       if (hasErrors) {
2997         Diags.ErrorOccurred = true;
2998         Diags.UncompilableErrorOccurred = true;
2999         Diags.UnrecoverableErrorOccurred = true;
3000       }
3001 
3002       F.RelocatablePCH = Record[4];
3003       // Relative paths in a relocatable PCH are relative to our sysroot.
3004       if (F.RelocatablePCH)
3005         F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
3006 
3007       F.StandardCXXModule = Record[5];
3008 
3009       F.HasTimestamps = Record[6];
3010 
3011       const std::string &CurBranch = getClangFullRepositoryVersion();
3012       StringRef ASTBranch = Blob;
3013       if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
3014         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3015           Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
3016         return VersionMismatch;
3017       }
3018       break;
3019     }
3020 
3021     case IMPORTS: {
3022       // Validate the AST before processing any imports (otherwise, untangling
3023       // them can be error-prone and expensive).  A module will have a name and
3024       // will already have been validated, but this catches the PCH case.
3025       if (ASTReadResult Result = readUnhashedControlBlockOnce())
3026         return Result;
3027 
3028       // Load each of the imported PCH files.
3029       unsigned Idx = 0, N = Record.size();
3030       while (Idx < N) {
3031         // Read information about the AST file.
3032         ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
3033         // Whether we're importing a standard c++ module.
3034         bool IsImportingStdCXXModule = Record[Idx++];
3035         // The import location will be the local one for now; we will adjust
3036         // all import locations of module imports after the global source
3037         // location info are setup, in ReadAST.
3038         SourceLocation ImportLoc =
3039             ReadUntranslatedSourceLocation(Record[Idx++]);
3040         off_t StoredSize = !IsImportingStdCXXModule ? (off_t)Record[Idx++] : 0;
3041         time_t StoredModTime =
3042             !IsImportingStdCXXModule ? (time_t)Record[Idx++] : 0;
3043 
3044         ASTFileSignature StoredSignature;
3045         if (!IsImportingStdCXXModule) {
3046           auto FirstSignatureByte = Record.begin() + Idx;
3047           StoredSignature = ASTFileSignature::create(
3048               FirstSignatureByte, FirstSignatureByte + ASTFileSignature::size);
3049           Idx += ASTFileSignature::size;
3050         }
3051 
3052         std::string ImportedName = ReadString(Record, Idx);
3053         std::string ImportedFile;
3054 
3055         // For prebuilt and explicit modules first consult the file map for
3056         // an override. Note that here we don't search prebuilt module
3057         // directories if we're not importing standard c++ module, only the
3058         // explicit name to file mappings. Also, we will still verify the
3059         // size/signature making sure it is essentially the same file but
3060         // perhaps in a different location.
3061         if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
3062           ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
3063               ImportedName, /*FileMapOnly*/ !IsImportingStdCXXModule);
3064 
3065         // For C++20 Modules, we won't record the path to the imported modules
3066         // in the BMI
3067         if (!IsImportingStdCXXModule) {
3068           if (ImportedFile.empty()) {
3069             // Use BaseDirectoryAsWritten to ensure we use the same path in the
3070             // ModuleCache as when writing.
3071             ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
3072           } else
3073             SkipPath(Record, Idx);
3074         } else if (ImportedFile.empty()) {
3075           Diag(clang::diag::err_failed_to_find_module_file) << ImportedName;
3076           return Missing;
3077         }
3078 
3079         // If our client can't cope with us being out of date, we can't cope with
3080         // our dependency being missing.
3081         unsigned Capabilities = ClientLoadCapabilities;
3082         if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3083           Capabilities &= ~ARR_Missing;
3084 
3085         // Load the AST file.
3086         auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
3087                                   Loaded, StoredSize, StoredModTime,
3088                                   StoredSignature, Capabilities);
3089 
3090         // If we diagnosed a problem, produce a backtrace.
3091         bool recompilingFinalized =
3092             Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
3093             getModuleManager().getModuleCache().isPCMFinal(F.FileName);
3094         if (isDiagnosedResult(Result, Capabilities) || recompilingFinalized)
3095           Diag(diag::note_module_file_imported_by)
3096               << F.FileName << !F.ModuleName.empty() << F.ModuleName;
3097         if (recompilingFinalized)
3098           Diag(diag::note_module_file_conflict);
3099 
3100         switch (Result) {
3101         case Failure: return Failure;
3102           // If we have to ignore the dependency, we'll have to ignore this too.
3103         case Missing:
3104         case OutOfDate: return OutOfDate;
3105         case VersionMismatch: return VersionMismatch;
3106         case ConfigurationMismatch: return ConfigurationMismatch;
3107         case HadErrors: return HadErrors;
3108         case Success: break;
3109         }
3110       }
3111       break;
3112     }
3113 
3114     case ORIGINAL_FILE:
3115       F.OriginalSourceFileID = FileID::get(Record[0]);
3116       F.ActualOriginalSourceFileName = std::string(Blob);
3117       F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
3118       ResolveImportedPath(F, F.OriginalSourceFileName);
3119       break;
3120 
3121     case ORIGINAL_FILE_ID:
3122       F.OriginalSourceFileID = FileID::get(Record[0]);
3123       break;
3124 
3125     case MODULE_NAME:
3126       F.ModuleName = std::string(Blob);
3127       Diag(diag::remark_module_import)
3128           << F.ModuleName << F.FileName << (ImportedBy ? true : false)
3129           << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
3130       if (Listener)
3131         Listener->ReadModuleName(F.ModuleName);
3132 
3133       // Validate the AST as soon as we have a name so we can exit early on
3134       // failure.
3135       if (ASTReadResult Result = readUnhashedControlBlockOnce())
3136         return Result;
3137 
3138       break;
3139 
3140     case MODULE_DIRECTORY: {
3141       // Save the BaseDirectory as written in the PCM for computing the module
3142       // filename for the ModuleCache.
3143       BaseDirectoryAsWritten = Blob;
3144       assert(!F.ModuleName.empty() &&
3145              "MODULE_DIRECTORY found before MODULE_NAME");
3146       F.BaseDirectory = std::string(Blob);
3147       if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3148         break;
3149       // If we've already loaded a module map file covering this module, we may
3150       // have a better path for it (relative to the current build).
3151       Module *M = PP.getHeaderSearchInfo().lookupModule(
3152           F.ModuleName, SourceLocation(), /*AllowSearch*/ true,
3153           /*AllowExtraModuleMapSearch*/ true);
3154       if (M && M->Directory) {
3155         // If we're implicitly loading a module, the base directory can't
3156         // change between the build and use.
3157         // Don't emit module relocation error if we have -fno-validate-pch
3158         if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3159                   DisableValidationForModuleKind::Module) &&
3160             F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
3161           auto BuildDir = PP.getFileManager().getOptionalDirectoryRef(Blob);
3162           if (!BuildDir || *BuildDir != M->Directory) {
3163             if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
3164               Diag(diag::err_imported_module_relocated)
3165                   << F.ModuleName << Blob << M->Directory->getName();
3166             return OutOfDate;
3167           }
3168         }
3169         F.BaseDirectory = std::string(M->Directory->getName());
3170       }
3171       break;
3172     }
3173 
3174     case MODULE_MAP_FILE:
3175       if (ASTReadResult Result =
3176               ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
3177         return Result;
3178       break;
3179 
3180     case INPUT_FILE_OFFSETS:
3181       NumInputs = Record[0];
3182       NumUserInputs = Record[1];
3183       F.InputFileOffsets =
3184           (const llvm::support::unaligned_uint64_t *)Blob.data();
3185       F.InputFilesLoaded.resize(NumInputs);
3186       F.InputFileInfosLoaded.resize(NumInputs);
3187       F.NumUserInputFiles = NumUserInputs;
3188       break;
3189     }
3190   }
3191 }
3192 
3193 llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
3194                                     unsigned ClientLoadCapabilities) {
3195   BitstreamCursor &Stream = F.Stream;
3196 
3197   if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID))
3198     return Err;
3199   F.ASTBlockStartOffset = Stream.GetCurrentBitNo();
3200 
3201   // Read all of the records and blocks for the AST file.
3202   RecordData Record;
3203   while (true) {
3204     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
3205     if (!MaybeEntry)
3206       return MaybeEntry.takeError();
3207     llvm::BitstreamEntry Entry = MaybeEntry.get();
3208 
3209     switch (Entry.Kind) {
3210     case llvm::BitstreamEntry::Error:
3211       return llvm::createStringError(
3212           std::errc::illegal_byte_sequence,
3213           "error at end of module block in AST file");
3214     case llvm::BitstreamEntry::EndBlock:
3215       // Outside of C++, we do not store a lookup map for the translation unit.
3216       // Instead, mark it as needing a lookup map to be built if this module
3217       // contains any declarations lexically within it (which it always does!).
3218       // This usually has no cost, since we very rarely need the lookup map for
3219       // the translation unit outside C++.
3220       if (ASTContext *Ctx = ContextObj) {
3221         DeclContext *DC = Ctx->getTranslationUnitDecl();
3222         if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
3223           DC->setMustBuildLookupTable();
3224       }
3225 
3226       return llvm::Error::success();
3227     case llvm::BitstreamEntry::SubBlock:
3228       switch (Entry.ID) {
3229       case DECLTYPES_BLOCK_ID:
3230         // We lazily load the decls block, but we want to set up the
3231         // DeclsCursor cursor to point into it.  Clone our current bitcode
3232         // cursor to it, enter the block and read the abbrevs in that block.
3233         // With the main cursor, we just skip over it.
3234         F.DeclsCursor = Stream;
3235         if (llvm::Error Err = Stream.SkipBlock())
3236           return Err;
3237         if (llvm::Error Err = ReadBlockAbbrevs(
3238                 F.DeclsCursor, DECLTYPES_BLOCK_ID, &F.DeclsBlockStartOffset))
3239           return Err;
3240         break;
3241 
3242       case PREPROCESSOR_BLOCK_ID:
3243         F.MacroCursor = Stream;
3244         if (!PP.getExternalSource())
3245           PP.setExternalSource(this);
3246 
3247         if (llvm::Error Err = Stream.SkipBlock())
3248           return Err;
3249         if (llvm::Error Err =
3250                 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID))
3251           return Err;
3252         F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
3253         break;
3254 
3255       case PREPROCESSOR_DETAIL_BLOCK_ID:
3256         F.PreprocessorDetailCursor = Stream;
3257 
3258         if (llvm::Error Err = Stream.SkipBlock()) {
3259           return Err;
3260         }
3261         if (llvm::Error Err = ReadBlockAbbrevs(F.PreprocessorDetailCursor,
3262                                                PREPROCESSOR_DETAIL_BLOCK_ID))
3263           return Err;
3264         F.PreprocessorDetailStartOffset
3265         = F.PreprocessorDetailCursor.GetCurrentBitNo();
3266 
3267         if (!PP.getPreprocessingRecord())
3268           PP.createPreprocessingRecord();
3269         if (!PP.getPreprocessingRecord()->getExternalSource())
3270           PP.getPreprocessingRecord()->SetExternalSource(*this);
3271         break;
3272 
3273       case SOURCE_MANAGER_BLOCK_ID:
3274         if (llvm::Error Err = ReadSourceManagerBlock(F))
3275           return Err;
3276         break;
3277 
3278       case SUBMODULE_BLOCK_ID:
3279         if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3280           return Err;
3281         break;
3282 
3283       case COMMENTS_BLOCK_ID: {
3284         BitstreamCursor C = Stream;
3285 
3286         if (llvm::Error Err = Stream.SkipBlock())
3287           return Err;
3288         if (llvm::Error Err = ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID))
3289           return Err;
3290         CommentsCursors.push_back(std::make_pair(C, &F));
3291         break;
3292       }
3293 
3294       default:
3295         if (llvm::Error Err = Stream.SkipBlock())
3296           return Err;
3297         break;
3298       }
3299       continue;
3300 
3301     case llvm::BitstreamEntry::Record:
3302       // The interesting case.
3303       break;
3304     }
3305 
3306     // Read and process a record.
3307     Record.clear();
3308     StringRef Blob;
3309     Expected<unsigned> MaybeRecordType =
3310         Stream.readRecord(Entry.ID, Record, &Blob);
3311     if (!MaybeRecordType)
3312       return MaybeRecordType.takeError();
3313     ASTRecordTypes RecordType = (ASTRecordTypes)MaybeRecordType.get();
3314 
3315     // If we're not loading an AST context, we don't care about most records.
3316     if (!ContextObj) {
3317       switch (RecordType) {
3318       case IDENTIFIER_TABLE:
3319       case IDENTIFIER_OFFSET:
3320       case INTERESTING_IDENTIFIERS:
3321       case STATISTICS:
3322       case PP_ASSUME_NONNULL_LOC:
3323       case PP_CONDITIONAL_STACK:
3324       case PP_COUNTER_VALUE:
3325       case SOURCE_LOCATION_OFFSETS:
3326       case MODULE_OFFSET_MAP:
3327       case SOURCE_MANAGER_LINE_TABLE:
3328       case PPD_ENTITIES_OFFSETS:
3329       case HEADER_SEARCH_TABLE:
3330       case IMPORTED_MODULES:
3331       case MACRO_OFFSET:
3332         break;
3333       default:
3334         continue;
3335       }
3336     }
3337 
3338     switch (RecordType) {
3339     default:  // Default behavior: ignore.
3340       break;
3341 
3342     case TYPE_OFFSET: {
3343       if (F.LocalNumTypes != 0)
3344         return llvm::createStringError(
3345             std::errc::illegal_byte_sequence,
3346             "duplicate TYPE_OFFSET record in AST file");
3347       F.TypeOffsets = reinterpret_cast<const UnderalignedInt64 *>(Blob.data());
3348       F.LocalNumTypes = Record[0];
3349       unsigned LocalBaseTypeIndex = Record[1];
3350       F.BaseTypeIndex = getTotalNumTypes();
3351 
3352       if (F.LocalNumTypes > 0) {
3353         // Introduce the global -> local mapping for types within this module.
3354         GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3355 
3356         // Introduce the local -> global mapping for types within this module.
3357         F.TypeRemap.insertOrReplace(
3358           std::make_pair(LocalBaseTypeIndex,
3359                          F.BaseTypeIndex - LocalBaseTypeIndex));
3360 
3361         TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
3362       }
3363       break;
3364     }
3365 
3366     case DECL_OFFSET: {
3367       if (F.LocalNumDecls != 0)
3368         return llvm::createStringError(
3369             std::errc::illegal_byte_sequence,
3370             "duplicate DECL_OFFSET record in AST file");
3371       F.DeclOffsets = (const DeclOffset *)Blob.data();
3372       F.LocalNumDecls = Record[0];
3373       unsigned LocalBaseDeclID = Record[1];
3374       F.BaseDeclID = getTotalNumDecls();
3375 
3376       if (F.LocalNumDecls > 0) {
3377         // Introduce the global -> local mapping for declarations within this
3378         // module.
3379         GlobalDeclMap.insert(
3380           std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
3381 
3382         // Introduce the local -> global mapping for declarations within this
3383         // module.
3384         F.DeclRemap.insertOrReplace(
3385           std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
3386 
3387         // Introduce the global -> local mapping for declarations within this
3388         // module.
3389         F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
3390 
3391         DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
3392       }
3393       break;
3394     }
3395 
3396     case TU_UPDATE_LEXICAL: {
3397       DeclContext *TU = ContextObj->getTranslationUnitDecl();
3398       LexicalContents Contents(
3399           reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
3400               Blob.data()),
3401           static_cast<unsigned int>(Blob.size() / 4));
3402       TULexicalDecls.push_back(std::make_pair(&F, Contents));
3403       TU->setHasExternalLexicalStorage(true);
3404       break;
3405     }
3406 
3407     case UPDATE_VISIBLE: {
3408       unsigned Idx = 0;
3409       serialization::DeclID ID = ReadDeclID(F, Record, Idx);
3410       auto *Data = (const unsigned char*)Blob.data();
3411       PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3412       // If we've already loaded the decl, perform the updates when we finish
3413       // loading this block.
3414       if (Decl *D = GetExistingDecl(ID))
3415         PendingUpdateRecords.push_back(
3416             PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3417       break;
3418     }
3419 
3420     case IDENTIFIER_TABLE:
3421       F.IdentifierTableData =
3422           reinterpret_cast<const unsigned char *>(Blob.data());
3423       if (Record[0]) {
3424         F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
3425             F.IdentifierTableData + Record[0],
3426             F.IdentifierTableData + sizeof(uint32_t),
3427             F.IdentifierTableData,
3428             ASTIdentifierLookupTrait(*this, F));
3429 
3430         PP.getIdentifierTable().setExternalIdentifierLookup(this);
3431       }
3432       break;
3433 
3434     case IDENTIFIER_OFFSET: {
3435       if (F.LocalNumIdentifiers != 0)
3436         return llvm::createStringError(
3437             std::errc::illegal_byte_sequence,
3438             "duplicate IDENTIFIER_OFFSET record in AST file");
3439       F.IdentifierOffsets = (const uint32_t *)Blob.data();
3440       F.LocalNumIdentifiers = Record[0];
3441       unsigned LocalBaseIdentifierID = Record[1];
3442       F.BaseIdentifierID = getTotalNumIdentifiers();
3443 
3444       if (F.LocalNumIdentifiers > 0) {
3445         // Introduce the global -> local mapping for identifiers within this
3446         // module.
3447         GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3448                                                   &F));
3449 
3450         // Introduce the local -> global mapping for identifiers within this
3451         // module.
3452         F.IdentifierRemap.insertOrReplace(
3453           std::make_pair(LocalBaseIdentifierID,
3454                          F.BaseIdentifierID - LocalBaseIdentifierID));
3455 
3456         IdentifiersLoaded.resize(IdentifiersLoaded.size()
3457                                  + F.LocalNumIdentifiers);
3458       }
3459       break;
3460     }
3461 
3462     case INTERESTING_IDENTIFIERS:
3463       F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
3464       break;
3465 
3466     case EAGERLY_DESERIALIZED_DECLS:
3467       // FIXME: Skip reading this record if our ASTConsumer doesn't care
3468       // about "interesting" decls (for instance, if we're building a module).
3469       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3470         EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3471       break;
3472 
3473     case MODULAR_CODEGEN_DECLS:
3474       // FIXME: Skip reading this record if our ASTConsumer doesn't care about
3475       // them (ie: if we're not codegenerating this module).
3476       if (F.Kind == MK_MainFile ||
3477           getContext().getLangOpts().BuildingPCHWithObjectFile)
3478         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3479           EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3480       break;
3481 
3482     case SPECIAL_TYPES:
3483       if (SpecialTypes.empty()) {
3484         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3485           SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3486         break;
3487       }
3488 
3489       if (SpecialTypes.size() != Record.size())
3490         return llvm::createStringError(std::errc::illegal_byte_sequence,
3491                                        "invalid special-types record");
3492 
3493       for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3494         serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
3495         if (!SpecialTypes[I])
3496           SpecialTypes[I] = ID;
3497         // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
3498         // merge step?
3499       }
3500       break;
3501 
3502     case STATISTICS:
3503       TotalNumStatements += Record[0];
3504       TotalNumMacros += Record[1];
3505       TotalLexicalDeclContexts += Record[2];
3506       TotalVisibleDeclContexts += Record[3];
3507       break;
3508 
3509     case UNUSED_FILESCOPED_DECLS:
3510       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3511         UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3512       break;
3513 
3514     case DELEGATING_CTORS:
3515       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3516         DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3517       break;
3518 
3519     case WEAK_UNDECLARED_IDENTIFIERS:
3520       if (Record.size() % 3 != 0)
3521         return llvm::createStringError(std::errc::illegal_byte_sequence,
3522                                        "invalid weak identifiers record");
3523 
3524       // FIXME: Ignore weak undeclared identifiers from non-original PCH
3525       // files. This isn't the way to do it :)
3526       WeakUndeclaredIdentifiers.clear();
3527 
3528       // Translate the weak, undeclared identifiers into global IDs.
3529       for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3530         WeakUndeclaredIdentifiers.push_back(
3531           getGlobalIdentifierID(F, Record[I++]));
3532         WeakUndeclaredIdentifiers.push_back(
3533           getGlobalIdentifierID(F, Record[I++]));
3534         WeakUndeclaredIdentifiers.push_back(
3535             ReadSourceLocation(F, Record, I).getRawEncoding());
3536       }
3537       break;
3538 
3539     case SELECTOR_OFFSETS: {
3540       F.SelectorOffsets = (const uint32_t *)Blob.data();
3541       F.LocalNumSelectors = Record[0];
3542       unsigned LocalBaseSelectorID = Record[1];
3543       F.BaseSelectorID = getTotalNumSelectors();
3544 
3545       if (F.LocalNumSelectors > 0) {
3546         // Introduce the global -> local mapping for selectors within this
3547         // module.
3548         GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3549 
3550         // Introduce the local -> global mapping for selectors within this
3551         // module.
3552         F.SelectorRemap.insertOrReplace(
3553           std::make_pair(LocalBaseSelectorID,
3554                          F.BaseSelectorID - LocalBaseSelectorID));
3555 
3556         SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3557       }
3558       break;
3559     }
3560 
3561     case METHOD_POOL:
3562       F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3563       if (Record[0])
3564         F.SelectorLookupTable
3565           = ASTSelectorLookupTable::Create(
3566                         F.SelectorLookupTableData + Record[0],
3567                         F.SelectorLookupTableData,
3568                         ASTSelectorLookupTrait(*this, F));
3569       TotalNumMethodPoolEntries += Record[1];
3570       break;
3571 
3572     case REFERENCED_SELECTOR_POOL:
3573       if (!Record.empty()) {
3574         for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3575           ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3576                                                                 Record[Idx++]));
3577           ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3578                                               getRawEncoding());
3579         }
3580       }
3581       break;
3582 
3583     case PP_ASSUME_NONNULL_LOC: {
3584       unsigned Idx = 0;
3585       if (!Record.empty())
3586         PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3587             ReadSourceLocation(F, Record, Idx));
3588       break;
3589     }
3590 
3591     case PP_CONDITIONAL_STACK:
3592       if (!Record.empty()) {
3593         unsigned Idx = 0, End = Record.size() - 1;
3594         bool ReachedEOFWhileSkipping = Record[Idx++];
3595         std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3596         if (ReachedEOFWhileSkipping) {
3597           SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3598           SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3599           bool FoundNonSkipPortion = Record[Idx++];
3600           bool FoundElse = Record[Idx++];
3601           SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3602           SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3603                            FoundElse, ElseLoc);
3604         }
3605         SmallVector<PPConditionalInfo, 4> ConditionalStack;
3606         while (Idx < End) {
3607           auto Loc = ReadSourceLocation(F, Record, Idx);
3608           bool WasSkipping = Record[Idx++];
3609           bool FoundNonSkip = Record[Idx++];
3610           bool FoundElse = Record[Idx++];
3611           ConditionalStack.push_back(
3612               {Loc, WasSkipping, FoundNonSkip, FoundElse});
3613         }
3614         PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3615       }
3616       break;
3617 
3618     case PP_COUNTER_VALUE:
3619       if (!Record.empty() && Listener)
3620         Listener->ReadCounter(F, Record[0]);
3621       break;
3622 
3623     case FILE_SORTED_DECLS:
3624       F.FileSortedDecls = (const DeclID *)Blob.data();
3625       F.NumFileSortedDecls = Record[0];
3626       break;
3627 
3628     case SOURCE_LOCATION_OFFSETS: {
3629       F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3630       F.LocalNumSLocEntries = Record[0];
3631       SourceLocation::UIntTy SLocSpaceSize = Record[1];
3632       F.SLocEntryOffsetsBase = Record[2] + F.SourceManagerBlockStartOffset;
3633       std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3634           SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3635                                               SLocSpaceSize);
3636       if (!F.SLocEntryBaseID) {
3637         if (!Diags.isDiagnosticInFlight()) {
3638           Diags.Report(SourceLocation(), diag::remark_sloc_usage);
3639           SourceMgr.noteSLocAddressSpaceUsage(Diags);
3640         }
3641         return llvm::createStringError(std::errc::invalid_argument,
3642                                        "ran out of source locations");
3643       }
3644       // Make our entry in the range map. BaseID is negative and growing, so
3645       // we invert it. Because we invert it, though, we need the other end of
3646       // the range.
3647       unsigned RangeStart =
3648           unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3649       GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3650       F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3651 
3652       // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3653       assert((F.SLocEntryBaseOffset & SourceLocation::MacroIDBit) == 0);
3654       GlobalSLocOffsetMap.insert(
3655           std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3656                            - SLocSpaceSize,&F));
3657 
3658       // Initialize the remapping table.
3659       // Invalid stays invalid.
3660       F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3661       // This module. Base was 2 when being compiled.
3662       F.SLocRemap.insertOrReplace(std::make_pair(
3663           2U, static_cast<SourceLocation::IntTy>(F.SLocEntryBaseOffset - 2)));
3664 
3665       TotalNumSLocEntries += F.LocalNumSLocEntries;
3666       break;
3667     }
3668 
3669     case MODULE_OFFSET_MAP:
3670       F.ModuleOffsetMap = Blob;
3671       break;
3672 
3673     case SOURCE_MANAGER_LINE_TABLE:
3674       ParseLineTable(F, Record);
3675       break;
3676 
3677     case EXT_VECTOR_DECLS:
3678       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3679         ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3680       break;
3681 
3682     case VTABLE_USES:
3683       if (Record.size() % 3 != 0)
3684         return llvm::createStringError(std::errc::illegal_byte_sequence,
3685                                        "Invalid VTABLE_USES record");
3686 
3687       // Later tables overwrite earlier ones.
3688       // FIXME: Modules will have some trouble with this. This is clearly not
3689       // the right way to do this.
3690       VTableUses.clear();
3691 
3692       for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3693         VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3694         VTableUses.push_back(
3695           ReadSourceLocation(F, Record, Idx).getRawEncoding());
3696         VTableUses.push_back(Record[Idx++]);
3697       }
3698       break;
3699 
3700     case PENDING_IMPLICIT_INSTANTIATIONS:
3701       if (PendingInstantiations.size() % 2 != 0)
3702         return llvm::createStringError(
3703             std::errc::illegal_byte_sequence,
3704             "Invalid existing PendingInstantiations");
3705 
3706       if (Record.size() % 2 != 0)
3707         return llvm::createStringError(
3708             std::errc::illegal_byte_sequence,
3709             "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3710 
3711       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3712         PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3713         PendingInstantiations.push_back(
3714           ReadSourceLocation(F, Record, I).getRawEncoding());
3715       }
3716       break;
3717 
3718     case SEMA_DECL_REFS:
3719       if (Record.size() != 3)
3720         return llvm::createStringError(std::errc::illegal_byte_sequence,
3721                                        "Invalid SEMA_DECL_REFS block");
3722       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3723         SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3724       break;
3725 
3726     case PPD_ENTITIES_OFFSETS: {
3727       F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3728       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3729       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3730 
3731       unsigned LocalBasePreprocessedEntityID = Record[0];
3732 
3733       unsigned StartingID;
3734       if (!PP.getPreprocessingRecord())
3735         PP.createPreprocessingRecord();
3736       if (!PP.getPreprocessingRecord()->getExternalSource())
3737         PP.getPreprocessingRecord()->SetExternalSource(*this);
3738       StartingID
3739         = PP.getPreprocessingRecord()
3740             ->allocateLoadedEntities(F.NumPreprocessedEntities);
3741       F.BasePreprocessedEntityID = StartingID;
3742 
3743       if (F.NumPreprocessedEntities > 0) {
3744         // Introduce the global -> local mapping for preprocessed entities in
3745         // this module.
3746         GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3747 
3748         // Introduce the local -> global mapping for preprocessed entities in
3749         // this module.
3750         F.PreprocessedEntityRemap.insertOrReplace(
3751           std::make_pair(LocalBasePreprocessedEntityID,
3752             F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3753       }
3754 
3755       break;
3756     }
3757 
3758     case PPD_SKIPPED_RANGES: {
3759       F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3760       assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3761       F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3762 
3763       if (!PP.getPreprocessingRecord())
3764         PP.createPreprocessingRecord();
3765       if (!PP.getPreprocessingRecord()->getExternalSource())
3766         PP.getPreprocessingRecord()->SetExternalSource(*this);
3767       F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3768           ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3769 
3770       if (F.NumPreprocessedSkippedRanges > 0)
3771         GlobalSkippedRangeMap.insert(
3772             std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3773       break;
3774     }
3775 
3776     case DECL_UPDATE_OFFSETS:
3777       if (Record.size() % 2 != 0)
3778         return llvm::createStringError(
3779             std::errc::illegal_byte_sequence,
3780             "invalid DECL_UPDATE_OFFSETS block in AST file");
3781       for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3782         GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3783         DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3784 
3785         // If we've already loaded the decl, perform the updates when we finish
3786         // loading this block.
3787         if (Decl *D = GetExistingDecl(ID))
3788           PendingUpdateRecords.push_back(
3789               PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3790       }
3791       break;
3792 
3793     case OBJC_CATEGORIES_MAP:
3794       if (F.LocalNumObjCCategoriesInMap != 0)
3795         return llvm::createStringError(
3796             std::errc::illegal_byte_sequence,
3797             "duplicate OBJC_CATEGORIES_MAP record in AST file");
3798 
3799       F.LocalNumObjCCategoriesInMap = Record[0];
3800       F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3801       break;
3802 
3803     case OBJC_CATEGORIES:
3804       F.ObjCCategories.swap(Record);
3805       break;
3806 
3807     case CUDA_SPECIAL_DECL_REFS:
3808       // Later tables overwrite earlier ones.
3809       // FIXME: Modules will have trouble with this.
3810       CUDASpecialDeclRefs.clear();
3811       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3812         CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3813       break;
3814 
3815     case HEADER_SEARCH_TABLE:
3816       F.HeaderFileInfoTableData = Blob.data();
3817       F.LocalNumHeaderFileInfos = Record[1];
3818       if (Record[0]) {
3819         F.HeaderFileInfoTable
3820           = HeaderFileInfoLookupTable::Create(
3821                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3822                    (const unsigned char *)F.HeaderFileInfoTableData,
3823                    HeaderFileInfoTrait(*this, F,
3824                                        &PP.getHeaderSearchInfo(),
3825                                        Blob.data() + Record[2]));
3826 
3827         PP.getHeaderSearchInfo().SetExternalSource(this);
3828         if (!PP.getHeaderSearchInfo().getExternalLookup())
3829           PP.getHeaderSearchInfo().SetExternalLookup(this);
3830       }
3831       break;
3832 
3833     case FP_PRAGMA_OPTIONS:
3834       // Later tables overwrite earlier ones.
3835       FPPragmaOptions.swap(Record);
3836       break;
3837 
3838     case OPENCL_EXTENSIONS:
3839       for (unsigned I = 0, E = Record.size(); I != E; ) {
3840         auto Name = ReadString(Record, I);
3841         auto &OptInfo = OpenCLExtensions.OptMap[Name];
3842         OptInfo.Supported = Record[I++] != 0;
3843         OptInfo.Enabled = Record[I++] != 0;
3844         OptInfo.WithPragma = Record[I++] != 0;
3845         OptInfo.Avail = Record[I++];
3846         OptInfo.Core = Record[I++];
3847         OptInfo.Opt = Record[I++];
3848       }
3849       break;
3850 
3851     case TENTATIVE_DEFINITIONS:
3852       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3853         TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3854       break;
3855 
3856     case KNOWN_NAMESPACES:
3857       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3858         KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3859       break;
3860 
3861     case UNDEFINED_BUT_USED:
3862       if (UndefinedButUsed.size() % 2 != 0)
3863         return llvm::createStringError(std::errc::illegal_byte_sequence,
3864                                        "Invalid existing UndefinedButUsed");
3865 
3866       if (Record.size() % 2 != 0)
3867         return llvm::createStringError(std::errc::illegal_byte_sequence,
3868                                        "invalid undefined-but-used record");
3869       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3870         UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3871         UndefinedButUsed.push_back(
3872             ReadSourceLocation(F, Record, I).getRawEncoding());
3873       }
3874       break;
3875 
3876     case DELETE_EXPRS_TO_ANALYZE:
3877       for (unsigned I = 0, N = Record.size(); I != N;) {
3878         DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3879         const uint64_t Count = Record[I++];
3880         DelayedDeleteExprs.push_back(Count);
3881         for (uint64_t C = 0; C < Count; ++C) {
3882           DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3883           bool IsArrayForm = Record[I++] == 1;
3884           DelayedDeleteExprs.push_back(IsArrayForm);
3885         }
3886       }
3887       break;
3888 
3889     case IMPORTED_MODULES:
3890       if (!F.isModule()) {
3891         // If we aren't loading a module (which has its own exports), make
3892         // all of the imported modules visible.
3893         // FIXME: Deal with macros-only imports.
3894         for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3895           unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3896           SourceLocation Loc = ReadSourceLocation(F, Record, I);
3897           if (GlobalID) {
3898             PendingImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3899             if (DeserializationListener)
3900               DeserializationListener->ModuleImportRead(GlobalID, Loc);
3901           }
3902         }
3903       }
3904       break;
3905 
3906     case MACRO_OFFSET: {
3907       if (F.LocalNumMacros != 0)
3908         return llvm::createStringError(
3909             std::errc::illegal_byte_sequence,
3910             "duplicate MACRO_OFFSET record in AST file");
3911       F.MacroOffsets = (const uint32_t *)Blob.data();
3912       F.LocalNumMacros = Record[0];
3913       unsigned LocalBaseMacroID = Record[1];
3914       F.MacroOffsetsBase = Record[2] + F.ASTBlockStartOffset;
3915       F.BaseMacroID = getTotalNumMacros();
3916 
3917       if (F.LocalNumMacros > 0) {
3918         // Introduce the global -> local mapping for macros within this module.
3919         GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3920 
3921         // Introduce the local -> global mapping for macros within this module.
3922         F.MacroRemap.insertOrReplace(
3923           std::make_pair(LocalBaseMacroID,
3924                          F.BaseMacroID - LocalBaseMacroID));
3925 
3926         MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3927       }
3928       break;
3929     }
3930 
3931     case LATE_PARSED_TEMPLATE:
3932       LateParsedTemplates.emplace_back(
3933           std::piecewise_construct, std::forward_as_tuple(&F),
3934           std::forward_as_tuple(Record.begin(), Record.end()));
3935       break;
3936 
3937     case OPTIMIZE_PRAGMA_OPTIONS:
3938       if (Record.size() != 1)
3939         return llvm::createStringError(std::errc::illegal_byte_sequence,
3940                                        "invalid pragma optimize record");
3941       OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3942       break;
3943 
3944     case MSSTRUCT_PRAGMA_OPTIONS:
3945       if (Record.size() != 1)
3946         return llvm::createStringError(std::errc::illegal_byte_sequence,
3947                                        "invalid pragma ms_struct record");
3948       PragmaMSStructState = Record[0];
3949       break;
3950 
3951     case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3952       if (Record.size() != 2)
3953         return llvm::createStringError(
3954             std::errc::illegal_byte_sequence,
3955             "invalid pragma pointers to members record");
3956       PragmaMSPointersToMembersState = Record[0];
3957       PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3958       break;
3959 
3960     case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3961       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3962         UnusedLocalTypedefNameCandidates.push_back(
3963             getGlobalDeclID(F, Record[I]));
3964       break;
3965 
3966     case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3967       if (Record.size() != 1)
3968         return llvm::createStringError(std::errc::illegal_byte_sequence,
3969                                        "invalid cuda pragma options record");
3970       ForceCUDAHostDeviceDepth = Record[0];
3971       break;
3972 
3973     case ALIGN_PACK_PRAGMA_OPTIONS: {
3974       if (Record.size() < 3)
3975         return llvm::createStringError(std::errc::illegal_byte_sequence,
3976                                        "invalid pragma pack record");
3977       PragmaAlignPackCurrentValue = ReadAlignPackInfo(Record[0]);
3978       PragmaAlignPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3979       unsigned NumStackEntries = Record[2];
3980       unsigned Idx = 3;
3981       // Reset the stack when importing a new module.
3982       PragmaAlignPackStack.clear();
3983       for (unsigned I = 0; I < NumStackEntries; ++I) {
3984         PragmaAlignPackStackEntry Entry;
3985         Entry.Value = ReadAlignPackInfo(Record[Idx++]);
3986         Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3987         Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3988         PragmaAlignPackStrings.push_back(ReadString(Record, Idx));
3989         Entry.SlotLabel = PragmaAlignPackStrings.back();
3990         PragmaAlignPackStack.push_back(Entry);
3991       }
3992       break;
3993     }
3994 
3995     case FLOAT_CONTROL_PRAGMA_OPTIONS: {
3996       if (Record.size() < 3)
3997         return llvm::createStringError(std::errc::illegal_byte_sequence,
3998                                        "invalid pragma float control record");
3999       FpPragmaCurrentValue = FPOptionsOverride::getFromOpaqueInt(Record[0]);
4000       FpPragmaCurrentLocation = ReadSourceLocation(F, Record[1]);
4001       unsigned NumStackEntries = Record[2];
4002       unsigned Idx = 3;
4003       // Reset the stack when importing a new module.
4004       FpPragmaStack.clear();
4005       for (unsigned I = 0; I < NumStackEntries; ++I) {
4006         FpPragmaStackEntry Entry;
4007         Entry.Value = FPOptionsOverride::getFromOpaqueInt(Record[Idx++]);
4008         Entry.Location = ReadSourceLocation(F, Record[Idx++]);
4009         Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
4010         FpPragmaStrings.push_back(ReadString(Record, Idx));
4011         Entry.SlotLabel = FpPragmaStrings.back();
4012         FpPragmaStack.push_back(Entry);
4013       }
4014       break;
4015     }
4016 
4017     case DECLS_TO_CHECK_FOR_DEFERRED_DIAGS:
4018       for (unsigned I = 0, N = Record.size(); I != N; ++I)
4019         DeclsToCheckForDeferredDiags.insert(getGlobalDeclID(F, Record[I]));
4020       break;
4021     }
4022   }
4023 }
4024 
4025 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
4026   assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
4027 
4028   // Additional remapping information.
4029   const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
4030   const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
4031   F.ModuleOffsetMap = StringRef();
4032 
4033   // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
4034   if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
4035     F.SLocRemap.insert(std::make_pair(0U, 0));
4036     F.SLocRemap.insert(std::make_pair(2U, 1));
4037   }
4038 
4039   // Continuous range maps we may be updating in our module.
4040   using SLocRemapBuilder =
4041       ContinuousRangeMap<SourceLocation::UIntTy, SourceLocation::IntTy,
4042                          2>::Builder;
4043   using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
4044   SLocRemapBuilder SLocRemap(F.SLocRemap);
4045   RemapBuilder IdentifierRemap(F.IdentifierRemap);
4046   RemapBuilder MacroRemap(F.MacroRemap);
4047   RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
4048   RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
4049   RemapBuilder SelectorRemap(F.SelectorRemap);
4050   RemapBuilder DeclRemap(F.DeclRemap);
4051   RemapBuilder TypeRemap(F.TypeRemap);
4052 
4053   while (Data < DataEnd) {
4054     // FIXME: Looking up dependency modules by filename is horrible. Let's
4055     // start fixing this with prebuilt, explicit and implicit modules and see
4056     // how it goes...
4057     using namespace llvm::support;
4058     ModuleKind Kind = static_cast<ModuleKind>(
4059         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data));
4060     uint16_t Len =
4061         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
4062     StringRef Name = StringRef((const char*)Data, Len);
4063     Data += Len;
4064     ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule ||
4065                               Kind == MK_ImplicitModule
4066                           ? ModuleMgr.lookupByModuleName(Name)
4067                           : ModuleMgr.lookupByFileName(Name));
4068     if (!OM) {
4069       std::string Msg =
4070           "SourceLocation remap refers to unknown module, cannot find ";
4071       Msg.append(std::string(Name));
4072       Error(Msg);
4073       return;
4074     }
4075 
4076     SourceLocation::UIntTy SLocOffset =
4077         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4078     uint32_t IdentifierIDOffset =
4079         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4080     uint32_t MacroIDOffset =
4081         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4082     uint32_t PreprocessedEntityIDOffset =
4083         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4084     uint32_t SubmoduleIDOffset =
4085         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4086     uint32_t SelectorIDOffset =
4087         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4088     uint32_t DeclIDOffset =
4089         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4090     uint32_t TypeIndexOffset =
4091         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
4092 
4093     auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4094                          RemapBuilder &Remap) {
4095       constexpr uint32_t None = std::numeric_limits<uint32_t>::max();
4096       if (Offset != None)
4097         Remap.insert(std::make_pair(Offset,
4098                                     static_cast<int>(BaseOffset - Offset)));
4099     };
4100 
4101     constexpr SourceLocation::UIntTy SLocNone =
4102         std::numeric_limits<SourceLocation::UIntTy>::max();
4103     if (SLocOffset != SLocNone)
4104       SLocRemap.insert(std::make_pair(
4105           SLocOffset, static_cast<SourceLocation::IntTy>(
4106                           OM->SLocEntryBaseOffset - SLocOffset)));
4107 
4108     mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
4109     mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
4110     mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
4111               PreprocessedEntityRemap);
4112     mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
4113     mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
4114     mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
4115     mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
4116 
4117     // Global -> local mappings.
4118     F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
4119   }
4120 }
4121 
4122 ASTReader::ASTReadResult
4123 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
4124                                   const ModuleFile *ImportedBy,
4125                                   unsigned ClientLoadCapabilities) {
4126   unsigned Idx = 0;
4127   F.ModuleMapPath = ReadPath(F, Record, Idx);
4128 
4129   // Try to resolve ModuleName in the current header search context and
4130   // verify that it is found in the same module map file as we saved. If the
4131   // top-level AST file is a main file, skip this check because there is no
4132   // usable header search context.
4133   assert(!F.ModuleName.empty() &&
4134          "MODULE_NAME should come before MODULE_MAP_FILE");
4135   if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4136       F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
4137     // An implicitly-loaded module file should have its module listed in some
4138     // module map file that we've already loaded.
4139     Module *M =
4140         PP.getHeaderSearchInfo().lookupModule(F.ModuleName, F.ImportLoc);
4141     auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4142     OptionalFileEntryRef ModMap =
4143         M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4144     // Don't emit module relocation error if we have -fno-validate-pch
4145     if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4146               DisableValidationForModuleKind::Module) &&
4147         !ModMap) {
4148       if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities)) {
4149         if (auto ASTFE = M ? M->getASTFile() : std::nullopt) {
4150           // This module was defined by an imported (explicit) module.
4151           Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
4152                                                << ASTFE->getName();
4153         } else {
4154           // This module was built with a different module map.
4155           Diag(diag::err_imported_module_not_found)
4156               << F.ModuleName << F.FileName
4157               << (ImportedBy ? ImportedBy->FileName : "") << F.ModuleMapPath
4158               << !ImportedBy;
4159           // In case it was imported by a PCH, there's a chance the user is
4160           // just missing to include the search path to the directory containing
4161           // the modulemap.
4162           if (ImportedBy && ImportedBy->Kind == MK_PCH)
4163             Diag(diag::note_imported_by_pch_module_not_found)
4164                 << llvm::sys::path::parent_path(F.ModuleMapPath);
4165         }
4166       }
4167       return OutOfDate;
4168     }
4169 
4170     assert(M && M->Name == F.ModuleName && "found module with different name");
4171 
4172     // Check the primary module map file.
4173     auto StoredModMap = FileMgr.getFile(F.ModuleMapPath);
4174     if (!StoredModMap || *StoredModMap != ModMap) {
4175       assert(ModMap && "found module is missing module map file");
4176       assert((ImportedBy || F.Kind == MK_ImplicitModule) &&
4177              "top-level import should be verified");
4178       bool NotImported = F.Kind == MK_ImplicitModule && !ImportedBy;
4179       if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4180         Diag(diag::err_imported_module_modmap_changed)
4181             << F.ModuleName << (NotImported ? F.FileName : ImportedBy->FileName)
4182             << ModMap->getName() << F.ModuleMapPath << NotImported;
4183       return OutOfDate;
4184     }
4185 
4186     ModuleMap::AdditionalModMapsSet AdditionalStoredMaps;
4187     for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
4188       // FIXME: we should use input files rather than storing names.
4189       std::string Filename = ReadPath(F, Record, Idx);
4190       auto SF = FileMgr.getOptionalFileRef(Filename, false, false);
4191       if (!SF) {
4192         if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4193           Error("could not find file '" + Filename +"' referenced by AST file");
4194         return OutOfDate;
4195       }
4196       AdditionalStoredMaps.insert(*SF);
4197     }
4198 
4199     // Check any additional module map files (e.g. module.private.modulemap)
4200     // that are not in the pcm.
4201     if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4202       for (FileEntryRef ModMap : *AdditionalModuleMaps) {
4203         // Remove files that match
4204         // Note: SmallPtrSet::erase is really remove
4205         if (!AdditionalStoredMaps.erase(ModMap)) {
4206           if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4207             Diag(diag::err_module_different_modmap)
4208               << F.ModuleName << /*new*/0 << ModMap.getName();
4209           return OutOfDate;
4210         }
4211       }
4212     }
4213 
4214     // Check any additional module map files that are in the pcm, but not
4215     // found in header search. Cases that match are already removed.
4216     for (FileEntryRef ModMap : AdditionalStoredMaps) {
4217       if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities))
4218         Diag(diag::err_module_different_modmap)
4219           << F.ModuleName << /*not new*/1 << ModMap.getName();
4220       return OutOfDate;
4221     }
4222   }
4223 
4224   if (Listener)
4225     Listener->ReadModuleMapFile(F.ModuleMapPath);
4226   return Success;
4227 }
4228 
4229 /// Move the given method to the back of the global list of methods.
4230 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
4231   // Find the entry for this selector in the method pool.
4232   Sema::GlobalMethodPool::iterator Known
4233     = S.MethodPool.find(Method->getSelector());
4234   if (Known == S.MethodPool.end())
4235     return;
4236 
4237   // Retrieve the appropriate method list.
4238   ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
4239                                                     : Known->second.second;
4240   bool Found = false;
4241   for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
4242     if (!Found) {
4243       if (List->getMethod() == Method) {
4244         Found = true;
4245       } else {
4246         // Keep searching.
4247         continue;
4248       }
4249     }
4250 
4251     if (List->getNext())
4252       List->setMethod(List->getNext()->getMethod());
4253     else
4254       List->setMethod(Method);
4255   }
4256 }
4257 
4258 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
4259   assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
4260   for (Decl *D : Names) {
4261     bool wasHidden = !D->isUnconditionallyVisible();
4262     D->setVisibleDespiteOwningModule();
4263 
4264     if (wasHidden && SemaObj) {
4265       if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
4266         moveMethodToBackOfGlobalList(*SemaObj, Method);
4267       }
4268     }
4269   }
4270 }
4271 
4272 void ASTReader::makeModuleVisible(Module *Mod,
4273                                   Module::NameVisibilityKind NameVisibility,
4274                                   SourceLocation ImportLoc) {
4275   llvm::SmallPtrSet<Module *, 4> Visited;
4276   SmallVector<Module *, 4> Stack;
4277   Stack.push_back(Mod);
4278   while (!Stack.empty()) {
4279     Mod = Stack.pop_back_val();
4280 
4281     if (NameVisibility <= Mod->NameVisibility) {
4282       // This module already has this level of visibility (or greater), so
4283       // there is nothing more to do.
4284       continue;
4285     }
4286 
4287     if (Mod->isUnimportable()) {
4288       // Modules that aren't importable cannot be made visible.
4289       continue;
4290     }
4291 
4292     // Update the module's name visibility.
4293     Mod->NameVisibility = NameVisibility;
4294 
4295     // If we've already deserialized any names from this module,
4296     // mark them as visible.
4297     HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4298     if (Hidden != HiddenNamesMap.end()) {
4299       auto HiddenNames = std::move(*Hidden);
4300       HiddenNamesMap.erase(Hidden);
4301       makeNamesVisible(HiddenNames.second, HiddenNames.first);
4302       assert(!HiddenNamesMap.contains(Mod) &&
4303              "making names visible added hidden names");
4304     }
4305 
4306     // Push any exported modules onto the stack to be marked as visible.
4307     SmallVector<Module *, 16> Exports;
4308     Mod->getExportedModules(Exports);
4309     for (SmallVectorImpl<Module *>::iterator
4310            I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4311       Module *Exported = *I;
4312       if (Visited.insert(Exported).second)
4313         Stack.push_back(Exported);
4314     }
4315   }
4316 }
4317 
4318 /// We've merged the definition \p MergedDef into the existing definition
4319 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
4320 /// visible.
4321 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
4322                                           NamedDecl *MergedDef) {
4323   if (!Def->isUnconditionallyVisible()) {
4324     // If MergedDef is visible or becomes visible, make the definition visible.
4325     if (MergedDef->isUnconditionallyVisible())
4326       Def->setVisibleDespiteOwningModule();
4327     else {
4328       getContext().mergeDefinitionIntoModule(
4329           Def, MergedDef->getImportedOwningModule(),
4330           /*NotifyListeners*/ false);
4331       PendingMergedDefinitionsToDeduplicate.insert(Def);
4332     }
4333   }
4334 }
4335 
4336 bool ASTReader::loadGlobalIndex() {
4337   if (GlobalIndex)
4338     return false;
4339 
4340   if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4341       !PP.getLangOpts().Modules)
4342     return true;
4343 
4344   // Try to load the global index.
4345   TriedLoadingGlobalIndex = true;
4346   StringRef ModuleCachePath
4347     = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4348   std::pair<GlobalModuleIndex *, llvm::Error> Result =
4349       GlobalModuleIndex::readIndex(ModuleCachePath);
4350   if (llvm::Error Err = std::move(Result.second)) {
4351     assert(!Result.first);
4352     consumeError(std::move(Err)); // FIXME this drops errors on the floor.
4353     return true;
4354   }
4355 
4356   GlobalIndex.reset(Result.first);
4357   ModuleMgr.setGlobalIndex(GlobalIndex.get());
4358   return false;
4359 }
4360 
4361 bool ASTReader::isGlobalIndexUnavailable() const {
4362   return PP.getLangOpts().Modules && UseGlobalIndex &&
4363          !hasGlobalIndex() && TriedLoadingGlobalIndex;
4364 }
4365 
4366 static void updateModuleTimestamp(ModuleFile &MF) {
4367   // Overwrite the timestamp file contents so that file's mtime changes.
4368   std::string TimestampFilename = MF.getTimestampFilename();
4369   std::error_code EC;
4370   llvm::raw_fd_ostream OS(TimestampFilename, EC,
4371                           llvm::sys::fs::OF_TextWithCRLF);
4372   if (EC)
4373     return;
4374   OS << "Timestamp file\n";
4375   OS.close();
4376   OS.clear_error(); // Avoid triggering a fatal error.
4377 }
4378 
4379 /// Given a cursor at the start of an AST file, scan ahead and drop the
4380 /// cursor into the start of the given block ID, returning false on success and
4381 /// true on failure.
4382 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4383   while (true) {
4384     Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
4385     if (!MaybeEntry) {
4386       // FIXME this drops errors on the floor.
4387       consumeError(MaybeEntry.takeError());
4388       return true;
4389     }
4390     llvm::BitstreamEntry Entry = MaybeEntry.get();
4391 
4392     switch (Entry.Kind) {
4393     case llvm::BitstreamEntry::Error:
4394     case llvm::BitstreamEntry::EndBlock:
4395       return true;
4396 
4397     case llvm::BitstreamEntry::Record:
4398       // Ignore top-level records.
4399       if (Expected<unsigned> Skipped = Cursor.skipRecord(Entry.ID))
4400         break;
4401       else {
4402         // FIXME this drops errors on the floor.
4403         consumeError(Skipped.takeError());
4404         return true;
4405       }
4406 
4407     case llvm::BitstreamEntry::SubBlock:
4408       if (Entry.ID == BlockID) {
4409         if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4410           // FIXME this drops the error on the floor.
4411           consumeError(std::move(Err));
4412           return true;
4413         }
4414         // Found it!
4415         return false;
4416       }
4417 
4418       if (llvm::Error Err = Cursor.SkipBlock()) {
4419         // FIXME this drops the error on the floor.
4420         consumeError(std::move(Err));
4421         return true;
4422       }
4423     }
4424   }
4425 }
4426 
4427 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName, ModuleKind Type,
4428                                             SourceLocation ImportLoc,
4429                                             unsigned ClientLoadCapabilities,
4430                                             ModuleFile **NewLoadedModuleFile) {
4431   llvm::TimeTraceScope scope("ReadAST", FileName);
4432 
4433   llvm::SaveAndRestore SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
4434   llvm::SaveAndRestore<std::optional<ModuleKind>> SetCurModuleKindRAII(
4435       CurrentDeserializingModuleKind, Type);
4436 
4437   // Defer any pending actions until we get to the end of reading the AST file.
4438   Deserializing AnASTFile(this);
4439 
4440   // Bump the generation number.
4441   unsigned PreviousGeneration = 0;
4442   if (ContextObj)
4443     PreviousGeneration = incrementGeneration(*ContextObj);
4444 
4445   unsigned NumModules = ModuleMgr.size();
4446   SmallVector<ImportedModule, 4> Loaded;
4447   if (ASTReadResult ReadResult =
4448           ReadASTCore(FileName, Type, ImportLoc,
4449                       /*ImportedBy=*/nullptr, Loaded, 0, 0, ASTFileSignature(),
4450                       ClientLoadCapabilities)) {
4451     ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4452 
4453     // If we find that any modules are unusable, the global index is going
4454     // to be out-of-date. Just remove it.
4455     GlobalIndex.reset();
4456     ModuleMgr.setGlobalIndex(nullptr);
4457     return ReadResult;
4458   }
4459 
4460   if (NewLoadedModuleFile && !Loaded.empty())
4461     *NewLoadedModuleFile = Loaded.back().Mod;
4462 
4463   // Here comes stuff that we only do once the entire chain is loaded. Do *not*
4464   // remove modules from this point. Various fields are updated during reading
4465   // the AST block and removing the modules would result in dangling pointers.
4466   // They are generally only incidentally dereferenced, ie. a binary search
4467   // runs over `GlobalSLocEntryMap`, which could cause an invalid module to
4468   // be dereferenced but it wouldn't actually be used.
4469 
4470   // Load the AST blocks of all of the modules that we loaded. We can still
4471   // hit errors parsing the ASTs at this point.
4472   for (ImportedModule &M : Loaded) {
4473     ModuleFile &F = *M.Mod;
4474     llvm::TimeTraceScope Scope2("Read Loaded AST", F.ModuleName);
4475 
4476     // Read the AST block.
4477     if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4478       Error(std::move(Err));
4479       return Failure;
4480     }
4481 
4482     // The AST block should always have a definition for the main module.
4483     if (F.isModule() && !F.DidReadTopLevelSubmodule) {
4484       Error(diag::err_module_file_missing_top_level_submodule, F.FileName);
4485       return Failure;
4486     }
4487 
4488     // Read the extension blocks.
4489     while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
4490       if (llvm::Error Err = ReadExtensionBlock(F)) {
4491         Error(std::move(Err));
4492         return Failure;
4493       }
4494     }
4495 
4496     // Once read, set the ModuleFile bit base offset and update the size in
4497     // bits of all files we've seen.
4498     F.GlobalBitOffset = TotalModulesSizeInBits;
4499     TotalModulesSizeInBits += F.SizeInBits;
4500     GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
4501   }
4502 
4503   // Preload source locations and interesting indentifiers.
4504   for (ImportedModule &M : Loaded) {
4505     ModuleFile &F = *M.Mod;
4506 
4507     // Map the original source file ID into the ID space of the current
4508     // compilation.
4509     if (F.OriginalSourceFileID.isValid())
4510       F.OriginalSourceFileID = TranslateFileID(F, F.OriginalSourceFileID);
4511 
4512     for (auto Offset : F.PreloadIdentifierOffsets) {
4513       const unsigned char *Data = F.IdentifierTableData + Offset;
4514 
4515       ASTIdentifierLookupTrait Trait(*this, F);
4516       auto KeyDataLen = Trait.ReadKeyDataLength(Data);
4517       auto Key = Trait.ReadKey(Data, KeyDataLen.first);
4518 
4519       IdentifierInfo *II;
4520       if (!PP.getLangOpts().CPlusPlus) {
4521         // Identifiers present in both the module file and the importing
4522         // instance are marked out-of-date so that they can be deserialized
4523         // on next use via ASTReader::updateOutOfDateIdentifier().
4524         // Identifiers present in the module file but not in the importing
4525         // instance are ignored for now, preventing growth of the identifier
4526         // table. They will be deserialized on first use via ASTReader::get().
4527         auto It = PP.getIdentifierTable().find(Key);
4528         if (It == PP.getIdentifierTable().end())
4529           continue;
4530         II = It->second;
4531       } else {
4532         // With C++ modules, not many identifiers are considered interesting.
4533         // All identifiers in the module file can be placed into the identifier
4534         // table of the importing instance and marked as out-of-date. This makes
4535         // ASTReader::get() a no-op, and deserialization will take place on
4536         // first/next use via ASTReader::updateOutOfDateIdentifier().
4537         II = &PP.getIdentifierTable().getOwn(Key);
4538       }
4539 
4540       II->setOutOfDate(true);
4541 
4542       // Mark this identifier as being from an AST file so that we can track
4543       // whether we need to serialize it.
4544       markIdentifierFromAST(*this, *II);
4545 
4546       // Associate the ID with the identifier so that the writer can reuse it.
4547       auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
4548       SetIdentifierInfo(ID, II);
4549     }
4550   }
4551 
4552   // Builtins and library builtins have already been initialized. Mark all
4553   // identifiers as out-of-date, so that they are deserialized on first use.
4554   if (Type == MK_PCH || Type == MK_Preamble || Type == MK_MainFile)
4555     for (auto &Id : PP.getIdentifierTable())
4556       Id.second->setOutOfDate(true);
4557 
4558   // Mark selectors as out of date.
4559   for (const auto &Sel : SelectorGeneration)
4560     SelectorOutOfDate[Sel.first] = true;
4561 
4562   // Setup the import locations and notify the module manager that we've
4563   // committed to these module files.
4564   for (ImportedModule &M : Loaded) {
4565     ModuleFile &F = *M.Mod;
4566 
4567     ModuleMgr.moduleFileAccepted(&F);
4568 
4569     // Set the import location.
4570     F.DirectImportLoc = ImportLoc;
4571     // FIXME: We assume that locations from PCH / preamble do not need
4572     // any translation.
4573     if (!M.ImportedBy)
4574       F.ImportLoc = M.ImportLoc;
4575     else
4576       F.ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4577   }
4578 
4579   // Resolve any unresolved module exports.
4580   for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4581     UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4582     SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4583     Module *ResolvedMod = getSubmodule(GlobalID);
4584 
4585     switch (Unresolved.Kind) {
4586     case UnresolvedModuleRef::Conflict:
4587       if (ResolvedMod) {
4588         Module::Conflict Conflict;
4589         Conflict.Other = ResolvedMod;
4590         Conflict.Message = Unresolved.String.str();
4591         Unresolved.Mod->Conflicts.push_back(Conflict);
4592       }
4593       continue;
4594 
4595     case UnresolvedModuleRef::Import:
4596       if (ResolvedMod)
4597         Unresolved.Mod->Imports.insert(ResolvedMod);
4598       continue;
4599 
4600     case UnresolvedModuleRef::Affecting:
4601       if (ResolvedMod)
4602         Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4603       continue;
4604 
4605     case UnresolvedModuleRef::Export:
4606       if (ResolvedMod || Unresolved.IsWildcard)
4607         Unresolved.Mod->Exports.push_back(
4608           Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4609       continue;
4610     }
4611   }
4612   UnresolvedModuleRefs.clear();
4613 
4614   // FIXME: How do we load the 'use'd modules? They may not be submodules.
4615   // Might be unnecessary as use declarations are only used to build the
4616   // module itself.
4617 
4618   if (ContextObj)
4619     InitializeContext();
4620 
4621   if (SemaObj)
4622     UpdateSema();
4623 
4624   if (DeserializationListener)
4625     DeserializationListener->ReaderInitialized(this);
4626 
4627   ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4628   if (PrimaryModule.OriginalSourceFileID.isValid()) {
4629     // If this AST file is a precompiled preamble, then set the
4630     // preamble file ID of the source manager to the file source file
4631     // from which the preamble was built.
4632     if (Type == MK_Preamble) {
4633       SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4634     } else if (Type == MK_MainFile) {
4635       SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4636     }
4637   }
4638 
4639   // For any Objective-C class definitions we have already loaded, make sure
4640   // that we load any additional categories.
4641   if (ContextObj) {
4642     for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4643       loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4644                          ObjCClassesLoaded[I],
4645                          PreviousGeneration);
4646     }
4647   }
4648 
4649   HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
4650   if (HSOpts.ModulesValidateOncePerBuildSession) {
4651     // Now we are certain that the module and all modules it depends on are
4652     // up-to-date. For implicitly-built module files, ensure the corresponding
4653     // timestamp files are up-to-date in this build session.
4654     for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4655       ImportedModule &M = Loaded[I];
4656       if (M.Mod->Kind == MK_ImplicitModule &&
4657           M.Mod->InputFilesValidationTimestamp < HSOpts.BuildSessionTimestamp)
4658         updateModuleTimestamp(*M.Mod);
4659     }
4660   }
4661 
4662   return Success;
4663 }
4664 
4665 static ASTFileSignature readASTFileSignature(StringRef PCH);
4666 
4667 /// Whether \p Stream doesn't start with the AST/PCH file magic number 'CPCH'.
4668 static llvm::Error doesntStartWithASTFileMagic(BitstreamCursor &Stream) {
4669   // FIXME checking magic headers is done in other places such as
4670   // SerializedDiagnosticReader and GlobalModuleIndex, but error handling isn't
4671   // always done the same. Unify it all with a helper.
4672   if (!Stream.canSkipToPos(4))
4673     return llvm::createStringError(std::errc::illegal_byte_sequence,
4674                                    "file too small to contain AST file magic");
4675   for (unsigned C : {'C', 'P', 'C', 'H'})
4676     if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
4677       if (Res.get() != C)
4678         return llvm::createStringError(
4679             std::errc::illegal_byte_sequence,
4680             "file doesn't start with AST file magic");
4681     } else
4682       return Res.takeError();
4683   return llvm::Error::success();
4684 }
4685 
4686 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4687   switch (Kind) {
4688   case MK_PCH:
4689     return 0; // PCH
4690   case MK_ImplicitModule:
4691   case MK_ExplicitModule:
4692   case MK_PrebuiltModule:
4693     return 1; // module
4694   case MK_MainFile:
4695   case MK_Preamble:
4696     return 2; // main source file
4697   }
4698   llvm_unreachable("unknown module kind");
4699 }
4700 
4701 ASTReader::ASTReadResult
4702 ASTReader::ReadASTCore(StringRef FileName,
4703                        ModuleKind Type,
4704                        SourceLocation ImportLoc,
4705                        ModuleFile *ImportedBy,
4706                        SmallVectorImpl<ImportedModule> &Loaded,
4707                        off_t ExpectedSize, time_t ExpectedModTime,
4708                        ASTFileSignature ExpectedSignature,
4709                        unsigned ClientLoadCapabilities) {
4710   ModuleFile *M;
4711   std::string ErrorStr;
4712   ModuleManager::AddModuleResult AddResult
4713     = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4714                           getGeneration(), ExpectedSize, ExpectedModTime,
4715                           ExpectedSignature, readASTFileSignature,
4716                           M, ErrorStr);
4717 
4718   switch (AddResult) {
4719   case ModuleManager::AlreadyLoaded:
4720     Diag(diag::remark_module_import)
4721         << M->ModuleName << M->FileName << (ImportedBy ? true : false)
4722         << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
4723     return Success;
4724 
4725   case ModuleManager::NewlyLoaded:
4726     // Load module file below.
4727     break;
4728 
4729   case ModuleManager::Missing:
4730     // The module file was missing; if the client can handle that, return
4731     // it.
4732     if (ClientLoadCapabilities & ARR_Missing)
4733       return Missing;
4734 
4735     // Otherwise, return an error.
4736     Diag(diag::err_ast_file_not_found)
4737         << moduleKindForDiagnostic(Type) << FileName << !ErrorStr.empty()
4738         << ErrorStr;
4739     return Failure;
4740 
4741   case ModuleManager::OutOfDate:
4742     // We couldn't load the module file because it is out-of-date. If the
4743     // client can handle out-of-date, return it.
4744     if (ClientLoadCapabilities & ARR_OutOfDate)
4745       return OutOfDate;
4746 
4747     // Otherwise, return an error.
4748     Diag(diag::err_ast_file_out_of_date)
4749         << moduleKindForDiagnostic(Type) << FileName << !ErrorStr.empty()
4750         << ErrorStr;
4751     return Failure;
4752   }
4753 
4754   assert(M && "Missing module file");
4755 
4756   bool ShouldFinalizePCM = false;
4757   auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4758     auto &MC = getModuleManager().getModuleCache();
4759     if (ShouldFinalizePCM)
4760       MC.finalizePCM(FileName);
4761     else
4762       MC.tryToDropPCM(FileName);
4763   });
4764   ModuleFile &F = *M;
4765   BitstreamCursor &Stream = F.Stream;
4766   Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4767   F.SizeInBits = F.Buffer->getBufferSize() * 8;
4768 
4769   // Sniff for the signature.
4770   if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4771     Diag(diag::err_ast_file_invalid)
4772         << moduleKindForDiagnostic(Type) << FileName << std::move(Err);
4773     return Failure;
4774   }
4775 
4776   // This is used for compatibility with older PCH formats.
4777   bool HaveReadControlBlock = false;
4778   while (true) {
4779     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4780     if (!MaybeEntry) {
4781       Error(MaybeEntry.takeError());
4782       return Failure;
4783     }
4784     llvm::BitstreamEntry Entry = MaybeEntry.get();
4785 
4786     switch (Entry.Kind) {
4787     case llvm::BitstreamEntry::Error:
4788     case llvm::BitstreamEntry::Record:
4789     case llvm::BitstreamEntry::EndBlock:
4790       Error("invalid record at top-level of AST file");
4791       return Failure;
4792 
4793     case llvm::BitstreamEntry::SubBlock:
4794       break;
4795     }
4796 
4797     switch (Entry.ID) {
4798     case CONTROL_BLOCK_ID:
4799       HaveReadControlBlock = true;
4800       switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4801       case Success:
4802         // Check that we didn't try to load a non-module AST file as a module.
4803         //
4804         // FIXME: Should we also perform the converse check? Loading a module as
4805         // a PCH file sort of works, but it's a bit wonky.
4806         if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4807              Type == MK_PrebuiltModule) &&
4808             F.ModuleName.empty()) {
4809           auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4810           if (Result != OutOfDate ||
4811               (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4812             Diag(diag::err_module_file_not_module) << FileName;
4813           return Result;
4814         }
4815         break;
4816 
4817       case Failure: return Failure;
4818       case Missing: return Missing;
4819       case OutOfDate: return OutOfDate;
4820       case VersionMismatch: return VersionMismatch;
4821       case ConfigurationMismatch: return ConfigurationMismatch;
4822       case HadErrors: return HadErrors;
4823       }
4824       break;
4825 
4826     case AST_BLOCK_ID:
4827       if (!HaveReadControlBlock) {
4828         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4829           Diag(diag::err_pch_version_too_old);
4830         return VersionMismatch;
4831       }
4832 
4833       // Record that we've loaded this module.
4834       Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4835       ShouldFinalizePCM = true;
4836       return Success;
4837 
4838     default:
4839       if (llvm::Error Err = Stream.SkipBlock()) {
4840         Error(std::move(Err));
4841         return Failure;
4842       }
4843       break;
4844     }
4845   }
4846 
4847   llvm_unreachable("unexpected break; expected return");
4848 }
4849 
4850 ASTReader::ASTReadResult
4851 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4852                                     unsigned ClientLoadCapabilities) {
4853   const HeaderSearchOptions &HSOpts =
4854       PP.getHeaderSearchInfo().getHeaderSearchOpts();
4855   bool AllowCompatibleConfigurationMismatch =
4856       F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4857   bool DisableValidation = shouldDisableValidationForFile(F);
4858 
4859   ASTReadResult Result = readUnhashedControlBlockImpl(
4860       &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4861       Listener.get(),
4862       WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4863 
4864   // If F was directly imported by another module, it's implicitly validated by
4865   // the importing module.
4866   if (DisableValidation || WasImportedBy ||
4867       (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4868     return Success;
4869 
4870   if (Result == Failure) {
4871     Error("malformed block record in AST file");
4872     return Failure;
4873   }
4874 
4875   if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4876     // If this module has already been finalized in the ModuleCache, we're stuck
4877     // with it; we can only load a single version of each module.
4878     //
4879     // This can happen when a module is imported in two contexts: in one, as a
4880     // user module; in another, as a system module (due to an import from
4881     // another module marked with the [system] flag).  It usually indicates a
4882     // bug in the module map: this module should also be marked with [system].
4883     //
4884     // If -Wno-system-headers (the default), and the first import is as a
4885     // system module, then validation will fail during the as-user import,
4886     // since -Werror flags won't have been validated.  However, it's reasonable
4887     // to treat this consistently as a system module.
4888     //
4889     // If -Wsystem-headers, the PCM on disk was built with
4890     // -Wno-system-headers, and the first import is as a user module, then
4891     // validation will fail during the as-system import since the PCM on disk
4892     // doesn't guarantee that -Werror was respected.  However, the -Werror
4893     // flags were checked during the initial as-user import.
4894     if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {
4895       Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4896       return Success;
4897     }
4898   }
4899 
4900   return Result;
4901 }
4902 
4903 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4904     ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4905     bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4906     bool ValidateDiagnosticOptions) {
4907   // Initialize a stream.
4908   BitstreamCursor Stream(StreamData);
4909 
4910   // Sniff for the signature.
4911   if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4912     // FIXME this drops the error on the floor.
4913     consumeError(std::move(Err));
4914     return Failure;
4915   }
4916 
4917   // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4918   if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4919     return Failure;
4920 
4921   // Read all of the records in the options block.
4922   RecordData Record;
4923   ASTReadResult Result = Success;
4924   while (true) {
4925     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4926     if (!MaybeEntry) {
4927       // FIXME this drops the error on the floor.
4928       consumeError(MaybeEntry.takeError());
4929       return Failure;
4930     }
4931     llvm::BitstreamEntry Entry = MaybeEntry.get();
4932 
4933     switch (Entry.Kind) {
4934     case llvm::BitstreamEntry::Error:
4935     case llvm::BitstreamEntry::SubBlock:
4936       return Failure;
4937 
4938     case llvm::BitstreamEntry::EndBlock:
4939       return Result;
4940 
4941     case llvm::BitstreamEntry::Record:
4942       // The interesting case.
4943       break;
4944     }
4945 
4946     // Read and process a record.
4947     Record.clear();
4948     StringRef Blob;
4949     Expected<unsigned> MaybeRecordType =
4950         Stream.readRecord(Entry.ID, Record, &Blob);
4951     if (!MaybeRecordType) {
4952       // FIXME this drops the error.
4953       return Failure;
4954     }
4955     switch ((UnhashedControlBlockRecordTypes)MaybeRecordType.get()) {
4956     case SIGNATURE:
4957       if (F) {
4958         F->Signature = ASTFileSignature::create(Blob.begin(), Blob.end());
4959         assert(F->Signature != ASTFileSignature::createDummy() &&
4960                "Dummy AST file signature not backpatched in ASTWriter.");
4961       }
4962       break;
4963     case AST_BLOCK_HASH:
4964       if (F) {
4965         F->ASTBlockHash = ASTFileSignature::create(Blob.begin(), Blob.end());
4966         assert(F->ASTBlockHash != ASTFileSignature::createDummy() &&
4967                "Dummy AST block hash not backpatched in ASTWriter.");
4968       }
4969       break;
4970     case DIAGNOSTIC_OPTIONS: {
4971       bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4972       if (Listener && ValidateDiagnosticOptions &&
4973           !AllowCompatibleConfigurationMismatch &&
4974           ParseDiagnosticOptions(Record, Complain, *Listener))
4975         Result = OutOfDate; // Don't return early.  Read the signature.
4976       break;
4977     }
4978     case HEADER_SEARCH_PATHS: {
4979       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4980       if (!AllowCompatibleConfigurationMismatch &&
4981           ParseHeaderSearchPaths(Record, Complain, *Listener))
4982         Result = ConfigurationMismatch;
4983       break;
4984     }
4985     case DIAG_PRAGMA_MAPPINGS:
4986       if (!F)
4987         break;
4988       if (F->PragmaDiagMappings.empty())
4989         F->PragmaDiagMappings.swap(Record);
4990       else
4991         F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4992                                      Record.begin(), Record.end());
4993       break;
4994     case HEADER_SEARCH_ENTRY_USAGE:
4995       if (!F)
4996         break;
4997       unsigned Count = Record[0];
4998       const char *Byte = Blob.data();
4999       F->SearchPathUsage = llvm::BitVector(Count, false);
5000       for (unsigned I = 0; I < Count; ++Byte)
5001         for (unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
5002           if (*Byte & (1 << Bit))
5003             F->SearchPathUsage[I] = true;
5004       break;
5005     }
5006   }
5007 }
5008 
5009 /// Parse a record and blob containing module file extension metadata.
5010 static bool parseModuleFileExtensionMetadata(
5011               const SmallVectorImpl<uint64_t> &Record,
5012               StringRef Blob,
5013               ModuleFileExtensionMetadata &Metadata) {
5014   if (Record.size() < 4) return true;
5015 
5016   Metadata.MajorVersion = Record[0];
5017   Metadata.MinorVersion = Record[1];
5018 
5019   unsigned BlockNameLen = Record[2];
5020   unsigned UserInfoLen = Record[3];
5021 
5022   if (BlockNameLen + UserInfoLen > Blob.size()) return true;
5023 
5024   Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
5025   Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
5026                                   Blob.data() + BlockNameLen + UserInfoLen);
5027   return false;
5028 }
5029 
5030 llvm::Error ASTReader::ReadExtensionBlock(ModuleFile &F) {
5031   BitstreamCursor &Stream = F.Stream;
5032 
5033   RecordData Record;
5034   while (true) {
5035     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5036     if (!MaybeEntry)
5037       return MaybeEntry.takeError();
5038     llvm::BitstreamEntry Entry = MaybeEntry.get();
5039 
5040     switch (Entry.Kind) {
5041     case llvm::BitstreamEntry::SubBlock:
5042       if (llvm::Error Err = Stream.SkipBlock())
5043         return Err;
5044       continue;
5045     case llvm::BitstreamEntry::EndBlock:
5046       return llvm::Error::success();
5047     case llvm::BitstreamEntry::Error:
5048       return llvm::createStringError(std::errc::illegal_byte_sequence,
5049                                      "malformed block record in AST file");
5050     case llvm::BitstreamEntry::Record:
5051       break;
5052     }
5053 
5054     Record.clear();
5055     StringRef Blob;
5056     Expected<unsigned> MaybeRecCode =
5057         Stream.readRecord(Entry.ID, Record, &Blob);
5058     if (!MaybeRecCode)
5059       return MaybeRecCode.takeError();
5060     switch (MaybeRecCode.get()) {
5061     case EXTENSION_METADATA: {
5062       ModuleFileExtensionMetadata Metadata;
5063       if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
5064         return llvm::createStringError(
5065             std::errc::illegal_byte_sequence,
5066             "malformed EXTENSION_METADATA in AST file");
5067 
5068       // Find a module file extension with this block name.
5069       auto Known = ModuleFileExtensions.find(Metadata.BlockName);
5070       if (Known == ModuleFileExtensions.end()) break;
5071 
5072       // Form a reader.
5073       if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
5074                                                              F, Stream)) {
5075         F.ExtensionReaders.push_back(std::move(Reader));
5076       }
5077 
5078       break;
5079     }
5080     }
5081   }
5082 
5083   return llvm::Error::success();
5084 }
5085 
5086 void ASTReader::InitializeContext() {
5087   assert(ContextObj && "no context to initialize");
5088   ASTContext &Context = *ContextObj;
5089 
5090   // If there's a listener, notify them that we "read" the translation unit.
5091   if (DeserializationListener)
5092     DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
5093                                       Context.getTranslationUnitDecl());
5094 
5095   // FIXME: Find a better way to deal with collisions between these
5096   // built-in types. Right now, we just ignore the problem.
5097 
5098   // Load the special types.
5099   if (SpecialTypes.size() >= NumSpecialTypeIDs) {
5100     if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
5101       if (!Context.CFConstantStringTypeDecl)
5102         Context.setCFConstantStringType(GetType(String));
5103     }
5104 
5105     if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
5106       QualType FileType = GetType(File);
5107       if (FileType.isNull()) {
5108         Error("FILE type is NULL");
5109         return;
5110       }
5111 
5112       if (!Context.FILEDecl) {
5113         if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
5114           Context.setFILEDecl(Typedef->getDecl());
5115         else {
5116           const TagType *Tag = FileType->getAs<TagType>();
5117           if (!Tag) {
5118             Error("Invalid FILE type in AST file");
5119             return;
5120           }
5121           Context.setFILEDecl(Tag->getDecl());
5122         }
5123       }
5124     }
5125 
5126     if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
5127       QualType Jmp_bufType = GetType(Jmp_buf);
5128       if (Jmp_bufType.isNull()) {
5129         Error("jmp_buf type is NULL");
5130         return;
5131       }
5132 
5133       if (!Context.jmp_bufDecl) {
5134         if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
5135           Context.setjmp_bufDecl(Typedef->getDecl());
5136         else {
5137           const TagType *Tag = Jmp_bufType->getAs<TagType>();
5138           if (!Tag) {
5139             Error("Invalid jmp_buf type in AST file");
5140             return;
5141           }
5142           Context.setjmp_bufDecl(Tag->getDecl());
5143         }
5144       }
5145     }
5146 
5147     if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
5148       QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5149       if (Sigjmp_bufType.isNull()) {
5150         Error("sigjmp_buf type is NULL");
5151         return;
5152       }
5153 
5154       if (!Context.sigjmp_bufDecl) {
5155         if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
5156           Context.setsigjmp_bufDecl(Typedef->getDecl());
5157         else {
5158           const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
5159           assert(Tag && "Invalid sigjmp_buf type in AST file");
5160           Context.setsigjmp_bufDecl(Tag->getDecl());
5161         }
5162       }
5163     }
5164 
5165     if (unsigned ObjCIdRedef
5166           = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
5167       if (Context.ObjCIdRedefinitionType.isNull())
5168         Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5169     }
5170 
5171     if (unsigned ObjCClassRedef
5172           = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
5173       if (Context.ObjCClassRedefinitionType.isNull())
5174         Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5175     }
5176 
5177     if (unsigned ObjCSelRedef
5178           = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
5179       if (Context.ObjCSelRedefinitionType.isNull())
5180         Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5181     }
5182 
5183     if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
5184       QualType Ucontext_tType = GetType(Ucontext_t);
5185       if (Ucontext_tType.isNull()) {
5186         Error("ucontext_t type is NULL");
5187         return;
5188       }
5189 
5190       if (!Context.ucontext_tDecl) {
5191         if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
5192           Context.setucontext_tDecl(Typedef->getDecl());
5193         else {
5194           const TagType *Tag = Ucontext_tType->getAs<TagType>();
5195           assert(Tag && "Invalid ucontext_t type in AST file");
5196           Context.setucontext_tDecl(Tag->getDecl());
5197         }
5198       }
5199     }
5200   }
5201 
5202   ReadPragmaDiagnosticMappings(Context.getDiagnostics());
5203 
5204   // If there were any CUDA special declarations, deserialize them.
5205   if (!CUDASpecialDeclRefs.empty()) {
5206     assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
5207     Context.setcudaConfigureCallDecl(
5208                            cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5209   }
5210 
5211   // Re-export any modules that were imported by a non-module AST file.
5212   // FIXME: This does not make macro-only imports visible again.
5213   for (auto &Import : PendingImportedModules) {
5214     if (Module *Imported = getSubmodule(Import.ID)) {
5215       makeModuleVisible(Imported, Module::AllVisible,
5216                         /*ImportLoc=*/Import.ImportLoc);
5217       if (Import.ImportLoc.isValid())
5218         PP.makeModuleVisible(Imported, Import.ImportLoc);
5219       // This updates visibility for Preprocessor only. For Sema, which can be
5220       // nullptr here, we do the same later, in UpdateSema().
5221     }
5222   }
5223 
5224   // Hand off these modules to Sema.
5225   PendingImportedModulesSema.append(PendingImportedModules);
5226   PendingImportedModules.clear();
5227 }
5228 
5229 void ASTReader::finalizeForWriting() {
5230   // Nothing to do for now.
5231 }
5232 
5233 /// Reads and return the signature record from \p PCH's control block, or
5234 /// else returns 0.
5235 static ASTFileSignature readASTFileSignature(StringRef PCH) {
5236   BitstreamCursor Stream(PCH);
5237   if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5238     // FIXME this drops the error on the floor.
5239     consumeError(std::move(Err));
5240     return ASTFileSignature();
5241   }
5242 
5243   // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5244   if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
5245     return ASTFileSignature();
5246 
5247   // Scan for SIGNATURE inside the diagnostic options block.
5248   ASTReader::RecordData Record;
5249   while (true) {
5250     Expected<llvm::BitstreamEntry> MaybeEntry =
5251         Stream.advanceSkippingSubblocks();
5252     if (!MaybeEntry) {
5253       // FIXME this drops the error on the floor.
5254       consumeError(MaybeEntry.takeError());
5255       return ASTFileSignature();
5256     }
5257     llvm::BitstreamEntry Entry = MaybeEntry.get();
5258 
5259     if (Entry.Kind != llvm::BitstreamEntry::Record)
5260       return ASTFileSignature();
5261 
5262     Record.clear();
5263     StringRef Blob;
5264     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5265     if (!MaybeRecord) {
5266       // FIXME this drops the error on the floor.
5267       consumeError(MaybeRecord.takeError());
5268       return ASTFileSignature();
5269     }
5270     if (SIGNATURE == MaybeRecord.get()) {
5271       auto Signature = ASTFileSignature::create(Blob.begin(), Blob.end());
5272       assert(Signature != ASTFileSignature::createDummy() &&
5273              "Dummy AST file signature not backpatched in ASTWriter.");
5274       return Signature;
5275     }
5276   }
5277 }
5278 
5279 /// Retrieve the name of the original source file name
5280 /// directly from the AST file, without actually loading the AST
5281 /// file.
5282 std::string ASTReader::getOriginalSourceFile(
5283     const std::string &ASTFileName, FileManager &FileMgr,
5284     const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
5285   // Open the AST file.
5286   auto Buffer = FileMgr.getBufferForFile(ASTFileName, /*IsVolatile=*/false,
5287                                          /*RequiresNullTerminator=*/false);
5288   if (!Buffer) {
5289     Diags.Report(diag::err_fe_unable_to_read_pch_file)
5290         << ASTFileName << Buffer.getError().message();
5291     return std::string();
5292   }
5293 
5294   // Initialize the stream
5295   BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
5296 
5297   // Sniff for the signature.
5298   if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5299     Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5300     return std::string();
5301   }
5302 
5303   // Scan for the CONTROL_BLOCK_ID block.
5304   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
5305     Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5306     return std::string();
5307   }
5308 
5309   // Scan for ORIGINAL_FILE inside the control block.
5310   RecordData Record;
5311   while (true) {
5312     Expected<llvm::BitstreamEntry> MaybeEntry =
5313         Stream.advanceSkippingSubblocks();
5314     if (!MaybeEntry) {
5315       // FIXME this drops errors on the floor.
5316       consumeError(MaybeEntry.takeError());
5317       return std::string();
5318     }
5319     llvm::BitstreamEntry Entry = MaybeEntry.get();
5320 
5321     if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5322       return std::string();
5323 
5324     if (Entry.Kind != llvm::BitstreamEntry::Record) {
5325       Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5326       return std::string();
5327     }
5328 
5329     Record.clear();
5330     StringRef Blob;
5331     Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5332     if (!MaybeRecord) {
5333       // FIXME this drops the errors on the floor.
5334       consumeError(MaybeRecord.takeError());
5335       return std::string();
5336     }
5337     if (ORIGINAL_FILE == MaybeRecord.get())
5338       return Blob.str();
5339   }
5340 }
5341 
5342 namespace {
5343 
5344   class SimplePCHValidator : public ASTReaderListener {
5345     const LangOptions &ExistingLangOpts;
5346     const TargetOptions &ExistingTargetOpts;
5347     const PreprocessorOptions &ExistingPPOpts;
5348     std::string ExistingModuleCachePath;
5349     FileManager &FileMgr;
5350     bool StrictOptionMatches;
5351 
5352   public:
5353     SimplePCHValidator(const LangOptions &ExistingLangOpts,
5354                        const TargetOptions &ExistingTargetOpts,
5355                        const PreprocessorOptions &ExistingPPOpts,
5356                        StringRef ExistingModuleCachePath, FileManager &FileMgr,
5357                        bool StrictOptionMatches)
5358         : ExistingLangOpts(ExistingLangOpts),
5359           ExistingTargetOpts(ExistingTargetOpts),
5360           ExistingPPOpts(ExistingPPOpts),
5361           ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5362           StrictOptionMatches(StrictOptionMatches) {}
5363 
5364     bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
5365                              bool AllowCompatibleDifferences) override {
5366       return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
5367                                   AllowCompatibleDifferences);
5368     }
5369 
5370     bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
5371                            bool AllowCompatibleDifferences) override {
5372       return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
5373                                 AllowCompatibleDifferences);
5374     }
5375 
5376     bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
5377                                  StringRef SpecificModuleCachePath,
5378                                  bool Complain) override {
5379       return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5380                                       ExistingModuleCachePath, nullptr,
5381                                       ExistingLangOpts, ExistingPPOpts);
5382     }
5383 
5384     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
5385                                  bool ReadMacros, bool Complain,
5386                                  std::string &SuggestedPredefines) override {
5387       return checkPreprocessorOptions(
5388           PPOpts, ExistingPPOpts, ReadMacros, /*Diags=*/nullptr, FileMgr,
5389           SuggestedPredefines, ExistingLangOpts,
5390           StrictOptionMatches ? OptionValidateStrictMatches
5391                               : OptionValidateContradictions);
5392     }
5393   };
5394 
5395 } // namespace
5396 
5397 bool ASTReader::readASTFileControlBlock(
5398     StringRef Filename, FileManager &FileMgr,
5399     const InMemoryModuleCache &ModuleCache,
5400     const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions,
5401     ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
5402   // Open the AST file.
5403   std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5404   llvm::MemoryBuffer *Buffer = ModuleCache.lookupPCM(Filename);
5405   if (!Buffer) {
5406     // FIXME: We should add the pcm to the InMemoryModuleCache if it could be
5407     // read again later, but we do not have the context here to determine if it
5408     // is safe to change the result of InMemoryModuleCache::getPCMState().
5409 
5410     // FIXME: This allows use of the VFS; we do not allow use of the
5411     // VFS when actually loading a module.
5412     auto BufferOrErr = FileMgr.getBufferForFile(Filename);
5413     if (!BufferOrErr)
5414       return true;
5415     OwnedBuffer = std::move(*BufferOrErr);
5416     Buffer = OwnedBuffer.get();
5417   }
5418 
5419   // Initialize the stream
5420   StringRef Bytes = PCHContainerRdr.ExtractPCH(*Buffer);
5421   BitstreamCursor Stream(Bytes);
5422 
5423   // Sniff for the signature.
5424   if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5425     consumeError(std::move(Err)); // FIXME this drops errors on the floor.
5426     return true;
5427   }
5428 
5429   // Scan for the CONTROL_BLOCK_ID block.
5430   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
5431     return true;
5432 
5433   bool NeedsInputFiles = Listener.needsInputFileVisitation();
5434   bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
5435   bool NeedsImports = Listener.needsImportVisitation();
5436   BitstreamCursor InputFilesCursor;
5437   uint64_t InputFilesOffsetBase = 0;
5438 
5439   RecordData Record;
5440   std::string ModuleDir;
5441   bool DoneWithControlBlock = false;
5442   while (!DoneWithControlBlock) {
5443     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5444     if (!MaybeEntry) {
5445       // FIXME this drops the error on the floor.
5446       consumeError(MaybeEntry.takeError());
5447       return true;
5448     }
5449     llvm::BitstreamEntry Entry = MaybeEntry.get();
5450 
5451     switch (Entry.Kind) {
5452     case llvm::BitstreamEntry::SubBlock: {
5453       switch (Entry.ID) {
5454       case OPTIONS_BLOCK_ID: {
5455         std::string IgnoredSuggestedPredefines;
5456         if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
5457                              /*AllowCompatibleConfigurationMismatch*/ false,
5458                              Listener, IgnoredSuggestedPredefines) != Success)
5459           return true;
5460         break;
5461       }
5462 
5463       case INPUT_FILES_BLOCK_ID:
5464         InputFilesCursor = Stream;
5465         if (llvm::Error Err = Stream.SkipBlock()) {
5466           // FIXME this drops the error on the floor.
5467           consumeError(std::move(Err));
5468           return true;
5469         }
5470         if (NeedsInputFiles &&
5471             ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID))
5472           return true;
5473         InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5474         break;
5475 
5476       default:
5477         if (llvm::Error Err = Stream.SkipBlock()) {
5478           // FIXME this drops the error on the floor.
5479           consumeError(std::move(Err));
5480           return true;
5481         }
5482         break;
5483       }
5484 
5485       continue;
5486     }
5487 
5488     case llvm::BitstreamEntry::EndBlock:
5489       DoneWithControlBlock = true;
5490       break;
5491 
5492     case llvm::BitstreamEntry::Error:
5493       return true;
5494 
5495     case llvm::BitstreamEntry::Record:
5496       break;
5497     }
5498 
5499     if (DoneWithControlBlock) break;
5500 
5501     Record.clear();
5502     StringRef Blob;
5503     Expected<unsigned> MaybeRecCode =
5504         Stream.readRecord(Entry.ID, Record, &Blob);
5505     if (!MaybeRecCode) {
5506       // FIXME this drops the error.
5507       return Failure;
5508     }
5509     switch ((ControlRecordTypes)MaybeRecCode.get()) {
5510     case METADATA:
5511       if (Record[0] != VERSION_MAJOR)
5512         return true;
5513       if (Listener.ReadFullVersionInformation(Blob))
5514         return true;
5515       break;
5516     case MODULE_NAME:
5517       Listener.ReadModuleName(Blob);
5518       break;
5519     case MODULE_DIRECTORY:
5520       ModuleDir = std::string(Blob);
5521       break;
5522     case MODULE_MAP_FILE: {
5523       unsigned Idx = 0;
5524       auto Path = ReadString(Record, Idx);
5525       ResolveImportedPath(Path, ModuleDir);
5526       Listener.ReadModuleMapFile(Path);
5527       break;
5528     }
5529     case INPUT_FILE_OFFSETS: {
5530       if (!NeedsInputFiles)
5531         break;
5532 
5533       unsigned NumInputFiles = Record[0];
5534       unsigned NumUserFiles = Record[1];
5535       const llvm::support::unaligned_uint64_t *InputFileOffs =
5536           (const llvm::support::unaligned_uint64_t *)Blob.data();
5537       for (unsigned I = 0; I != NumInputFiles; ++I) {
5538         // Go find this input file.
5539         bool isSystemFile = I >= NumUserFiles;
5540 
5541         if (isSystemFile && !NeedsSystemInputFiles)
5542           break; // the rest are system input files
5543 
5544         BitstreamCursor &Cursor = InputFilesCursor;
5545         SavedStreamPosition SavedPosition(Cursor);
5546         if (llvm::Error Err =
5547                 Cursor.JumpToBit(InputFilesOffsetBase + InputFileOffs[I])) {
5548           // FIXME this drops errors on the floor.
5549           consumeError(std::move(Err));
5550         }
5551 
5552         Expected<unsigned> MaybeCode = Cursor.ReadCode();
5553         if (!MaybeCode) {
5554           // FIXME this drops errors on the floor.
5555           consumeError(MaybeCode.takeError());
5556         }
5557         unsigned Code = MaybeCode.get();
5558 
5559         RecordData Record;
5560         StringRef Blob;
5561         bool shouldContinue = false;
5562         Expected<unsigned> MaybeRecordType =
5563             Cursor.readRecord(Code, Record, &Blob);
5564         if (!MaybeRecordType) {
5565           // FIXME this drops errors on the floor.
5566           consumeError(MaybeRecordType.takeError());
5567         }
5568         switch ((InputFileRecordTypes)MaybeRecordType.get()) {
5569         case INPUT_FILE_HASH:
5570           break;
5571         case INPUT_FILE:
5572           bool Overridden = static_cast<bool>(Record[3]);
5573           std::string Filename = std::string(Blob);
5574           ResolveImportedPath(Filename, ModuleDir);
5575           shouldContinue = Listener.visitInputFile(
5576               Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
5577           break;
5578         }
5579         if (!shouldContinue)
5580           break;
5581       }
5582       break;
5583     }
5584 
5585     case IMPORTS: {
5586       if (!NeedsImports)
5587         break;
5588 
5589       unsigned Idx = 0, N = Record.size();
5590       while (Idx < N) {
5591         // Read information about the AST file.
5592 
5593         // Skip Kind
5594         Idx++;
5595         bool IsStandardCXXModule = Record[Idx++];
5596 
5597         // Skip ImportLoc
5598         Idx++;
5599 
5600         // In C++20 Modules, we don't record the path to imported
5601         // modules in the BMI files.
5602         if (IsStandardCXXModule) {
5603           std::string ModuleName = ReadString(Record, Idx);
5604           Listener.visitImport(ModuleName, /*Filename=*/"");
5605           continue;
5606         }
5607 
5608         // Skip Size, ModTime and Signature
5609         Idx += 1 + 1 + ASTFileSignature::size;
5610         std::string ModuleName = ReadString(Record, Idx);
5611         std::string Filename = ReadString(Record, Idx);
5612         ResolveImportedPath(Filename, ModuleDir);
5613         Listener.visitImport(ModuleName, Filename);
5614       }
5615       break;
5616     }
5617 
5618     default:
5619       // No other validation to perform.
5620       break;
5621     }
5622   }
5623 
5624   // Look for module file extension blocks, if requested.
5625   if (FindModuleFileExtensions) {
5626     BitstreamCursor SavedStream = Stream;
5627     while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
5628       bool DoneWithExtensionBlock = false;
5629       while (!DoneWithExtensionBlock) {
5630         Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5631         if (!MaybeEntry) {
5632           // FIXME this drops the error.
5633           return true;
5634         }
5635         llvm::BitstreamEntry Entry = MaybeEntry.get();
5636 
5637         switch (Entry.Kind) {
5638         case llvm::BitstreamEntry::SubBlock:
5639           if (llvm::Error Err = Stream.SkipBlock()) {
5640             // FIXME this drops the error on the floor.
5641             consumeError(std::move(Err));
5642             return true;
5643           }
5644           continue;
5645 
5646         case llvm::BitstreamEntry::EndBlock:
5647           DoneWithExtensionBlock = true;
5648           continue;
5649 
5650         case llvm::BitstreamEntry::Error:
5651           return true;
5652 
5653         case llvm::BitstreamEntry::Record:
5654           break;
5655         }
5656 
5657        Record.clear();
5658        StringRef Blob;
5659        Expected<unsigned> MaybeRecCode =
5660            Stream.readRecord(Entry.ID, Record, &Blob);
5661        if (!MaybeRecCode) {
5662          // FIXME this drops the error.
5663          return true;
5664        }
5665        switch (MaybeRecCode.get()) {
5666        case EXTENSION_METADATA: {
5667          ModuleFileExtensionMetadata Metadata;
5668          if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
5669            return true;
5670 
5671          Listener.readModuleFileExtension(Metadata);
5672          break;
5673        }
5674        }
5675       }
5676     }
5677     Stream = SavedStream;
5678   }
5679 
5680   // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5681   if (readUnhashedControlBlockImpl(
5682           nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
5683           /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
5684           ValidateDiagnosticOptions) != Success)
5685     return true;
5686 
5687   return false;
5688 }
5689 
5690 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
5691                                     const InMemoryModuleCache &ModuleCache,
5692                                     const PCHContainerReader &PCHContainerRdr,
5693                                     const LangOptions &LangOpts,
5694                                     const TargetOptions &TargetOpts,
5695                                     const PreprocessorOptions &PPOpts,
5696                                     StringRef ExistingModuleCachePath,
5697                                     bool RequireStrictOptionMatches) {
5698   SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5699                                ExistingModuleCachePath, FileMgr,
5700                                RequireStrictOptionMatches);
5701   return !readASTFileControlBlock(Filename, FileMgr, ModuleCache,
5702                                   PCHContainerRdr,
5703                                   /*FindModuleFileExtensions=*/false, validator,
5704                                   /*ValidateDiagnosticOptions=*/true);
5705 }
5706 
5707 llvm::Error ASTReader::ReadSubmoduleBlock(ModuleFile &F,
5708                                           unsigned ClientLoadCapabilities) {
5709   // Enter the submodule block.
5710   if (llvm::Error Err = F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID))
5711     return Err;
5712 
5713   ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5714   bool First = true;
5715   Module *CurrentModule = nullptr;
5716   RecordData Record;
5717   while (true) {
5718     Expected<llvm::BitstreamEntry> MaybeEntry =
5719         F.Stream.advanceSkippingSubblocks();
5720     if (!MaybeEntry)
5721       return MaybeEntry.takeError();
5722     llvm::BitstreamEntry Entry = MaybeEntry.get();
5723 
5724     switch (Entry.Kind) {
5725     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
5726     case llvm::BitstreamEntry::Error:
5727       return llvm::createStringError(std::errc::illegal_byte_sequence,
5728                                      "malformed block record in AST file");
5729     case llvm::BitstreamEntry::EndBlock:
5730       return llvm::Error::success();
5731     case llvm::BitstreamEntry::Record:
5732       // The interesting case.
5733       break;
5734     }
5735 
5736     // Read a record.
5737     StringRef Blob;
5738     Record.clear();
5739     Expected<unsigned> MaybeKind = F.Stream.readRecord(Entry.ID, Record, &Blob);
5740     if (!MaybeKind)
5741       return MaybeKind.takeError();
5742     unsigned Kind = MaybeKind.get();
5743 
5744     if ((Kind == SUBMODULE_METADATA) != First)
5745       return llvm::createStringError(
5746           std::errc::illegal_byte_sequence,
5747           "submodule metadata record should be at beginning of block");
5748     First = false;
5749 
5750     // Submodule information is only valid if we have a current module.
5751     // FIXME: Should we error on these cases?
5752     if (!CurrentModule && Kind != SUBMODULE_METADATA &&
5753         Kind != SUBMODULE_DEFINITION)
5754       continue;
5755 
5756     switch (Kind) {
5757     default:  // Default behavior: ignore.
5758       break;
5759 
5760     case SUBMODULE_DEFINITION: {
5761       if (Record.size() < 13)
5762         return llvm::createStringError(std::errc::illegal_byte_sequence,
5763                                        "malformed module definition");
5764 
5765       StringRef Name = Blob;
5766       unsigned Idx = 0;
5767       SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5768       SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5769       Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5770       SourceLocation DefinitionLoc = ReadSourceLocation(F, Record[Idx++]);
5771       bool IsFramework = Record[Idx++];
5772       bool IsExplicit = Record[Idx++];
5773       bool IsSystem = Record[Idx++];
5774       bool IsExternC = Record[Idx++];
5775       bool InferSubmodules = Record[Idx++];
5776       bool InferExplicitSubmodules = Record[Idx++];
5777       bool InferExportWildcard = Record[Idx++];
5778       bool ConfigMacrosExhaustive = Record[Idx++];
5779       bool ModuleMapIsPrivate = Record[Idx++];
5780       bool NamedModuleHasInit = Record[Idx++];
5781 
5782       Module *ParentModule = nullptr;
5783       if (Parent)
5784         ParentModule = getSubmodule(Parent);
5785 
5786       // Retrieve this (sub)module from the module map, creating it if
5787       // necessary.
5788       CurrentModule =
5789           ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5790               .first;
5791 
5792       // FIXME: Call ModMap.setInferredModuleAllowedBy()
5793 
5794       SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5795       if (GlobalIndex >= SubmodulesLoaded.size() ||
5796           SubmodulesLoaded[GlobalIndex])
5797         return llvm::createStringError(std::errc::invalid_argument,
5798                                        "too many submodules");
5799 
5800       if (!ParentModule) {
5801         if (OptionalFileEntryRef CurFile = CurrentModule->getASTFile()) {
5802           // Don't emit module relocation error if we have -fno-validate-pch
5803           if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5804                     DisableValidationForModuleKind::Module) &&
5805               CurFile != F.File) {
5806             auto ConflictError =
5807                 PartialDiagnostic(diag::err_module_file_conflict,
5808                                   ContextObj->DiagAllocator)
5809                 << CurrentModule->getTopLevelModuleName() << CurFile->getName()
5810                 << F.File.getName();
5811             return DiagnosticError::create(CurrentImportLoc, ConflictError);
5812           }
5813         }
5814 
5815         F.DidReadTopLevelSubmodule = true;
5816         CurrentModule->setASTFile(F.File);
5817         CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5818       }
5819 
5820       CurrentModule->Kind = Kind;
5821       CurrentModule->DefinitionLoc = DefinitionLoc;
5822       CurrentModule->Signature = F.Signature;
5823       CurrentModule->IsFromModuleFile = true;
5824       CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5825       CurrentModule->IsExternC = IsExternC;
5826       CurrentModule->InferSubmodules = InferSubmodules;
5827       CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5828       CurrentModule->InferExportWildcard = InferExportWildcard;
5829       CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5830       CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5831       CurrentModule->NamedModuleHasInit = NamedModuleHasInit;
5832       if (DeserializationListener)
5833         DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5834 
5835       SubmodulesLoaded[GlobalIndex] = CurrentModule;
5836 
5837       // Clear out data that will be replaced by what is in the module file.
5838       CurrentModule->LinkLibraries.clear();
5839       CurrentModule->ConfigMacros.clear();
5840       CurrentModule->UnresolvedConflicts.clear();
5841       CurrentModule->Conflicts.clear();
5842 
5843       // The module is available unless it's missing a requirement; relevant
5844       // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5845       // Missing headers that were present when the module was built do not
5846       // make it unavailable -- if we got this far, this must be an explicitly
5847       // imported module file.
5848       CurrentModule->Requirements.clear();
5849       CurrentModule->MissingHeaders.clear();
5850       CurrentModule->IsUnimportable =
5851           ParentModule && ParentModule->IsUnimportable;
5852       CurrentModule->IsAvailable = !CurrentModule->IsUnimportable;
5853       break;
5854     }
5855 
5856     case SUBMODULE_UMBRELLA_HEADER: {
5857       // FIXME: This doesn't work for framework modules as `Filename` is the
5858       //        name as written in the module file and does not include
5859       //        `Headers/`, so this path will never exist.
5860       std::string Filename = std::string(Blob);
5861       ResolveImportedPath(F, Filename);
5862       if (auto Umbrella = PP.getFileManager().getOptionalFileRef(Filename)) {
5863         if (!CurrentModule->getUmbrellaHeaderAsWritten()) {
5864           // FIXME: NameAsWritten
5865           ModMap.setUmbrellaHeaderAsWritten(CurrentModule, *Umbrella, Blob, "");
5866         }
5867         // Note that it's too late at this point to return out of date if the
5868         // name from the PCM doesn't match up with the one in the module map,
5869         // but also quite unlikely since we will have already checked the
5870         // modification time and size of the module map file itself.
5871       }
5872       break;
5873     }
5874 
5875     case SUBMODULE_HEADER:
5876     case SUBMODULE_EXCLUDED_HEADER:
5877     case SUBMODULE_PRIVATE_HEADER:
5878       // We lazily associate headers with their modules via the HeaderInfo table.
5879       // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5880       // of complete filenames or remove it entirely.
5881       break;
5882 
5883     case SUBMODULE_TEXTUAL_HEADER:
5884     case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5885       // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5886       // them here.
5887       break;
5888 
5889     case SUBMODULE_TOPHEADER: {
5890       std::string HeaderName(Blob);
5891       ResolveImportedPath(F, HeaderName);
5892       CurrentModule->addTopHeaderFilename(HeaderName);
5893       break;
5894     }
5895 
5896     case SUBMODULE_UMBRELLA_DIR: {
5897       // See comments in SUBMODULE_UMBRELLA_HEADER
5898       std::string Dirname = std::string(Blob);
5899       ResolveImportedPath(F, Dirname);
5900       if (auto Umbrella =
5901               PP.getFileManager().getOptionalDirectoryRef(Dirname)) {
5902         if (!CurrentModule->getUmbrellaDirAsWritten()) {
5903           // FIXME: NameAsWritten
5904           ModMap.setUmbrellaDirAsWritten(CurrentModule, *Umbrella, Blob, "");
5905         }
5906       }
5907       break;
5908     }
5909 
5910     case SUBMODULE_METADATA: {
5911       F.BaseSubmoduleID = getTotalNumSubmodules();
5912       F.LocalNumSubmodules = Record[0];
5913       unsigned LocalBaseSubmoduleID = Record[1];
5914       if (F.LocalNumSubmodules > 0) {
5915         // Introduce the global -> local mapping for submodules within this
5916         // module.
5917         GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5918 
5919         // Introduce the local -> global mapping for submodules within this
5920         // module.
5921         F.SubmoduleRemap.insertOrReplace(
5922           std::make_pair(LocalBaseSubmoduleID,
5923                          F.BaseSubmoduleID - LocalBaseSubmoduleID));
5924 
5925         SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5926       }
5927       break;
5928     }
5929 
5930     case SUBMODULE_IMPORTS:
5931       for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5932         UnresolvedModuleRef Unresolved;
5933         Unresolved.File = &F;
5934         Unresolved.Mod = CurrentModule;
5935         Unresolved.ID = Record[Idx];
5936         Unresolved.Kind = UnresolvedModuleRef::Import;
5937         Unresolved.IsWildcard = false;
5938         UnresolvedModuleRefs.push_back(Unresolved);
5939       }
5940       break;
5941 
5942     case SUBMODULE_AFFECTING_MODULES:
5943       for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5944         UnresolvedModuleRef Unresolved;
5945         Unresolved.File = &F;
5946         Unresolved.Mod = CurrentModule;
5947         Unresolved.ID = Record[Idx];
5948         Unresolved.Kind = UnresolvedModuleRef::Affecting;
5949         Unresolved.IsWildcard = false;
5950         UnresolvedModuleRefs.push_back(Unresolved);
5951       }
5952       break;
5953 
5954     case SUBMODULE_EXPORTS:
5955       for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5956         UnresolvedModuleRef Unresolved;
5957         Unresolved.File = &F;
5958         Unresolved.Mod = CurrentModule;
5959         Unresolved.ID = Record[Idx];
5960         Unresolved.Kind = UnresolvedModuleRef::Export;
5961         Unresolved.IsWildcard = Record[Idx + 1];
5962         UnresolvedModuleRefs.push_back(Unresolved);
5963       }
5964 
5965       // Once we've loaded the set of exports, there's no reason to keep
5966       // the parsed, unresolved exports around.
5967       CurrentModule->UnresolvedExports.clear();
5968       break;
5969 
5970     case SUBMODULE_REQUIRES:
5971       CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5972                                     PP.getTargetInfo());
5973       break;
5974 
5975     case SUBMODULE_LINK_LIBRARY:
5976       ModMap.resolveLinkAsDependencies(CurrentModule);
5977       CurrentModule->LinkLibraries.push_back(
5978           Module::LinkLibrary(std::string(Blob), Record[0]));
5979       break;
5980 
5981     case SUBMODULE_CONFIG_MACRO:
5982       CurrentModule->ConfigMacros.push_back(Blob.str());
5983       break;
5984 
5985     case SUBMODULE_CONFLICT: {
5986       UnresolvedModuleRef Unresolved;
5987       Unresolved.File = &F;
5988       Unresolved.Mod = CurrentModule;
5989       Unresolved.ID = Record[0];
5990       Unresolved.Kind = UnresolvedModuleRef::Conflict;
5991       Unresolved.IsWildcard = false;
5992       Unresolved.String = Blob;
5993       UnresolvedModuleRefs.push_back(Unresolved);
5994       break;
5995     }
5996 
5997     case SUBMODULE_INITIALIZERS: {
5998       if (!ContextObj)
5999         break;
6000       SmallVector<uint32_t, 16> Inits;
6001       for (auto &ID : Record)
6002         Inits.push_back(getGlobalDeclID(F, ID));
6003       ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
6004       break;
6005     }
6006 
6007     case SUBMODULE_EXPORT_AS:
6008       CurrentModule->ExportAsModule = Blob.str();
6009       ModMap.addLinkAsDependency(CurrentModule);
6010       break;
6011     }
6012   }
6013 }
6014 
6015 /// Parse the record that corresponds to a LangOptions data
6016 /// structure.
6017 ///
6018 /// This routine parses the language options from the AST file and then gives
6019 /// them to the AST listener if one is set.
6020 ///
6021 /// \returns true if the listener deems the file unacceptable, false otherwise.
6022 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
6023                                      bool Complain,
6024                                      ASTReaderListener &Listener,
6025                                      bool AllowCompatibleDifferences) {
6026   LangOptions LangOpts;
6027   unsigned Idx = 0;
6028 #define LANGOPT(Name, Bits, Default, Description) \
6029   LangOpts.Name = Record[Idx++];
6030 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
6031   LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
6032 #include "clang/Basic/LangOptions.def"
6033 #define SANITIZER(NAME, ID)                                                    \
6034   LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
6035 #include "clang/Basic/Sanitizers.def"
6036 
6037   for (unsigned N = Record[Idx++]; N; --N)
6038     LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
6039 
6040   ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
6041   VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
6042   LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
6043 
6044   LangOpts.CurrentModule = ReadString(Record, Idx);
6045 
6046   // Comment options.
6047   for (unsigned N = Record[Idx++]; N; --N) {
6048     LangOpts.CommentOpts.BlockCommandNames.push_back(
6049       ReadString(Record, Idx));
6050   }
6051   LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
6052 
6053   // OpenMP offloading options.
6054   for (unsigned N = Record[Idx++]; N; --N) {
6055     LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
6056   }
6057 
6058   LangOpts.OMPHostIRFile = ReadString(Record, Idx);
6059 
6060   return Listener.ReadLanguageOptions(LangOpts, Complain,
6061                                       AllowCompatibleDifferences);
6062 }
6063 
6064 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
6065                                    ASTReaderListener &Listener,
6066                                    bool AllowCompatibleDifferences) {
6067   unsigned Idx = 0;
6068   TargetOptions TargetOpts;
6069   TargetOpts.Triple = ReadString(Record, Idx);
6070   TargetOpts.CPU = ReadString(Record, Idx);
6071   TargetOpts.TuneCPU = ReadString(Record, Idx);
6072   TargetOpts.ABI = ReadString(Record, Idx);
6073   for (unsigned N = Record[Idx++]; N; --N) {
6074     TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
6075   }
6076   for (unsigned N = Record[Idx++]; N; --N) {
6077     TargetOpts.Features.push_back(ReadString(Record, Idx));
6078   }
6079 
6080   return Listener.ReadTargetOptions(TargetOpts, Complain,
6081                                     AllowCompatibleDifferences);
6082 }
6083 
6084 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
6085                                        ASTReaderListener &Listener) {
6086   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
6087   unsigned Idx = 0;
6088 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
6089 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
6090   DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
6091 #include "clang/Basic/DiagnosticOptions.def"
6092 
6093   for (unsigned N = Record[Idx++]; N; --N)
6094     DiagOpts->Warnings.push_back(ReadString(Record, Idx));
6095   for (unsigned N = Record[Idx++]; N; --N)
6096     DiagOpts->Remarks.push_back(ReadString(Record, Idx));
6097 
6098   return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
6099 }
6100 
6101 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
6102                                        ASTReaderListener &Listener) {
6103   FileSystemOptions FSOpts;
6104   unsigned Idx = 0;
6105   FSOpts.WorkingDir = ReadString(Record, Idx);
6106   return Listener.ReadFileSystemOptions(FSOpts, Complain);
6107 }
6108 
6109 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
6110                                          bool Complain,
6111                                          ASTReaderListener &Listener) {
6112   HeaderSearchOptions HSOpts;
6113   unsigned Idx = 0;
6114   HSOpts.Sysroot = ReadString(Record, Idx);
6115 
6116   HSOpts.ResourceDir = ReadString(Record, Idx);
6117   HSOpts.ModuleCachePath = ReadString(Record, Idx);
6118   HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
6119   HSOpts.DisableModuleHash = Record[Idx++];
6120   HSOpts.ImplicitModuleMaps = Record[Idx++];
6121   HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
6122   HSOpts.EnablePrebuiltImplicitModules = Record[Idx++];
6123   HSOpts.UseBuiltinIncludes = Record[Idx++];
6124   HSOpts.UseStandardSystemIncludes = Record[Idx++];
6125   HSOpts.UseStandardCXXIncludes = Record[Idx++];
6126   HSOpts.UseLibcxx = Record[Idx++];
6127   std::string SpecificModuleCachePath = ReadString(Record, Idx);
6128 
6129   return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
6130                                           Complain);
6131 }
6132 
6133 bool ASTReader::ParseHeaderSearchPaths(const RecordData &Record, bool Complain,
6134                                        ASTReaderListener &Listener) {
6135   HeaderSearchOptions HSOpts;
6136   unsigned Idx = 0;
6137 
6138   // Include entries.
6139   for (unsigned N = Record[Idx++]; N; --N) {
6140     std::string Path = ReadString(Record, Idx);
6141     frontend::IncludeDirGroup Group
6142       = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
6143     bool IsFramework = Record[Idx++];
6144     bool IgnoreSysRoot = Record[Idx++];
6145     HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
6146                                     IgnoreSysRoot);
6147   }
6148 
6149   // System header prefixes.
6150   for (unsigned N = Record[Idx++]; N; --N) {
6151     std::string Prefix = ReadString(Record, Idx);
6152     bool IsSystemHeader = Record[Idx++];
6153     HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
6154   }
6155 
6156   // VFS overlay files.
6157   for (unsigned N = Record[Idx++]; N; --N) {
6158     std::string VFSOverlayFile = ReadString(Record, Idx);
6159     HSOpts.VFSOverlayFiles.emplace_back(std::move(VFSOverlayFile));
6160   }
6161 
6162   return Listener.ReadHeaderSearchPaths(HSOpts, Complain);
6163 }
6164 
6165 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
6166                                          bool Complain,
6167                                          ASTReaderListener &Listener,
6168                                          std::string &SuggestedPredefines) {
6169   PreprocessorOptions PPOpts;
6170   unsigned Idx = 0;
6171 
6172   // Macro definitions/undefs
6173   bool ReadMacros = Record[Idx++];
6174   if (ReadMacros) {
6175     for (unsigned N = Record[Idx++]; N; --N) {
6176       std::string Macro = ReadString(Record, Idx);
6177       bool IsUndef = Record[Idx++];
6178       PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
6179     }
6180   }
6181 
6182   // Includes
6183   for (unsigned N = Record[Idx++]; N; --N) {
6184     PPOpts.Includes.push_back(ReadString(Record, Idx));
6185   }
6186 
6187   // Macro Includes
6188   for (unsigned N = Record[Idx++]; N; --N) {
6189     PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
6190   }
6191 
6192   PPOpts.UsePredefines = Record[Idx++];
6193   PPOpts.DetailedRecord = Record[Idx++];
6194   PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
6195   PPOpts.ObjCXXARCStandardLibrary =
6196     static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
6197   SuggestedPredefines.clear();
6198   return Listener.ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
6199                                           SuggestedPredefines);
6200 }
6201 
6202 std::pair<ModuleFile *, unsigned>
6203 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
6204   GlobalPreprocessedEntityMapType::iterator
6205   I = GlobalPreprocessedEntityMap.find(GlobalIndex);
6206   assert(I != GlobalPreprocessedEntityMap.end() &&
6207          "Corrupted global preprocessed entity map");
6208   ModuleFile *M = I->second;
6209   unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
6210   return std::make_pair(M, LocalIndex);
6211 }
6212 
6213 llvm::iterator_range<PreprocessingRecord::iterator>
6214 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
6215   if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
6216     return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
6217                                              Mod.NumPreprocessedEntities);
6218 
6219   return llvm::make_range(PreprocessingRecord::iterator(),
6220                           PreprocessingRecord::iterator());
6221 }
6222 
6223 bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
6224                                         unsigned int ClientLoadCapabilities) {
6225   return ClientLoadCapabilities & ARR_OutOfDate &&
6226          !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
6227 }
6228 
6229 llvm::iterator_range<ASTReader::ModuleDeclIterator>
6230 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
6231   return llvm::make_range(
6232       ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
6233       ModuleDeclIterator(this, &Mod,
6234                          Mod.FileSortedDecls + Mod.NumFileSortedDecls));
6235 }
6236 
6237 SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
6238   auto I = GlobalSkippedRangeMap.find(GlobalIndex);
6239   assert(I != GlobalSkippedRangeMap.end() &&
6240     "Corrupted global skipped range map");
6241   ModuleFile *M = I->second;
6242   unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
6243   assert(LocalIndex < M->NumPreprocessedSkippedRanges);
6244   PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
6245   SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
6246                     TranslateSourceLocation(*M, RawRange.getEnd()));
6247   assert(Range.isValid());
6248   return Range;
6249 }
6250 
6251 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
6252   PreprocessedEntityID PPID = Index+1;
6253   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6254   ModuleFile &M = *PPInfo.first;
6255   unsigned LocalIndex = PPInfo.second;
6256   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
6257 
6258   if (!PP.getPreprocessingRecord()) {
6259     Error("no preprocessing record");
6260     return nullptr;
6261   }
6262 
6263   SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
6264   if (llvm::Error Err = M.PreprocessorDetailCursor.JumpToBit(
6265           M.MacroOffsetsBase + PPOffs.BitOffset)) {
6266     Error(std::move(Err));
6267     return nullptr;
6268   }
6269 
6270   Expected<llvm::BitstreamEntry> MaybeEntry =
6271       M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
6272   if (!MaybeEntry) {
6273     Error(MaybeEntry.takeError());
6274     return nullptr;
6275   }
6276   llvm::BitstreamEntry Entry = MaybeEntry.get();
6277 
6278   if (Entry.Kind != llvm::BitstreamEntry::Record)
6279     return nullptr;
6280 
6281   // Read the record.
6282   SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
6283                     TranslateSourceLocation(M, PPOffs.getEnd()));
6284   PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
6285   StringRef Blob;
6286   RecordData Record;
6287   Expected<unsigned> MaybeRecType =
6288       M.PreprocessorDetailCursor.readRecord(Entry.ID, Record, &Blob);
6289   if (!MaybeRecType) {
6290     Error(MaybeRecType.takeError());
6291     return nullptr;
6292   }
6293   switch ((PreprocessorDetailRecordTypes)MaybeRecType.get()) {
6294   case PPD_MACRO_EXPANSION: {
6295     bool isBuiltin = Record[0];
6296     IdentifierInfo *Name = nullptr;
6297     MacroDefinitionRecord *Def = nullptr;
6298     if (isBuiltin)
6299       Name = getLocalIdentifier(M, Record[1]);
6300     else {
6301       PreprocessedEntityID GlobalID =
6302           getGlobalPreprocessedEntityID(M, Record[1]);
6303       Def = cast<MacroDefinitionRecord>(
6304           PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6305     }
6306 
6307     MacroExpansion *ME;
6308     if (isBuiltin)
6309       ME = new (PPRec) MacroExpansion(Name, Range);
6310     else
6311       ME = new (PPRec) MacroExpansion(Def, Range);
6312 
6313     return ME;
6314   }
6315 
6316   case PPD_MACRO_DEFINITION: {
6317     // Decode the identifier info and then check again; if the macro is
6318     // still defined and associated with the identifier,
6319     IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
6320     MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
6321 
6322     if (DeserializationListener)
6323       DeserializationListener->MacroDefinitionRead(PPID, MD);
6324 
6325     return MD;
6326   }
6327 
6328   case PPD_INCLUSION_DIRECTIVE: {
6329     const char *FullFileNameStart = Blob.data() + Record[0];
6330     StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
6331     OptionalFileEntryRef File;
6332     if (!FullFileName.empty())
6333       File = PP.getFileManager().getOptionalFileRef(FullFileName);
6334 
6335     // FIXME: Stable encoding
6336     InclusionDirective::InclusionKind Kind
6337       = static_cast<InclusionDirective::InclusionKind>(Record[2]);
6338     InclusionDirective *ID
6339       = new (PPRec) InclusionDirective(PPRec, Kind,
6340                                        StringRef(Blob.data(), Record[0]),
6341                                        Record[1], Record[3],
6342                                        File,
6343                                        Range);
6344     return ID;
6345   }
6346   }
6347 
6348   llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
6349 }
6350 
6351 /// Find the next module that contains entities and return the ID
6352 /// of the first entry.
6353 ///
6354 /// \param SLocMapI points at a chunk of a module that contains no
6355 /// preprocessed entities or the entities it contains are not the ones we are
6356 /// looking for.
6357 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
6358                        GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
6359   ++SLocMapI;
6360   for (GlobalSLocOffsetMapType::const_iterator
6361          EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6362     ModuleFile &M = *SLocMapI->second;
6363     if (M.NumPreprocessedEntities)
6364       return M.BasePreprocessedEntityID;
6365   }
6366 
6367   return getTotalNumPreprocessedEntities();
6368 }
6369 
6370 namespace {
6371 
6372 struct PPEntityComp {
6373   const ASTReader &Reader;
6374   ModuleFile &M;
6375 
6376   PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
6377 
6378   bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
6379     SourceLocation LHS = getLoc(L);
6380     SourceLocation RHS = getLoc(R);
6381     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6382   }
6383 
6384   bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
6385     SourceLocation LHS = getLoc(L);
6386     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6387   }
6388 
6389   bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
6390     SourceLocation RHS = getLoc(R);
6391     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6392   }
6393 
6394   SourceLocation getLoc(const PPEntityOffset &PPE) const {
6395     return Reader.TranslateSourceLocation(M, PPE.getBegin());
6396   }
6397 };
6398 
6399 } // namespace
6400 
6401 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
6402                                                        bool EndsAfter) const {
6403   if (SourceMgr.isLocalSourceLocation(Loc))
6404     return getTotalNumPreprocessedEntities();
6405 
6406   GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6407       SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
6408   assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6409          "Corrupted global sloc offset map");
6410 
6411   if (SLocMapI->second->NumPreprocessedEntities == 0)
6412     return findNextPreprocessedEntity(SLocMapI);
6413 
6414   ModuleFile &M = *SLocMapI->second;
6415 
6416   using pp_iterator = const PPEntityOffset *;
6417 
6418   pp_iterator pp_begin = M.PreprocessedEntityOffsets;
6419   pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
6420 
6421   size_t Count = M.NumPreprocessedEntities;
6422   size_t Half;
6423   pp_iterator First = pp_begin;
6424   pp_iterator PPI;
6425 
6426   if (EndsAfter) {
6427     PPI = std::upper_bound(pp_begin, pp_end, Loc,
6428                            PPEntityComp(*this, M));
6429   } else {
6430     // Do a binary search manually instead of using std::lower_bound because
6431     // The end locations of entities may be unordered (when a macro expansion
6432     // is inside another macro argument), but for this case it is not important
6433     // whether we get the first macro expansion or its containing macro.
6434     while (Count > 0) {
6435       Half = Count / 2;
6436       PPI = First;
6437       std::advance(PPI, Half);
6438       if (SourceMgr.isBeforeInTranslationUnit(
6439               TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
6440         First = PPI;
6441         ++First;
6442         Count = Count - Half - 1;
6443       } else
6444         Count = Half;
6445     }
6446   }
6447 
6448   if (PPI == pp_end)
6449     return findNextPreprocessedEntity(SLocMapI);
6450 
6451   return M.BasePreprocessedEntityID + (PPI - pp_begin);
6452 }
6453 
6454 /// Returns a pair of [Begin, End) indices of preallocated
6455 /// preprocessed entities that \arg Range encompasses.
6456 std::pair<unsigned, unsigned>
6457     ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
6458   if (Range.isInvalid())
6459     return std::make_pair(0,0);
6460   assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
6461 
6462   PreprocessedEntityID BeginID =
6463       findPreprocessedEntity(Range.getBegin(), false);
6464   PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
6465   return std::make_pair(BeginID, EndID);
6466 }
6467 
6468 /// Optionally returns true or false if the preallocated preprocessed
6469 /// entity with index \arg Index came from file \arg FID.
6470 std::optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
6471                                                             FileID FID) {
6472   if (FID.isInvalid())
6473     return false;
6474 
6475   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6476   ModuleFile &M = *PPInfo.first;
6477   unsigned LocalIndex = PPInfo.second;
6478   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
6479 
6480   SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
6481   if (Loc.isInvalid())
6482     return false;
6483 
6484   if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
6485     return true;
6486   else
6487     return false;
6488 }
6489 
6490 namespace {
6491 
6492   /// Visitor used to search for information about a header file.
6493   class HeaderFileInfoVisitor {
6494   FileEntryRef FE;
6495     std::optional<HeaderFileInfo> HFI;
6496 
6497   public:
6498     explicit HeaderFileInfoVisitor(FileEntryRef FE) : FE(FE) {}
6499 
6500     bool operator()(ModuleFile &M) {
6501       HeaderFileInfoLookupTable *Table
6502         = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
6503       if (!Table)
6504         return false;
6505 
6506       // Look in the on-disk hash table for an entry for this file name.
6507       HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6508       if (Pos == Table->end())
6509         return false;
6510 
6511       HFI = *Pos;
6512       return true;
6513     }
6514 
6515     std::optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
6516   };
6517 
6518 } // namespace
6519 
6520 HeaderFileInfo ASTReader::GetHeaderFileInfo(FileEntryRef FE) {
6521   HeaderFileInfoVisitor Visitor(FE);
6522   ModuleMgr.visit(Visitor);
6523   if (std::optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6524       return *HFI;
6525 
6526   return HeaderFileInfo();
6527 }
6528 
6529 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
6530   using DiagState = DiagnosticsEngine::DiagState;
6531   SmallVector<DiagState *, 32> DiagStates;
6532 
6533   for (ModuleFile &F : ModuleMgr) {
6534     unsigned Idx = 0;
6535     auto &Record = F.PragmaDiagMappings;
6536     if (Record.empty())
6537       continue;
6538 
6539     DiagStates.clear();
6540 
6541     auto ReadDiagState = [&](const DiagState &BasedOn,
6542                              bool IncludeNonPragmaStates) {
6543       unsigned BackrefID = Record[Idx++];
6544       if (BackrefID != 0)
6545         return DiagStates[BackrefID - 1];
6546 
6547       // A new DiagState was created here.
6548       Diag.DiagStates.push_back(BasedOn);
6549       DiagState *NewState = &Diag.DiagStates.back();
6550       DiagStates.push_back(NewState);
6551       unsigned Size = Record[Idx++];
6552       assert(Idx + Size * 2 <= Record.size() &&
6553              "Invalid data, not enough diag/map pairs");
6554       while (Size--) {
6555         unsigned DiagID = Record[Idx++];
6556         DiagnosticMapping NewMapping =
6557             DiagnosticMapping::deserialize(Record[Idx++]);
6558         if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
6559           continue;
6560 
6561         DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
6562 
6563         // If this mapping was specified as a warning but the severity was
6564         // upgraded due to diagnostic settings, simulate the current diagnostic
6565         // settings (and use a warning).
6566         if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
6567           NewMapping.setSeverity(diag::Severity::Warning);
6568           NewMapping.setUpgradedFromWarning(false);
6569         }
6570 
6571         Mapping = NewMapping;
6572       }
6573       return NewState;
6574     };
6575 
6576     // Read the first state.
6577     DiagState *FirstState;
6578     if (F.Kind == MK_ImplicitModule) {
6579       // Implicitly-built modules are reused with different diagnostic
6580       // settings.  Use the initial diagnostic state from Diag to simulate this
6581       // compilation's diagnostic settings.
6582       FirstState = Diag.DiagStatesByLoc.FirstDiagState;
6583       DiagStates.push_back(FirstState);
6584 
6585       // Skip the initial diagnostic state from the serialized module.
6586       assert(Record[1] == 0 &&
6587              "Invalid data, unexpected backref in initial state");
6588       Idx = 3 + Record[2] * 2;
6589       assert(Idx < Record.size() &&
6590              "Invalid data, not enough state change pairs in initial state");
6591     } else if (F.isModule()) {
6592       // For an explicit module, preserve the flags from the module build
6593       // command line (-w, -Weverything, -Werror, ...) along with any explicit
6594       // -Wblah flags.
6595       unsigned Flags = Record[Idx++];
6596       DiagState Initial;
6597       Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6598       Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6599       Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6600       Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6601       Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6602       Initial.ExtBehavior = (diag::Severity)Flags;
6603       FirstState = ReadDiagState(Initial, true);
6604 
6605       assert(F.OriginalSourceFileID.isValid());
6606 
6607       // Set up the root buffer of the module to start with the initial
6608       // diagnostic state of the module itself, to cover files that contain no
6609       // explicit transitions (for which we did not serialize anything).
6610       Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
6611           .StateTransitions.push_back({FirstState, 0});
6612     } else {
6613       // For prefix ASTs, start with whatever the user configured on the
6614       // command line.
6615       Idx++; // Skip flags.
6616       FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState, false);
6617     }
6618 
6619     // Read the state transitions.
6620     unsigned NumLocations = Record[Idx++];
6621     while (NumLocations--) {
6622       assert(Idx < Record.size() &&
6623              "Invalid data, missing pragma diagnostic states");
6624       SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
6625       auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
6626       assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
6627       assert(IDAndOffset.second == 0 && "not a start location for a FileID");
6628       unsigned Transitions = Record[Idx++];
6629 
6630       // Note that we don't need to set up Parent/ParentOffset here, because
6631       // we won't be changing the diagnostic state within imported FileIDs
6632       // (other than perhaps appending to the main source file, which has no
6633       // parent).
6634       auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
6635       F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6636       for (unsigned I = 0; I != Transitions; ++I) {
6637         unsigned Offset = Record[Idx++];
6638         auto *State = ReadDiagState(*FirstState, false);
6639         F.StateTransitions.push_back({State, Offset});
6640       }
6641     }
6642 
6643     // Read the final state.
6644     assert(Idx < Record.size() &&
6645            "Invalid data, missing final pragma diagnostic state");
6646     SourceLocation CurStateLoc = ReadSourceLocation(F, Record[Idx++]);
6647     auto *CurState = ReadDiagState(*FirstState, false);
6648 
6649     if (!F.isModule()) {
6650       Diag.DiagStatesByLoc.CurDiagState = CurState;
6651       Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6652 
6653       // Preserve the property that the imaginary root file describes the
6654       // current state.
6655       FileID NullFile;
6656       auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6657       if (T.empty())
6658         T.push_back({CurState, 0});
6659       else
6660         T[0].State = CurState;
6661     }
6662 
6663     // Don't try to read these mappings again.
6664     Record.clear();
6665   }
6666 }
6667 
6668 /// Get the correct cursor and offset for loading a type.
6669 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
6670   GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6671   assert(I != GlobalTypeMap.end() && "Corrupted global type map");
6672   ModuleFile *M = I->second;
6673   return RecordLocation(
6674       M, M->TypeOffsets[Index - M->BaseTypeIndex].getBitOffset() +
6675              M->DeclsBlockStartOffset);
6676 }
6677 
6678 static std::optional<Type::TypeClass> getTypeClassForCode(TypeCode code) {
6679   switch (code) {
6680 #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6681   case TYPE_##CODE_ID: return Type::CLASS_ID;
6682 #include "clang/Serialization/TypeBitCodes.def"
6683   default:
6684     return std::nullopt;
6685   }
6686 }
6687 
6688 /// Read and return the type with the given index..
6689 ///
6690 /// The index is the type ID, shifted and minus the number of predefs. This
6691 /// routine actually reads the record corresponding to the type at the given
6692 /// location. It is a helper routine for GetType, which deals with reading type
6693 /// IDs.
6694 QualType ASTReader::readTypeRecord(unsigned Index) {
6695   assert(ContextObj && "reading type with no AST context");
6696   ASTContext &Context = *ContextObj;
6697   RecordLocation Loc = TypeCursorForIndex(Index);
6698   BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
6699 
6700   // Keep track of where we are in the stream, then jump back there
6701   // after reading this type.
6702   SavedStreamPosition SavedPosition(DeclsCursor);
6703 
6704   ReadingKindTracker ReadingKind(Read_Type, *this);
6705 
6706   // Note that we are loading a type record.
6707   Deserializing AType(this);
6708 
6709   if (llvm::Error Err = DeclsCursor.JumpToBit(Loc.Offset)) {
6710     Error(std::move(Err));
6711     return QualType();
6712   }
6713   Expected<unsigned> RawCode = DeclsCursor.ReadCode();
6714   if (!RawCode) {
6715     Error(RawCode.takeError());
6716     return QualType();
6717   }
6718 
6719   ASTRecordReader Record(*this, *Loc.F);
6720   Expected<unsigned> Code = Record.readRecord(DeclsCursor, RawCode.get());
6721   if (!Code) {
6722     Error(Code.takeError());
6723     return QualType();
6724   }
6725   if (Code.get() == TYPE_EXT_QUAL) {
6726     QualType baseType = Record.readQualType();
6727     Qualifiers quals = Record.readQualifiers();
6728     return Context.getQualifiedType(baseType, quals);
6729   }
6730 
6731   auto maybeClass = getTypeClassForCode((TypeCode) Code.get());
6732   if (!maybeClass) {
6733     Error("Unexpected code for type");
6734     return QualType();
6735   }
6736 
6737   serialization::AbstractTypeReader<ASTRecordReader> TypeReader(Record);
6738   return TypeReader.read(*maybeClass);
6739 }
6740 
6741 namespace clang {
6742 
6743 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6744   using LocSeq = SourceLocationSequence;
6745 
6746   ASTRecordReader &Reader;
6747   LocSeq *Seq;
6748 
6749   SourceLocation readSourceLocation() { return Reader.readSourceLocation(Seq); }
6750   SourceRange readSourceRange() { return Reader.readSourceRange(Seq); }
6751 
6752   TypeSourceInfo *GetTypeSourceInfo() {
6753     return Reader.readTypeSourceInfo();
6754   }
6755 
6756   NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6757     return Reader.readNestedNameSpecifierLoc();
6758   }
6759 
6760   Attr *ReadAttr() {
6761     return Reader.readAttr();
6762   }
6763 
6764 public:
6765   TypeLocReader(ASTRecordReader &Reader, LocSeq *Seq)
6766       : Reader(Reader), Seq(Seq) {}
6767 
6768   // We want compile-time assurance that we've enumerated all of
6769   // these, so unfortunately we have to declare them first, then
6770   // define them out-of-line.
6771 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6772 #define TYPELOC(CLASS, PARENT) \
6773   void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6774 #include "clang/AST/TypeLocNodes.def"
6775 
6776   void VisitFunctionTypeLoc(FunctionTypeLoc);
6777   void VisitArrayTypeLoc(ArrayTypeLoc);
6778 };
6779 
6780 } // namespace clang
6781 
6782 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6783   // nothing to do
6784 }
6785 
6786 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6787   TL.setBuiltinLoc(readSourceLocation());
6788   if (TL.needsExtraLocalData()) {
6789     TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Reader.readInt()));
6790     TL.setWrittenSignSpec(static_cast<TypeSpecifierSign>(Reader.readInt()));
6791     TL.setWrittenWidthSpec(static_cast<TypeSpecifierWidth>(Reader.readInt()));
6792     TL.setModeAttr(Reader.readInt());
6793   }
6794 }
6795 
6796 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6797   TL.setNameLoc(readSourceLocation());
6798 }
6799 
6800 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6801   TL.setStarLoc(readSourceLocation());
6802 }
6803 
6804 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6805   // nothing to do
6806 }
6807 
6808 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6809   // nothing to do
6810 }
6811 
6812 void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6813   TL.setExpansionLoc(readSourceLocation());
6814 }
6815 
6816 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6817   TL.setCaretLoc(readSourceLocation());
6818 }
6819 
6820 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6821   TL.setAmpLoc(readSourceLocation());
6822 }
6823 
6824 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6825   TL.setAmpAmpLoc(readSourceLocation());
6826 }
6827 
6828 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6829   TL.setStarLoc(readSourceLocation());
6830   TL.setClassTInfo(GetTypeSourceInfo());
6831 }
6832 
6833 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6834   TL.setLBracketLoc(readSourceLocation());
6835   TL.setRBracketLoc(readSourceLocation());
6836   if (Reader.readBool())
6837     TL.setSizeExpr(Reader.readExpr());
6838   else
6839     TL.setSizeExpr(nullptr);
6840 }
6841 
6842 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6843   VisitArrayTypeLoc(TL);
6844 }
6845 
6846 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6847   VisitArrayTypeLoc(TL);
6848 }
6849 
6850 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6851   VisitArrayTypeLoc(TL);
6852 }
6853 
6854 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6855                                             DependentSizedArrayTypeLoc TL) {
6856   VisitArrayTypeLoc(TL);
6857 }
6858 
6859 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6860     DependentAddressSpaceTypeLoc TL) {
6861 
6862     TL.setAttrNameLoc(readSourceLocation());
6863     TL.setAttrOperandParensRange(readSourceRange());
6864     TL.setAttrExprOperand(Reader.readExpr());
6865 }
6866 
6867 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6868                                         DependentSizedExtVectorTypeLoc TL) {
6869   TL.setNameLoc(readSourceLocation());
6870 }
6871 
6872 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6873   TL.setNameLoc(readSourceLocation());
6874 }
6875 
6876 void TypeLocReader::VisitDependentVectorTypeLoc(
6877     DependentVectorTypeLoc TL) {
6878   TL.setNameLoc(readSourceLocation());
6879 }
6880 
6881 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6882   TL.setNameLoc(readSourceLocation());
6883 }
6884 
6885 void TypeLocReader::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
6886   TL.setAttrNameLoc(readSourceLocation());
6887   TL.setAttrOperandParensRange(readSourceRange());
6888   TL.setAttrRowOperand(Reader.readExpr());
6889   TL.setAttrColumnOperand(Reader.readExpr());
6890 }
6891 
6892 void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6893     DependentSizedMatrixTypeLoc TL) {
6894   TL.setAttrNameLoc(readSourceLocation());
6895   TL.setAttrOperandParensRange(readSourceRange());
6896   TL.setAttrRowOperand(Reader.readExpr());
6897   TL.setAttrColumnOperand(Reader.readExpr());
6898 }
6899 
6900 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6901   TL.setLocalRangeBegin(readSourceLocation());
6902   TL.setLParenLoc(readSourceLocation());
6903   TL.setRParenLoc(readSourceLocation());
6904   TL.setExceptionSpecRange(readSourceRange());
6905   TL.setLocalRangeEnd(readSourceLocation());
6906   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6907     TL.setParam(i, Reader.readDeclAs<ParmVarDecl>());
6908   }
6909 }
6910 
6911 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6912   VisitFunctionTypeLoc(TL);
6913 }
6914 
6915 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6916   VisitFunctionTypeLoc(TL);
6917 }
6918 
6919 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6920   TL.setNameLoc(readSourceLocation());
6921 }
6922 
6923 void TypeLocReader::VisitUsingTypeLoc(UsingTypeLoc TL) {
6924   TL.setNameLoc(readSourceLocation());
6925 }
6926 
6927 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6928   TL.setNameLoc(readSourceLocation());
6929 }
6930 
6931 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6932   TL.setTypeofLoc(readSourceLocation());
6933   TL.setLParenLoc(readSourceLocation());
6934   TL.setRParenLoc(readSourceLocation());
6935 }
6936 
6937 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6938   TL.setTypeofLoc(readSourceLocation());
6939   TL.setLParenLoc(readSourceLocation());
6940   TL.setRParenLoc(readSourceLocation());
6941   TL.setUnmodifiedTInfo(GetTypeSourceInfo());
6942 }
6943 
6944 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6945   TL.setDecltypeLoc(readSourceLocation());
6946   TL.setRParenLoc(readSourceLocation());
6947 }
6948 
6949 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6950   TL.setKWLoc(readSourceLocation());
6951   TL.setLParenLoc(readSourceLocation());
6952   TL.setRParenLoc(readSourceLocation());
6953   TL.setUnderlyingTInfo(GetTypeSourceInfo());
6954 }
6955 
6956 ConceptReference *ASTRecordReader::readConceptReference() {
6957   auto NNS = readNestedNameSpecifierLoc();
6958   auto TemplateKWLoc = readSourceLocation();
6959   auto ConceptNameLoc = readDeclarationNameInfo();
6960   auto FoundDecl = readDeclAs<NamedDecl>();
6961   auto NamedConcept = readDeclAs<ConceptDecl>();
6962   auto *CR = ConceptReference::Create(
6963       getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
6964       (readBool() ? readASTTemplateArgumentListInfo() : nullptr));
6965   return CR;
6966 }
6967 
6968 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6969   TL.setNameLoc(readSourceLocation());
6970   if (Reader.readBool())
6971     TL.setConceptReference(Reader.readConceptReference());
6972   if (Reader.readBool())
6973     TL.setRParenLoc(readSourceLocation());
6974 }
6975 
6976 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6977     DeducedTemplateSpecializationTypeLoc TL) {
6978   TL.setTemplateNameLoc(readSourceLocation());
6979 }
6980 
6981 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6982   TL.setNameLoc(readSourceLocation());
6983 }
6984 
6985 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6986   TL.setNameLoc(readSourceLocation());
6987 }
6988 
6989 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6990   TL.setAttr(ReadAttr());
6991 }
6992 
6993 void TypeLocReader::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
6994   // Nothing to do.
6995 }
6996 
6997 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6998   TL.setNameLoc(readSourceLocation());
6999 }
7000 
7001 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
7002                                             SubstTemplateTypeParmTypeLoc TL) {
7003   TL.setNameLoc(readSourceLocation());
7004 }
7005 
7006 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
7007                                           SubstTemplateTypeParmPackTypeLoc TL) {
7008   TL.setNameLoc(readSourceLocation());
7009 }
7010 
7011 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
7012                                            TemplateSpecializationTypeLoc TL) {
7013   TL.setTemplateKeywordLoc(readSourceLocation());
7014   TL.setTemplateNameLoc(readSourceLocation());
7015   TL.setLAngleLoc(readSourceLocation());
7016   TL.setRAngleLoc(readSourceLocation());
7017   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
7018     TL.setArgLocInfo(i,
7019                      Reader.readTemplateArgumentLocInfo(
7020                          TL.getTypePtr()->template_arguments()[i].getKind()));
7021 }
7022 
7023 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
7024   TL.setLParenLoc(readSourceLocation());
7025   TL.setRParenLoc(readSourceLocation());
7026 }
7027 
7028 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
7029   TL.setElaboratedKeywordLoc(readSourceLocation());
7030   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
7031 }
7032 
7033 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
7034   TL.setNameLoc(readSourceLocation());
7035 }
7036 
7037 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
7038   TL.setElaboratedKeywordLoc(readSourceLocation());
7039   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
7040   TL.setNameLoc(readSourceLocation());
7041 }
7042 
7043 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
7044        DependentTemplateSpecializationTypeLoc TL) {
7045   TL.setElaboratedKeywordLoc(readSourceLocation());
7046   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
7047   TL.setTemplateKeywordLoc(readSourceLocation());
7048   TL.setTemplateNameLoc(readSourceLocation());
7049   TL.setLAngleLoc(readSourceLocation());
7050   TL.setRAngleLoc(readSourceLocation());
7051   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
7052     TL.setArgLocInfo(I,
7053                      Reader.readTemplateArgumentLocInfo(
7054                          TL.getTypePtr()->template_arguments()[I].getKind()));
7055 }
7056 
7057 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
7058   TL.setEllipsisLoc(readSourceLocation());
7059 }
7060 
7061 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
7062   TL.setNameLoc(readSourceLocation());
7063   TL.setNameEndLoc(readSourceLocation());
7064 }
7065 
7066 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
7067   if (TL.getNumProtocols()) {
7068     TL.setProtocolLAngleLoc(readSourceLocation());
7069     TL.setProtocolRAngleLoc(readSourceLocation());
7070   }
7071   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
7072     TL.setProtocolLoc(i, readSourceLocation());
7073 }
7074 
7075 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
7076   TL.setHasBaseTypeAsWritten(Reader.readBool());
7077   TL.setTypeArgsLAngleLoc(readSourceLocation());
7078   TL.setTypeArgsRAngleLoc(readSourceLocation());
7079   for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
7080     TL.setTypeArgTInfo(i, GetTypeSourceInfo());
7081   TL.setProtocolLAngleLoc(readSourceLocation());
7082   TL.setProtocolRAngleLoc(readSourceLocation());
7083   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
7084     TL.setProtocolLoc(i, readSourceLocation());
7085 }
7086 
7087 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
7088   TL.setStarLoc(readSourceLocation());
7089 }
7090 
7091 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
7092   TL.setKWLoc(readSourceLocation());
7093   TL.setLParenLoc(readSourceLocation());
7094   TL.setRParenLoc(readSourceLocation());
7095 }
7096 
7097 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
7098   TL.setKWLoc(readSourceLocation());
7099 }
7100 
7101 void TypeLocReader::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) {
7102   TL.setNameLoc(readSourceLocation());
7103 }
7104 void TypeLocReader::VisitDependentBitIntTypeLoc(
7105     clang::DependentBitIntTypeLoc TL) {
7106   TL.setNameLoc(readSourceLocation());
7107 }
7108 
7109 void ASTRecordReader::readTypeLoc(TypeLoc TL, LocSeq *ParentSeq) {
7110   LocSeq::State Seq(ParentSeq);
7111   TypeLocReader TLR(*this, Seq);
7112   for (; !TL.isNull(); TL = TL.getNextTypeLoc())
7113     TLR.Visit(TL);
7114 }
7115 
7116 TypeSourceInfo *ASTRecordReader::readTypeSourceInfo() {
7117   QualType InfoTy = readType();
7118   if (InfoTy.isNull())
7119     return nullptr;
7120 
7121   TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
7122   readTypeLoc(TInfo->getTypeLoc());
7123   return TInfo;
7124 }
7125 
7126 QualType ASTReader::GetType(TypeID ID) {
7127   assert(ContextObj && "reading type with no AST context");
7128   ASTContext &Context = *ContextObj;
7129 
7130   unsigned FastQuals = ID & Qualifiers::FastMask;
7131   unsigned Index = ID >> Qualifiers::FastWidth;
7132 
7133   if (Index < NUM_PREDEF_TYPE_IDS) {
7134     QualType T;
7135     switch ((PredefinedTypeIDs)Index) {
7136     case PREDEF_TYPE_LAST_ID:
7137       // We should never use this one.
7138       llvm_unreachable("Invalid predefined type");
7139       break;
7140     case PREDEF_TYPE_NULL_ID:
7141       return QualType();
7142     case PREDEF_TYPE_VOID_ID:
7143       T = Context.VoidTy;
7144       break;
7145     case PREDEF_TYPE_BOOL_ID:
7146       T = Context.BoolTy;
7147       break;
7148     case PREDEF_TYPE_CHAR_U_ID:
7149     case PREDEF_TYPE_CHAR_S_ID:
7150       // FIXME: Check that the signedness of CharTy is correct!
7151       T = Context.CharTy;
7152       break;
7153     case PREDEF_TYPE_UCHAR_ID:
7154       T = Context.UnsignedCharTy;
7155       break;
7156     case PREDEF_TYPE_USHORT_ID:
7157       T = Context.UnsignedShortTy;
7158       break;
7159     case PREDEF_TYPE_UINT_ID:
7160       T = Context.UnsignedIntTy;
7161       break;
7162     case PREDEF_TYPE_ULONG_ID:
7163       T = Context.UnsignedLongTy;
7164       break;
7165     case PREDEF_TYPE_ULONGLONG_ID:
7166       T = Context.UnsignedLongLongTy;
7167       break;
7168     case PREDEF_TYPE_UINT128_ID:
7169       T = Context.UnsignedInt128Ty;
7170       break;
7171     case PREDEF_TYPE_SCHAR_ID:
7172       T = Context.SignedCharTy;
7173       break;
7174     case PREDEF_TYPE_WCHAR_ID:
7175       T = Context.WCharTy;
7176       break;
7177     case PREDEF_TYPE_SHORT_ID:
7178       T = Context.ShortTy;
7179       break;
7180     case PREDEF_TYPE_INT_ID:
7181       T = Context.IntTy;
7182       break;
7183     case PREDEF_TYPE_LONG_ID:
7184       T = Context.LongTy;
7185       break;
7186     case PREDEF_TYPE_LONGLONG_ID:
7187       T = Context.LongLongTy;
7188       break;
7189     case PREDEF_TYPE_INT128_ID:
7190       T = Context.Int128Ty;
7191       break;
7192     case PREDEF_TYPE_BFLOAT16_ID:
7193       T = Context.BFloat16Ty;
7194       break;
7195     case PREDEF_TYPE_HALF_ID:
7196       T = Context.HalfTy;
7197       break;
7198     case PREDEF_TYPE_FLOAT_ID:
7199       T = Context.FloatTy;
7200       break;
7201     case PREDEF_TYPE_DOUBLE_ID:
7202       T = Context.DoubleTy;
7203       break;
7204     case PREDEF_TYPE_LONGDOUBLE_ID:
7205       T = Context.LongDoubleTy;
7206       break;
7207     case PREDEF_TYPE_SHORT_ACCUM_ID:
7208       T = Context.ShortAccumTy;
7209       break;
7210     case PREDEF_TYPE_ACCUM_ID:
7211       T = Context.AccumTy;
7212       break;
7213     case PREDEF_TYPE_LONG_ACCUM_ID:
7214       T = Context.LongAccumTy;
7215       break;
7216     case PREDEF_TYPE_USHORT_ACCUM_ID:
7217       T = Context.UnsignedShortAccumTy;
7218       break;
7219     case PREDEF_TYPE_UACCUM_ID:
7220       T = Context.UnsignedAccumTy;
7221       break;
7222     case PREDEF_TYPE_ULONG_ACCUM_ID:
7223       T = Context.UnsignedLongAccumTy;
7224       break;
7225     case PREDEF_TYPE_SHORT_FRACT_ID:
7226       T = Context.ShortFractTy;
7227       break;
7228     case PREDEF_TYPE_FRACT_ID:
7229       T = Context.FractTy;
7230       break;
7231     case PREDEF_TYPE_LONG_FRACT_ID:
7232       T = Context.LongFractTy;
7233       break;
7234     case PREDEF_TYPE_USHORT_FRACT_ID:
7235       T = Context.UnsignedShortFractTy;
7236       break;
7237     case PREDEF_TYPE_UFRACT_ID:
7238       T = Context.UnsignedFractTy;
7239       break;
7240     case PREDEF_TYPE_ULONG_FRACT_ID:
7241       T = Context.UnsignedLongFractTy;
7242       break;
7243     case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
7244       T = Context.SatShortAccumTy;
7245       break;
7246     case PREDEF_TYPE_SAT_ACCUM_ID:
7247       T = Context.SatAccumTy;
7248       break;
7249     case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
7250       T = Context.SatLongAccumTy;
7251       break;
7252     case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
7253       T = Context.SatUnsignedShortAccumTy;
7254       break;
7255     case PREDEF_TYPE_SAT_UACCUM_ID:
7256       T = Context.SatUnsignedAccumTy;
7257       break;
7258     case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
7259       T = Context.SatUnsignedLongAccumTy;
7260       break;
7261     case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
7262       T = Context.SatShortFractTy;
7263       break;
7264     case PREDEF_TYPE_SAT_FRACT_ID:
7265       T = Context.SatFractTy;
7266       break;
7267     case PREDEF_TYPE_SAT_LONG_FRACT_ID:
7268       T = Context.SatLongFractTy;
7269       break;
7270     case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
7271       T = Context.SatUnsignedShortFractTy;
7272       break;
7273     case PREDEF_TYPE_SAT_UFRACT_ID:
7274       T = Context.SatUnsignedFractTy;
7275       break;
7276     case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
7277       T = Context.SatUnsignedLongFractTy;
7278       break;
7279     case PREDEF_TYPE_FLOAT16_ID:
7280       T = Context.Float16Ty;
7281       break;
7282     case PREDEF_TYPE_FLOAT128_ID:
7283       T = Context.Float128Ty;
7284       break;
7285     case PREDEF_TYPE_IBM128_ID:
7286       T = Context.Ibm128Ty;
7287       break;
7288     case PREDEF_TYPE_OVERLOAD_ID:
7289       T = Context.OverloadTy;
7290       break;
7291     case PREDEF_TYPE_BOUND_MEMBER:
7292       T = Context.BoundMemberTy;
7293       break;
7294     case PREDEF_TYPE_PSEUDO_OBJECT:
7295       T = Context.PseudoObjectTy;
7296       break;
7297     case PREDEF_TYPE_DEPENDENT_ID:
7298       T = Context.DependentTy;
7299       break;
7300     case PREDEF_TYPE_UNKNOWN_ANY:
7301       T = Context.UnknownAnyTy;
7302       break;
7303     case PREDEF_TYPE_NULLPTR_ID:
7304       T = Context.NullPtrTy;
7305       break;
7306     case PREDEF_TYPE_CHAR8_ID:
7307       T = Context.Char8Ty;
7308       break;
7309     case PREDEF_TYPE_CHAR16_ID:
7310       T = Context.Char16Ty;
7311       break;
7312     case PREDEF_TYPE_CHAR32_ID:
7313       T = Context.Char32Ty;
7314       break;
7315     case PREDEF_TYPE_OBJC_ID:
7316       T = Context.ObjCBuiltinIdTy;
7317       break;
7318     case PREDEF_TYPE_OBJC_CLASS:
7319       T = Context.ObjCBuiltinClassTy;
7320       break;
7321     case PREDEF_TYPE_OBJC_SEL:
7322       T = Context.ObjCBuiltinSelTy;
7323       break;
7324 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7325     case PREDEF_TYPE_##Id##_ID: \
7326       T = Context.SingletonId; \
7327       break;
7328 #include "clang/Basic/OpenCLImageTypes.def"
7329 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7330     case PREDEF_TYPE_##Id##_ID: \
7331       T = Context.Id##Ty; \
7332       break;
7333 #include "clang/Basic/OpenCLExtensionTypes.def"
7334     case PREDEF_TYPE_SAMPLER_ID:
7335       T = Context.OCLSamplerTy;
7336       break;
7337     case PREDEF_TYPE_EVENT_ID:
7338       T = Context.OCLEventTy;
7339       break;
7340     case PREDEF_TYPE_CLK_EVENT_ID:
7341       T = Context.OCLClkEventTy;
7342       break;
7343     case PREDEF_TYPE_QUEUE_ID:
7344       T = Context.OCLQueueTy;
7345       break;
7346     case PREDEF_TYPE_RESERVE_ID_ID:
7347       T = Context.OCLReserveIDTy;
7348       break;
7349     case PREDEF_TYPE_AUTO_DEDUCT:
7350       T = Context.getAutoDeductType();
7351       break;
7352     case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7353       T = Context.getAutoRRefDeductType();
7354       break;
7355     case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7356       T = Context.ARCUnbridgedCastTy;
7357       break;
7358     case PREDEF_TYPE_BUILTIN_FN:
7359       T = Context.BuiltinFnTy;
7360       break;
7361     case PREDEF_TYPE_INCOMPLETE_MATRIX_IDX:
7362       T = Context.IncompleteMatrixIdxTy;
7363       break;
7364     case PREDEF_TYPE_OMP_ARRAY_SECTION:
7365       T = Context.OMPArraySectionTy;
7366       break;
7367     case PREDEF_TYPE_OMP_ARRAY_SHAPING:
7368       T = Context.OMPArraySectionTy;
7369       break;
7370     case PREDEF_TYPE_OMP_ITERATOR:
7371       T = Context.OMPIteratorTy;
7372       break;
7373 #define SVE_TYPE(Name, Id, SingletonId) \
7374     case PREDEF_TYPE_##Id##_ID: \
7375       T = Context.SingletonId; \
7376       break;
7377 #include "clang/Basic/AArch64SVEACLETypes.def"
7378 #define PPC_VECTOR_TYPE(Name, Id, Size) \
7379     case PREDEF_TYPE_##Id##_ID: \
7380       T = Context.Id##Ty; \
7381       break;
7382 #include "clang/Basic/PPCTypes.def"
7383 #define RVV_TYPE(Name, Id, SingletonId) \
7384     case PREDEF_TYPE_##Id##_ID: \
7385       T = Context.SingletonId; \
7386       break;
7387 #include "clang/Basic/RISCVVTypes.def"
7388 #define WASM_TYPE(Name, Id, SingletonId)                                       \
7389   case PREDEF_TYPE_##Id##_ID:                                                  \
7390     T = Context.SingletonId;                                                   \
7391     break;
7392 #include "clang/Basic/WebAssemblyReferenceTypes.def"
7393     }
7394 
7395     assert(!T.isNull() && "Unknown predefined type");
7396     return T.withFastQualifiers(FastQuals);
7397   }
7398 
7399   Index -= NUM_PREDEF_TYPE_IDS;
7400   assert(Index < TypesLoaded.size() && "Type index out-of-range");
7401   if (TypesLoaded[Index].isNull()) {
7402     TypesLoaded[Index] = readTypeRecord(Index);
7403     if (TypesLoaded[Index].isNull())
7404       return QualType();
7405 
7406     TypesLoaded[Index]->setFromAST();
7407     if (DeserializationListener)
7408       DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7409                                         TypesLoaded[Index]);
7410   }
7411 
7412   return TypesLoaded[Index].withFastQualifiers(FastQuals);
7413 }
7414 
7415 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7416   return GetType(getGlobalTypeID(F, LocalID));
7417 }
7418 
7419 serialization::TypeID
7420 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7421   unsigned FastQuals = LocalID & Qualifiers::FastMask;
7422   unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7423 
7424   if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7425     return LocalID;
7426 
7427   if (!F.ModuleOffsetMap.empty())
7428     ReadModuleOffsetMap(F);
7429 
7430   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7431     = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7432   assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7433 
7434   unsigned GlobalIndex = LocalIndex + I->second;
7435   return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7436 }
7437 
7438 TemplateArgumentLocInfo
7439 ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
7440   switch (Kind) {
7441   case TemplateArgument::Expression:
7442     return readExpr();
7443   case TemplateArgument::Type:
7444     return readTypeSourceInfo();
7445   case TemplateArgument::Template: {
7446     NestedNameSpecifierLoc QualifierLoc =
7447       readNestedNameSpecifierLoc();
7448     SourceLocation TemplateNameLoc = readSourceLocation();
7449     return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
7450                                    TemplateNameLoc, SourceLocation());
7451   }
7452   case TemplateArgument::TemplateExpansion: {
7453     NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc();
7454     SourceLocation TemplateNameLoc = readSourceLocation();
7455     SourceLocation EllipsisLoc = readSourceLocation();
7456     return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
7457                                    TemplateNameLoc, EllipsisLoc);
7458   }
7459   case TemplateArgument::Null:
7460   case TemplateArgument::Integral:
7461   case TemplateArgument::Declaration:
7462   case TemplateArgument::NullPtr:
7463   case TemplateArgument::StructuralValue:
7464   case TemplateArgument::Pack:
7465     // FIXME: Is this right?
7466     return TemplateArgumentLocInfo();
7467   }
7468   llvm_unreachable("unexpected template argument loc");
7469 }
7470 
7471 TemplateArgumentLoc ASTRecordReader::readTemplateArgumentLoc() {
7472   TemplateArgument Arg = readTemplateArgument();
7473 
7474   if (Arg.getKind() == TemplateArgument::Expression) {
7475     if (readBool()) // bool InfoHasSameExpr.
7476       return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7477   }
7478   return TemplateArgumentLoc(Arg, readTemplateArgumentLocInfo(Arg.getKind()));
7479 }
7480 
7481 void ASTRecordReader::readTemplateArgumentListInfo(
7482     TemplateArgumentListInfo &Result) {
7483   Result.setLAngleLoc(readSourceLocation());
7484   Result.setRAngleLoc(readSourceLocation());
7485   unsigned NumArgsAsWritten = readInt();
7486   for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7487     Result.addArgument(readTemplateArgumentLoc());
7488 }
7489 
7490 const ASTTemplateArgumentListInfo *
7491 ASTRecordReader::readASTTemplateArgumentListInfo() {
7492   TemplateArgumentListInfo Result;
7493   readTemplateArgumentListInfo(Result);
7494   return ASTTemplateArgumentListInfo::Create(getContext(), Result);
7495 }
7496 
7497 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7498   return GetDecl(ID);
7499 }
7500 
7501 void ASTReader::CompleteRedeclChain(const Decl *D) {
7502   if (NumCurrentElementsDeserializing) {
7503     // We arrange to not care about the complete redeclaration chain while we're
7504     // deserializing. Just remember that the AST has marked this one as complete
7505     // but that it's not actually complete yet, so we know we still need to
7506     // complete it later.
7507     PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7508     return;
7509   }
7510 
7511   if (!D->getDeclContext()) {
7512     assert(isa<TranslationUnitDecl>(D) && "Not a TU?");
7513     return;
7514   }
7515 
7516   const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7517 
7518   // If this is a named declaration, complete it by looking it up
7519   // within its context.
7520   //
7521   // FIXME: Merging a function definition should merge
7522   // all mergeable entities within it.
7523   if (isa<TranslationUnitDecl, NamespaceDecl, RecordDecl, EnumDecl>(DC)) {
7524     if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7525       if (!getContext().getLangOpts().CPlusPlus &&
7526           isa<TranslationUnitDecl>(DC)) {
7527         // Outside of C++, we don't have a lookup table for the TU, so update
7528         // the identifier instead. (For C++ modules, we don't store decls
7529         // in the serialized identifier table, so we do the lookup in the TU.)
7530         auto *II = Name.getAsIdentifierInfo();
7531         assert(II && "non-identifier name in C?");
7532         if (II->isOutOfDate())
7533           updateOutOfDateIdentifier(*II);
7534       } else
7535         DC->lookup(Name);
7536     } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7537       // Find all declarations of this kind from the relevant context.
7538       for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7539         auto *DC = cast<DeclContext>(DCDecl);
7540         SmallVector<Decl*, 8> Decls;
7541         FindExternalLexicalDecls(
7542             DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7543       }
7544     }
7545   }
7546 
7547   if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7548     CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7549   if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7550     VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7551   if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7552     if (auto *Template = FD->getPrimaryTemplate())
7553       Template->LoadLazySpecializations();
7554   }
7555 }
7556 
7557 CXXCtorInitializer **
7558 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7559   RecordLocation Loc = getLocalBitOffset(Offset);
7560   BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7561   SavedStreamPosition SavedPosition(Cursor);
7562   if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7563     Error(std::move(Err));
7564     return nullptr;
7565   }
7566   ReadingKindTracker ReadingKind(Read_Decl, *this);
7567   Deserializing D(this);
7568 
7569   Expected<unsigned> MaybeCode = Cursor.ReadCode();
7570   if (!MaybeCode) {
7571     Error(MaybeCode.takeError());
7572     return nullptr;
7573   }
7574   unsigned Code = MaybeCode.get();
7575 
7576   ASTRecordReader Record(*this, *Loc.F);
7577   Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7578   if (!MaybeRecCode) {
7579     Error(MaybeRecCode.takeError());
7580     return nullptr;
7581   }
7582   if (MaybeRecCode.get() != DECL_CXX_CTOR_INITIALIZERS) {
7583     Error("malformed AST file: missing C++ ctor initializers");
7584     return nullptr;
7585   }
7586 
7587   return Record.readCXXCtorInitializers();
7588 }
7589 
7590 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7591   assert(ContextObj && "reading base specifiers with no AST context");
7592   ASTContext &Context = *ContextObj;
7593 
7594   RecordLocation Loc = getLocalBitOffset(Offset);
7595   BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7596   SavedStreamPosition SavedPosition(Cursor);
7597   if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7598     Error(std::move(Err));
7599     return nullptr;
7600   }
7601   ReadingKindTracker ReadingKind(Read_Decl, *this);
7602   Deserializing D(this);
7603 
7604   Expected<unsigned> MaybeCode = Cursor.ReadCode();
7605   if (!MaybeCode) {
7606     Error(MaybeCode.takeError());
7607     return nullptr;
7608   }
7609   unsigned Code = MaybeCode.get();
7610 
7611   ASTRecordReader Record(*this, *Loc.F);
7612   Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7613   if (!MaybeRecCode) {
7614     Error(MaybeCode.takeError());
7615     return nullptr;
7616   }
7617   unsigned RecCode = MaybeRecCode.get();
7618 
7619   if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7620     Error("malformed AST file: missing C++ base specifiers");
7621     return nullptr;
7622   }
7623 
7624   unsigned NumBases = Record.readInt();
7625   void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7626   CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7627   for (unsigned I = 0; I != NumBases; ++I)
7628     Bases[I] = Record.readCXXBaseSpecifier();
7629   return Bases;
7630 }
7631 
7632 serialization::DeclID
7633 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7634   if (LocalID < NUM_PREDEF_DECL_IDS)
7635     return LocalID;
7636 
7637   if (!F.ModuleOffsetMap.empty())
7638     ReadModuleOffsetMap(F);
7639 
7640   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7641     = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7642   assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7643 
7644   return LocalID + I->second;
7645 }
7646 
7647 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7648                                    ModuleFile &M) const {
7649   // Predefined decls aren't from any module.
7650   if (ID < NUM_PREDEF_DECL_IDS)
7651     return false;
7652 
7653   return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7654          ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7655 }
7656 
7657 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7658   if (!D->isFromASTFile())
7659     return nullptr;
7660   GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7661   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7662   return I->second;
7663 }
7664 
7665 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7666   if (ID < NUM_PREDEF_DECL_IDS)
7667     return SourceLocation();
7668 
7669   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7670 
7671   if (Index > DeclsLoaded.size()) {
7672     Error("declaration ID out-of-range for AST file");
7673     return SourceLocation();
7674   }
7675 
7676   if (Decl *D = DeclsLoaded[Index])
7677     return D->getLocation();
7678 
7679   SourceLocation Loc;
7680   DeclCursorForID(ID, Loc);
7681   return Loc;
7682 }
7683 
7684 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7685   switch (ID) {
7686   case PREDEF_DECL_NULL_ID:
7687     return nullptr;
7688 
7689   case PREDEF_DECL_TRANSLATION_UNIT_ID:
7690     return Context.getTranslationUnitDecl();
7691 
7692   case PREDEF_DECL_OBJC_ID_ID:
7693     return Context.getObjCIdDecl();
7694 
7695   case PREDEF_DECL_OBJC_SEL_ID:
7696     return Context.getObjCSelDecl();
7697 
7698   case PREDEF_DECL_OBJC_CLASS_ID:
7699     return Context.getObjCClassDecl();
7700 
7701   case PREDEF_DECL_OBJC_PROTOCOL_ID:
7702     return Context.getObjCProtocolDecl();
7703 
7704   case PREDEF_DECL_INT_128_ID:
7705     return Context.getInt128Decl();
7706 
7707   case PREDEF_DECL_UNSIGNED_INT_128_ID:
7708     return Context.getUInt128Decl();
7709 
7710   case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7711     return Context.getObjCInstanceTypeDecl();
7712 
7713   case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7714     return Context.getBuiltinVaListDecl();
7715 
7716   case PREDEF_DECL_VA_LIST_TAG:
7717     return Context.getVaListTagDecl();
7718 
7719   case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7720     return Context.getBuiltinMSVaListDecl();
7721 
7722   case PREDEF_DECL_BUILTIN_MS_GUID_ID:
7723     return Context.getMSGuidTagDecl();
7724 
7725   case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7726     return Context.getExternCContextDecl();
7727 
7728   case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7729     return Context.getMakeIntegerSeqDecl();
7730 
7731   case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7732     return Context.getCFConstantStringDecl();
7733 
7734   case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7735     return Context.getCFConstantStringTagDecl();
7736 
7737   case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7738     return Context.getTypePackElementDecl();
7739   }
7740   llvm_unreachable("PredefinedDeclIDs unknown enum value");
7741 }
7742 
7743 Decl *ASTReader::GetExistingDecl(DeclID ID) {
7744   assert(ContextObj && "reading decl with no AST context");
7745   if (ID < NUM_PREDEF_DECL_IDS) {
7746     Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7747     if (D) {
7748       // Track that we have merged the declaration with ID \p ID into the
7749       // pre-existing predefined declaration \p D.
7750       auto &Merged = KeyDecls[D->getCanonicalDecl()];
7751       if (Merged.empty())
7752         Merged.push_back(ID);
7753     }
7754     return D;
7755   }
7756 
7757   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7758 
7759   if (Index >= DeclsLoaded.size()) {
7760     assert(0 && "declaration ID out-of-range for AST file");
7761     Error("declaration ID out-of-range for AST file");
7762     return nullptr;
7763   }
7764 
7765   return DeclsLoaded[Index];
7766 }
7767 
7768 Decl *ASTReader::GetDecl(DeclID ID) {
7769   if (ID < NUM_PREDEF_DECL_IDS)
7770     return GetExistingDecl(ID);
7771 
7772   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7773 
7774   if (Index >= DeclsLoaded.size()) {
7775     assert(0 && "declaration ID out-of-range for AST file");
7776     Error("declaration ID out-of-range for AST file");
7777     return nullptr;
7778   }
7779 
7780   if (!DeclsLoaded[Index]) {
7781     ReadDeclRecord(ID);
7782     if (DeserializationListener)
7783       DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7784   }
7785 
7786   return DeclsLoaded[Index];
7787 }
7788 
7789 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7790                                                   DeclID GlobalID) {
7791   if (GlobalID < NUM_PREDEF_DECL_IDS)
7792     return GlobalID;
7793 
7794   GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7795   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7796   ModuleFile *Owner = I->second;
7797 
7798   llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7799     = M.GlobalToLocalDeclIDs.find(Owner);
7800   if (Pos == M.GlobalToLocalDeclIDs.end())
7801     return 0;
7802 
7803   return GlobalID - Owner->BaseDeclID + Pos->second;
7804 }
7805 
7806 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7807                                             const RecordData &Record,
7808                                             unsigned &Idx) {
7809   if (Idx >= Record.size()) {
7810     Error("Corrupted AST file");
7811     return 0;
7812   }
7813 
7814   return getGlobalDeclID(F, Record[Idx++]);
7815 }
7816 
7817 /// Resolve the offset of a statement into a statement.
7818 ///
7819 /// This operation will read a new statement from the external
7820 /// source each time it is called, and is meant to be used via a
7821 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7822 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7823   // Switch case IDs are per Decl.
7824   ClearSwitchCaseIDs();
7825 
7826   // Offset here is a global offset across the entire chain.
7827   RecordLocation Loc = getLocalBitOffset(Offset);
7828   if (llvm::Error Err = Loc.F->DeclsCursor.JumpToBit(Loc.Offset)) {
7829     Error(std::move(Err));
7830     return nullptr;
7831   }
7832   assert(NumCurrentElementsDeserializing == 0 &&
7833          "should not be called while already deserializing");
7834   Deserializing D(this);
7835   return ReadStmtFromStream(*Loc.F);
7836 }
7837 
7838 void ASTReader::FindExternalLexicalDecls(
7839     const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7840     SmallVectorImpl<Decl *> &Decls) {
7841   bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7842 
7843   auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7844     assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7845     for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7846       auto K = (Decl::Kind)+LexicalDecls[I];
7847       if (!IsKindWeWant(K))
7848         continue;
7849 
7850       auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7851 
7852       // Don't add predefined declarations to the lexical context more
7853       // than once.
7854       if (ID < NUM_PREDEF_DECL_IDS) {
7855         if (PredefsVisited[ID])
7856           continue;
7857 
7858         PredefsVisited[ID] = true;
7859       }
7860 
7861       if (Decl *D = GetLocalDecl(*M, ID)) {
7862         assert(D->getKind() == K && "wrong kind for lexical decl");
7863         if (!DC->isDeclInLexicalTraversal(D))
7864           Decls.push_back(D);
7865       }
7866     }
7867   };
7868 
7869   if (isa<TranslationUnitDecl>(DC)) {
7870     for (const auto &Lexical : TULexicalDecls)
7871       Visit(Lexical.first, Lexical.second);
7872   } else {
7873     auto I = LexicalDecls.find(DC);
7874     if (I != LexicalDecls.end())
7875       Visit(I->second.first, I->second.second);
7876   }
7877 
7878   ++NumLexicalDeclContextsRead;
7879 }
7880 
7881 namespace {
7882 
7883 class DeclIDComp {
7884   ASTReader &Reader;
7885   ModuleFile &Mod;
7886 
7887 public:
7888   DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7889 
7890   bool operator()(LocalDeclID L, LocalDeclID R) const {
7891     SourceLocation LHS = getLocation(L);
7892     SourceLocation RHS = getLocation(R);
7893     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7894   }
7895 
7896   bool operator()(SourceLocation LHS, LocalDeclID R) const {
7897     SourceLocation RHS = getLocation(R);
7898     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7899   }
7900 
7901   bool operator()(LocalDeclID L, SourceLocation RHS) const {
7902     SourceLocation LHS = getLocation(L);
7903     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7904   }
7905 
7906   SourceLocation getLocation(LocalDeclID ID) const {
7907     return Reader.getSourceManager().getFileLoc(
7908             Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7909   }
7910 };
7911 
7912 } // namespace
7913 
7914 void ASTReader::FindFileRegionDecls(FileID File,
7915                                     unsigned Offset, unsigned Length,
7916                                     SmallVectorImpl<Decl *> &Decls) {
7917   SourceManager &SM = getSourceManager();
7918 
7919   llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7920   if (I == FileDeclIDs.end())
7921     return;
7922 
7923   FileDeclsInfo &DInfo = I->second;
7924   if (DInfo.Decls.empty())
7925     return;
7926 
7927   SourceLocation
7928     BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7929   SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7930 
7931   DeclIDComp DIDComp(*this, *DInfo.Mod);
7932   ArrayRef<serialization::LocalDeclID>::iterator BeginIt =
7933       llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7934   if (BeginIt != DInfo.Decls.begin())
7935     --BeginIt;
7936 
7937   // If we are pointing at a top-level decl inside an objc container, we need
7938   // to backtrack until we find it otherwise we will fail to report that the
7939   // region overlaps with an objc container.
7940   while (BeginIt != DInfo.Decls.begin() &&
7941          GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7942              ->isTopLevelDeclInObjCContainer())
7943     --BeginIt;
7944 
7945   ArrayRef<serialization::LocalDeclID>::iterator EndIt =
7946       llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7947   if (EndIt != DInfo.Decls.end())
7948     ++EndIt;
7949 
7950   for (ArrayRef<serialization::LocalDeclID>::iterator
7951          DIt = BeginIt; DIt != EndIt; ++DIt)
7952     Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7953 }
7954 
7955 bool
7956 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7957                                           DeclarationName Name) {
7958   assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7959          "DeclContext has no visible decls in storage");
7960   if (!Name)
7961     return false;
7962 
7963   auto It = Lookups.find(DC);
7964   if (It == Lookups.end())
7965     return false;
7966 
7967   Deserializing LookupResults(this);
7968 
7969   // Load the list of declarations.
7970   SmallVector<NamedDecl *, 64> Decls;
7971   llvm::SmallPtrSet<NamedDecl *, 8> Found;
7972   for (DeclID ID : It->second.Table.find(Name)) {
7973     NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7974     if (ND->getDeclName() == Name && Found.insert(ND).second)
7975       Decls.push_back(ND);
7976   }
7977 
7978   ++NumVisibleDeclContextsRead;
7979   SetExternalVisibleDeclsForName(DC, Name, Decls);
7980   return !Decls.empty();
7981 }
7982 
7983 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7984   if (!DC->hasExternalVisibleStorage())
7985     return;
7986 
7987   auto It = Lookups.find(DC);
7988   assert(It != Lookups.end() &&
7989          "have external visible storage but no lookup tables");
7990 
7991   DeclsMap Decls;
7992 
7993   for (DeclID ID : It->second.Table.findAll()) {
7994     NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7995     Decls[ND->getDeclName()].push_back(ND);
7996   }
7997 
7998   ++NumVisibleDeclContextsRead;
7999 
8000   for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
8001     SetExternalVisibleDeclsForName(DC, I->first, I->second);
8002   }
8003   const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
8004 }
8005 
8006 const serialization::reader::DeclContextLookupTable *
8007 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
8008   auto I = Lookups.find(Primary);
8009   return I == Lookups.end() ? nullptr : &I->second;
8010 }
8011 
8012 /// Under non-PCH compilation the consumer receives the objc methods
8013 /// before receiving the implementation, and codegen depends on this.
8014 /// We simulate this by deserializing and passing to consumer the methods of the
8015 /// implementation before passing the deserialized implementation decl.
8016 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
8017                                        ASTConsumer *Consumer) {
8018   assert(ImplD && Consumer);
8019 
8020   for (auto *I : ImplD->methods())
8021     Consumer->HandleInterestingDecl(DeclGroupRef(I));
8022 
8023   Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
8024 }
8025 
8026 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
8027   if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
8028     PassObjCImplDeclToConsumer(ImplD, Consumer);
8029   else
8030     Consumer->HandleInterestingDecl(DeclGroupRef(D));
8031 }
8032 
8033 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
8034   this->Consumer = Consumer;
8035 
8036   if (Consumer)
8037     PassInterestingDeclsToConsumer();
8038 
8039   if (DeserializationListener)
8040     DeserializationListener->ReaderInitialized(this);
8041 }
8042 
8043 void ASTReader::PrintStats() {
8044   std::fprintf(stderr, "*** AST File Statistics:\n");
8045 
8046   unsigned NumTypesLoaded =
8047       TypesLoaded.size() - llvm::count(TypesLoaded.materialized(), QualType());
8048   unsigned NumDeclsLoaded =
8049       DeclsLoaded.size() -
8050       llvm::count(DeclsLoaded.materialized(), (Decl *)nullptr);
8051   unsigned NumIdentifiersLoaded =
8052       IdentifiersLoaded.size() -
8053       llvm::count(IdentifiersLoaded, (IdentifierInfo *)nullptr);
8054   unsigned NumMacrosLoaded =
8055       MacrosLoaded.size() - llvm::count(MacrosLoaded, (MacroInfo *)nullptr);
8056   unsigned NumSelectorsLoaded =
8057       SelectorsLoaded.size() - llvm::count(SelectorsLoaded, Selector());
8058 
8059   if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
8060     std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
8061                  NumSLocEntriesRead, TotalNumSLocEntries,
8062                  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
8063   if (!TypesLoaded.empty())
8064     std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
8065                  NumTypesLoaded, (unsigned)TypesLoaded.size(),
8066                  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
8067   if (!DeclsLoaded.empty())
8068     std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
8069                  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
8070                  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
8071   if (!IdentifiersLoaded.empty())
8072     std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
8073                  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
8074                  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
8075   if (!MacrosLoaded.empty())
8076     std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
8077                  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
8078                  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
8079   if (!SelectorsLoaded.empty())
8080     std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
8081                  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
8082                  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
8083   if (TotalNumStatements)
8084     std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
8085                  NumStatementsRead, TotalNumStatements,
8086                  ((float)NumStatementsRead/TotalNumStatements * 100));
8087   if (TotalNumMacros)
8088     std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
8089                  NumMacrosRead, TotalNumMacros,
8090                  ((float)NumMacrosRead/TotalNumMacros * 100));
8091   if (TotalLexicalDeclContexts)
8092     std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
8093                  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
8094                  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
8095                   * 100));
8096   if (TotalVisibleDeclContexts)
8097     std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
8098                  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
8099                  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
8100                   * 100));
8101   if (TotalNumMethodPoolEntries)
8102     std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
8103                  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
8104                  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
8105                   * 100));
8106   if (NumMethodPoolLookups)
8107     std::fprintf(stderr, "  %u/%u method pool lookups succeeded (%f%%)\n",
8108                  NumMethodPoolHits, NumMethodPoolLookups,
8109                  ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
8110   if (NumMethodPoolTableLookups)
8111     std::fprintf(stderr, "  %u/%u method pool table lookups succeeded (%f%%)\n",
8112                  NumMethodPoolTableHits, NumMethodPoolTableLookups,
8113                  ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
8114                   * 100.0));
8115   if (NumIdentifierLookupHits)
8116     std::fprintf(stderr,
8117                  "  %u / %u identifier table lookups succeeded (%f%%)\n",
8118                  NumIdentifierLookupHits, NumIdentifierLookups,
8119                  (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
8120 
8121   if (GlobalIndex) {
8122     std::fprintf(stderr, "\n");
8123     GlobalIndex->printStats();
8124   }
8125 
8126   std::fprintf(stderr, "\n");
8127   dump();
8128   std::fprintf(stderr, "\n");
8129 }
8130 
8131 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
8132 LLVM_DUMP_METHOD static void
8133 dumpModuleIDMap(StringRef Name,
8134                 const ContinuousRangeMap<Key, ModuleFile *,
8135                                          InitialCapacity> &Map) {
8136   if (Map.begin() == Map.end())
8137     return;
8138 
8139   using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
8140 
8141   llvm::errs() << Name << ":\n";
8142   for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
8143        I != IEnd; ++I) {
8144     llvm::errs() << "  " << I->first << " -> " << I->second->FileName
8145       << "\n";
8146   }
8147 }
8148 
8149 LLVM_DUMP_METHOD void ASTReader::dump() {
8150   llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
8151   dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
8152   dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
8153   dumpModuleIDMap("Global type map", GlobalTypeMap);
8154   dumpModuleIDMap("Global declaration map", GlobalDeclMap);
8155   dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
8156   dumpModuleIDMap("Global macro map", GlobalMacroMap);
8157   dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
8158   dumpModuleIDMap("Global selector map", GlobalSelectorMap);
8159   dumpModuleIDMap("Global preprocessed entity map",
8160                   GlobalPreprocessedEntityMap);
8161 
8162   llvm::errs() << "\n*** PCH/Modules Loaded:";
8163   for (ModuleFile &M : ModuleMgr)
8164     M.dump();
8165 }
8166 
8167 /// Return the amount of memory used by memory buffers, breaking down
8168 /// by heap-backed versus mmap'ed memory.
8169 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
8170   for (ModuleFile &I : ModuleMgr) {
8171     if (llvm::MemoryBuffer *buf = I.Buffer) {
8172       size_t bytes = buf->getBufferSize();
8173       switch (buf->getBufferKind()) {
8174         case llvm::MemoryBuffer::MemoryBuffer_Malloc:
8175           sizes.malloc_bytes += bytes;
8176           break;
8177         case llvm::MemoryBuffer::MemoryBuffer_MMap:
8178           sizes.mmap_bytes += bytes;
8179           break;
8180       }
8181     }
8182   }
8183 }
8184 
8185 void ASTReader::InitializeSema(Sema &S) {
8186   SemaObj = &S;
8187   S.addExternalSource(this);
8188 
8189   // Makes sure any declarations that were deserialized "too early"
8190   // still get added to the identifier's declaration chains.
8191   for (uint64_t ID : PreloadedDeclIDs) {
8192     NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
8193     pushExternalDeclIntoScope(D, D->getDeclName());
8194   }
8195   PreloadedDeclIDs.clear();
8196 
8197   // FIXME: What happens if these are changed by a module import?
8198   if (!FPPragmaOptions.empty()) {
8199     assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
8200     FPOptionsOverride NewOverrides =
8201         FPOptionsOverride::getFromOpaqueInt(FPPragmaOptions[0]);
8202     SemaObj->CurFPFeatures =
8203         NewOverrides.applyOverrides(SemaObj->getLangOpts());
8204   }
8205 
8206   SemaObj->OpenCLFeatures = OpenCLExtensions;
8207 
8208   UpdateSema();
8209 }
8210 
8211 void ASTReader::UpdateSema() {
8212   assert(SemaObj && "no Sema to update");
8213 
8214   // Load the offsets of the declarations that Sema references.
8215   // They will be lazily deserialized when needed.
8216   if (!SemaDeclRefs.empty()) {
8217     assert(SemaDeclRefs.size() % 3 == 0);
8218     for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
8219       if (!SemaObj->StdNamespace)
8220         SemaObj->StdNamespace = SemaDeclRefs[I];
8221       if (!SemaObj->StdBadAlloc)
8222         SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
8223       if (!SemaObj->StdAlignValT)
8224         SemaObj->StdAlignValT = SemaDeclRefs[I+2];
8225     }
8226     SemaDeclRefs.clear();
8227   }
8228 
8229   // Update the state of pragmas. Use the same API as if we had encountered the
8230   // pragma in the source.
8231   if(OptimizeOffPragmaLocation.isValid())
8232     SemaObj->ActOnPragmaOptimize(/* On = */ false, OptimizeOffPragmaLocation);
8233   if (PragmaMSStructState != -1)
8234     SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
8235   if (PointersToMembersPragmaLocation.isValid()) {
8236     SemaObj->ActOnPragmaMSPointersToMembers(
8237         (LangOptions::PragmaMSPointersToMembersKind)
8238             PragmaMSPointersToMembersState,
8239         PointersToMembersPragmaLocation);
8240   }
8241   SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
8242 
8243   if (PragmaAlignPackCurrentValue) {
8244     // The bottom of the stack might have a default value. It must be adjusted
8245     // to the current value to ensure that the packing state is preserved after
8246     // popping entries that were included/imported from a PCH/module.
8247     bool DropFirst = false;
8248     if (!PragmaAlignPackStack.empty() &&
8249         PragmaAlignPackStack.front().Location.isInvalid()) {
8250       assert(PragmaAlignPackStack.front().Value ==
8251                  SemaObj->AlignPackStack.DefaultValue &&
8252              "Expected a default alignment value");
8253       SemaObj->AlignPackStack.Stack.emplace_back(
8254           PragmaAlignPackStack.front().SlotLabel,
8255           SemaObj->AlignPackStack.CurrentValue,
8256           SemaObj->AlignPackStack.CurrentPragmaLocation,
8257           PragmaAlignPackStack.front().PushLocation);
8258       DropFirst = true;
8259     }
8260     for (const auto &Entry :
8261          llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
8262       SemaObj->AlignPackStack.Stack.emplace_back(
8263           Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8264     }
8265     if (PragmaAlignPackCurrentLocation.isInvalid()) {
8266       assert(*PragmaAlignPackCurrentValue ==
8267                  SemaObj->AlignPackStack.DefaultValue &&
8268              "Expected a default align and pack value");
8269       // Keep the current values.
8270     } else {
8271       SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
8272       SemaObj->AlignPackStack.CurrentPragmaLocation =
8273           PragmaAlignPackCurrentLocation;
8274     }
8275   }
8276   if (FpPragmaCurrentValue) {
8277     // The bottom of the stack might have a default value. It must be adjusted
8278     // to the current value to ensure that fp-pragma state is preserved after
8279     // popping entries that were included/imported from a PCH/module.
8280     bool DropFirst = false;
8281     if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
8282       assert(FpPragmaStack.front().Value ==
8283                  SemaObj->FpPragmaStack.DefaultValue &&
8284              "Expected a default pragma float_control value");
8285       SemaObj->FpPragmaStack.Stack.emplace_back(
8286           FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
8287           SemaObj->FpPragmaStack.CurrentPragmaLocation,
8288           FpPragmaStack.front().PushLocation);
8289       DropFirst = true;
8290     }
8291     for (const auto &Entry :
8292          llvm::ArrayRef(FpPragmaStack).drop_front(DropFirst ? 1 : 0))
8293       SemaObj->FpPragmaStack.Stack.emplace_back(
8294           Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8295     if (FpPragmaCurrentLocation.isInvalid()) {
8296       assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
8297              "Expected a default pragma float_control value");
8298       // Keep the current values.
8299     } else {
8300       SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
8301       SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
8302     }
8303   }
8304 
8305   // For non-modular AST files, restore visiblity of modules.
8306   for (auto &Import : PendingImportedModulesSema) {
8307     if (Import.ImportLoc.isInvalid())
8308       continue;
8309     if (Module *Imported = getSubmodule(Import.ID)) {
8310       SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8311     }
8312   }
8313   PendingImportedModulesSema.clear();
8314 }
8315 
8316 IdentifierInfo *ASTReader::get(StringRef Name) {
8317   // Note that we are loading an identifier.
8318   Deserializing AnIdentifier(this);
8319 
8320   IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
8321                                   NumIdentifierLookups,
8322                                   NumIdentifierLookupHits);
8323 
8324   // We don't need to do identifier table lookups in C++ modules (we preload
8325   // all interesting declarations, and don't need to use the scope for name
8326   // lookups). Perform the lookup in PCH files, though, since we don't build
8327   // a complete initial identifier table if we're carrying on from a PCH.
8328   if (PP.getLangOpts().CPlusPlus) {
8329     for (auto *F : ModuleMgr.pch_modules())
8330       if (Visitor(*F))
8331         break;
8332   } else {
8333     // If there is a global index, look there first to determine which modules
8334     // provably do not have any results for this identifier.
8335     GlobalModuleIndex::HitSet Hits;
8336     GlobalModuleIndex::HitSet *HitsPtr = nullptr;
8337     if (!loadGlobalIndex()) {
8338       if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8339         HitsPtr = &Hits;
8340       }
8341     }
8342 
8343     ModuleMgr.visit(Visitor, HitsPtr);
8344   }
8345 
8346   IdentifierInfo *II = Visitor.getIdentifierInfo();
8347   markIdentifierUpToDate(II);
8348   return II;
8349 }
8350 
8351 namespace clang {
8352 
8353   /// An identifier-lookup iterator that enumerates all of the
8354   /// identifiers stored within a set of AST files.
8355   class ASTIdentifierIterator : public IdentifierIterator {
8356     /// The AST reader whose identifiers are being enumerated.
8357     const ASTReader &Reader;
8358 
8359     /// The current index into the chain of AST files stored in
8360     /// the AST reader.
8361     unsigned Index;
8362 
8363     /// The current position within the identifier lookup table
8364     /// of the current AST file.
8365     ASTIdentifierLookupTable::key_iterator Current;
8366 
8367     /// The end position within the identifier lookup table of
8368     /// the current AST file.
8369     ASTIdentifierLookupTable::key_iterator End;
8370 
8371     /// Whether to skip any modules in the ASTReader.
8372     bool SkipModules;
8373 
8374   public:
8375     explicit ASTIdentifierIterator(const ASTReader &Reader,
8376                                    bool SkipModules = false);
8377 
8378     StringRef Next() override;
8379   };
8380 
8381 } // namespace clang
8382 
8383 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
8384                                              bool SkipModules)
8385     : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8386 }
8387 
8388 StringRef ASTIdentifierIterator::Next() {
8389   while (Current == End) {
8390     // If we have exhausted all of our AST files, we're done.
8391     if (Index == 0)
8392       return StringRef();
8393 
8394     --Index;
8395     ModuleFile &F = Reader.ModuleMgr[Index];
8396     if (SkipModules && F.isModule())
8397       continue;
8398 
8399     ASTIdentifierLookupTable *IdTable =
8400         (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
8401     Current = IdTable->key_begin();
8402     End = IdTable->key_end();
8403   }
8404 
8405   // We have any identifiers remaining in the current AST file; return
8406   // the next one.
8407   StringRef Result = *Current;
8408   ++Current;
8409   return Result;
8410 }
8411 
8412 namespace {
8413 
8414 /// A utility for appending two IdentifierIterators.
8415 class ChainedIdentifierIterator : public IdentifierIterator {
8416   std::unique_ptr<IdentifierIterator> Current;
8417   std::unique_ptr<IdentifierIterator> Queued;
8418 
8419 public:
8420   ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
8421                             std::unique_ptr<IdentifierIterator> Second)
8422       : Current(std::move(First)), Queued(std::move(Second)) {}
8423 
8424   StringRef Next() override {
8425     if (!Current)
8426       return StringRef();
8427 
8428     StringRef result = Current->Next();
8429     if (!result.empty())
8430       return result;
8431 
8432     // Try the queued iterator, which may itself be empty.
8433     Current.reset();
8434     std::swap(Current, Queued);
8435     return Next();
8436   }
8437 };
8438 
8439 } // namespace
8440 
8441 IdentifierIterator *ASTReader::getIdentifiers() {
8442   if (!loadGlobalIndex()) {
8443     std::unique_ptr<IdentifierIterator> ReaderIter(
8444         new ASTIdentifierIterator(*this, /*SkipModules=*/true));
8445     std::unique_ptr<IdentifierIterator> ModulesIter(
8446         GlobalIndex->createIdentifierIterator());
8447     return new ChainedIdentifierIterator(std::move(ReaderIter),
8448                                          std::move(ModulesIter));
8449   }
8450 
8451   return new ASTIdentifierIterator(*this);
8452 }
8453 
8454 namespace clang {
8455 namespace serialization {
8456 
8457   class ReadMethodPoolVisitor {
8458     ASTReader &Reader;
8459     Selector Sel;
8460     unsigned PriorGeneration;
8461     unsigned InstanceBits = 0;
8462     unsigned FactoryBits = 0;
8463     bool InstanceHasMoreThanOneDecl = false;
8464     bool FactoryHasMoreThanOneDecl = false;
8465     SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8466     SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8467 
8468   public:
8469     ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8470                           unsigned PriorGeneration)
8471         : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8472 
8473     bool operator()(ModuleFile &M) {
8474       if (!M.SelectorLookupTable)
8475         return false;
8476 
8477       // If we've already searched this module file, skip it now.
8478       if (M.Generation <= PriorGeneration)
8479         return true;
8480 
8481       ++Reader.NumMethodPoolTableLookups;
8482       ASTSelectorLookupTable *PoolTable
8483         = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8484       ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8485       if (Pos == PoolTable->end())
8486         return false;
8487 
8488       ++Reader.NumMethodPoolTableHits;
8489       ++Reader.NumSelectorsRead;
8490       // FIXME: Not quite happy with the statistics here. We probably should
8491       // disable this tracking when called via LoadSelector.
8492       // Also, should entries without methods count as misses?
8493       ++Reader.NumMethodPoolEntriesRead;
8494       ASTSelectorLookupTrait::data_type Data = *Pos;
8495       if (Reader.DeserializationListener)
8496         Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8497 
8498       // Append methods in the reverse order, so that later we can process them
8499       // in the order they appear in the source code by iterating through
8500       // the vector in the reverse order.
8501       InstanceMethods.append(Data.Instance.rbegin(), Data.Instance.rend());
8502       FactoryMethods.append(Data.Factory.rbegin(), Data.Factory.rend());
8503       InstanceBits = Data.InstanceBits;
8504       FactoryBits = Data.FactoryBits;
8505       InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8506       FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8507       return false;
8508     }
8509 
8510     /// Retrieve the instance methods found by this visitor.
8511     ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8512       return InstanceMethods;
8513     }
8514 
8515     /// Retrieve the instance methods found by this visitor.
8516     ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8517       return FactoryMethods;
8518     }
8519 
8520     unsigned getInstanceBits() const { return InstanceBits; }
8521     unsigned getFactoryBits() const { return FactoryBits; }
8522 
8523     bool instanceHasMoreThanOneDecl() const {
8524       return InstanceHasMoreThanOneDecl;
8525     }
8526 
8527     bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8528   };
8529 
8530 } // namespace serialization
8531 } // namespace clang
8532 
8533 /// Add the given set of methods to the method list.
8534 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8535                              ObjCMethodList &List) {
8536   for (ObjCMethodDecl *M : llvm::reverse(Methods))
8537     S.addMethodToGlobalList(&List, M);
8538 }
8539 
8540 void ASTReader::ReadMethodPool(Selector Sel) {
8541   // Get the selector generation and update it to the current generation.
8542   unsigned &Generation = SelectorGeneration[Sel];
8543   unsigned PriorGeneration = Generation;
8544   Generation = getGeneration();
8545   SelectorOutOfDate[Sel] = false;
8546 
8547   // Search for methods defined with this selector.
8548   ++NumMethodPoolLookups;
8549   ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8550   ModuleMgr.visit(Visitor);
8551 
8552   if (Visitor.getInstanceMethods().empty() &&
8553       Visitor.getFactoryMethods().empty())
8554     return;
8555 
8556   ++NumMethodPoolHits;
8557 
8558   if (!getSema())
8559     return;
8560 
8561   Sema &S = *getSema();
8562   Sema::GlobalMethodPool::iterator Pos =
8563       S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethodPool::Lists()))
8564           .first;
8565 
8566   Pos->second.first.setBits(Visitor.getInstanceBits());
8567   Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8568   Pos->second.second.setBits(Visitor.getFactoryBits());
8569   Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8570 
8571   // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8572   // when building a module we keep every method individually and may need to
8573   // update hasMoreThanOneDecl as we add the methods.
8574   addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8575   addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8576 }
8577 
8578 void ASTReader::updateOutOfDateSelector(Selector Sel) {
8579   if (SelectorOutOfDate[Sel])
8580     ReadMethodPool(Sel);
8581 }
8582 
8583 void ASTReader::ReadKnownNamespaces(
8584                           SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8585   Namespaces.clear();
8586 
8587   for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8588     if (NamespaceDecl *Namespace
8589                 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8590       Namespaces.push_back(Namespace);
8591   }
8592 }
8593 
8594 void ASTReader::ReadUndefinedButUsed(
8595     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8596   for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8597     NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8598     SourceLocation Loc =
8599         SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8600     Undefined.insert(std::make_pair(D, Loc));
8601   }
8602 }
8603 
8604 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8605     FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8606                                                      Exprs) {
8607   for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8608     FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8609     uint64_t Count = DelayedDeleteExprs[Idx++];
8610     for (uint64_t C = 0; C < Count; ++C) {
8611       SourceLocation DeleteLoc =
8612           SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8613       const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8614       Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8615     }
8616   }
8617 }
8618 
8619 void ASTReader::ReadTentativeDefinitions(
8620                   SmallVectorImpl<VarDecl *> &TentativeDefs) {
8621   for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8622     VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8623     if (Var)
8624       TentativeDefs.push_back(Var);
8625   }
8626   TentativeDefinitions.clear();
8627 }
8628 
8629 void ASTReader::ReadUnusedFileScopedDecls(
8630                                SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8631   for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8632     DeclaratorDecl *D
8633       = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8634     if (D)
8635       Decls.push_back(D);
8636   }
8637   UnusedFileScopedDecls.clear();
8638 }
8639 
8640 void ASTReader::ReadDelegatingConstructors(
8641                                  SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8642   for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8643     CXXConstructorDecl *D
8644       = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8645     if (D)
8646       Decls.push_back(D);
8647   }
8648   DelegatingCtorDecls.clear();
8649 }
8650 
8651 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8652   for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8653     TypedefNameDecl *D
8654       = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8655     if (D)
8656       Decls.push_back(D);
8657   }
8658   ExtVectorDecls.clear();
8659 }
8660 
8661 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8662     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8663   for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8664        ++I) {
8665     TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8666         GetDecl(UnusedLocalTypedefNameCandidates[I]));
8667     if (D)
8668       Decls.insert(D);
8669   }
8670   UnusedLocalTypedefNameCandidates.clear();
8671 }
8672 
8673 void ASTReader::ReadDeclsToCheckForDeferredDiags(
8674     llvm::SmallSetVector<Decl *, 4> &Decls) {
8675   for (auto I : DeclsToCheckForDeferredDiags) {
8676     auto *D = dyn_cast_or_null<Decl>(GetDecl(I));
8677     if (D)
8678       Decls.insert(D);
8679   }
8680   DeclsToCheckForDeferredDiags.clear();
8681 }
8682 
8683 void ASTReader::ReadReferencedSelectors(
8684        SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8685   if (ReferencedSelectorsData.empty())
8686     return;
8687 
8688   // If there are @selector references added them to its pool. This is for
8689   // implementation of -Wselector.
8690   unsigned int DataSize = ReferencedSelectorsData.size()-1;
8691   unsigned I = 0;
8692   while (I < DataSize) {
8693     Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8694     SourceLocation SelLoc
8695       = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8696     Sels.push_back(std::make_pair(Sel, SelLoc));
8697   }
8698   ReferencedSelectorsData.clear();
8699 }
8700 
8701 void ASTReader::ReadWeakUndeclaredIdentifiers(
8702        SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8703   if (WeakUndeclaredIdentifiers.empty())
8704     return;
8705 
8706   for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8707     IdentifierInfo *WeakId
8708       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8709     IdentifierInfo *AliasId
8710       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8711     SourceLocation Loc =
8712         SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8713     WeakInfo WI(AliasId, Loc);
8714     WeakIDs.push_back(std::make_pair(WeakId, WI));
8715   }
8716   WeakUndeclaredIdentifiers.clear();
8717 }
8718 
8719 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8720   for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8721     ExternalVTableUse VT;
8722     VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8723     VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8724     VT.DefinitionRequired = VTableUses[Idx++];
8725     VTables.push_back(VT);
8726   }
8727 
8728   VTableUses.clear();
8729 }
8730 
8731 void ASTReader::ReadPendingInstantiations(
8732        SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8733   for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8734     ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8735     SourceLocation Loc
8736       = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8737 
8738     Pending.push_back(std::make_pair(D, Loc));
8739   }
8740   PendingInstantiations.clear();
8741 }
8742 
8743 void ASTReader::ReadLateParsedTemplates(
8744     llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8745         &LPTMap) {
8746   for (auto &LPT : LateParsedTemplates) {
8747     ModuleFile *FMod = LPT.first;
8748     RecordDataImpl &LateParsed = LPT.second;
8749     for (unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8750          /* In loop */) {
8751       FunctionDecl *FD =
8752           cast<FunctionDecl>(GetLocalDecl(*FMod, LateParsed[Idx++]));
8753 
8754       auto LT = std::make_unique<LateParsedTemplate>();
8755       LT->D = GetLocalDecl(*FMod, LateParsed[Idx++]);
8756       LT->FPO = FPOptions::getFromOpaqueInt(LateParsed[Idx++]);
8757 
8758       ModuleFile *F = getOwningModuleFile(LT->D);
8759       assert(F && "No module");
8760 
8761       unsigned TokN = LateParsed[Idx++];
8762       LT->Toks.reserve(TokN);
8763       for (unsigned T = 0; T < TokN; ++T)
8764         LT->Toks.push_back(ReadToken(*F, LateParsed, Idx));
8765 
8766       LPTMap.insert(std::make_pair(FD, std::move(LT)));
8767     }
8768   }
8769 
8770   LateParsedTemplates.clear();
8771 }
8772 
8773 void ASTReader::AssignedLambdaNumbering(const CXXRecordDecl *Lambda) {
8774   if (Lambda->getLambdaContextDecl()) {
8775     // Keep track of this lambda so it can be merged with another lambda that
8776     // is loaded later.
8777     LambdaDeclarationsForMerging.insert(
8778         {{Lambda->getLambdaContextDecl()->getCanonicalDecl(),
8779           Lambda->getLambdaIndexInContext()},
8780          const_cast<CXXRecordDecl *>(Lambda)});
8781   }
8782 }
8783 
8784 void ASTReader::LoadSelector(Selector Sel) {
8785   // It would be complicated to avoid reading the methods anyway. So don't.
8786   ReadMethodPool(Sel);
8787 }
8788 
8789 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8790   assert(ID && "Non-zero identifier ID required");
8791   assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8792   IdentifiersLoaded[ID - 1] = II;
8793   if (DeserializationListener)
8794     DeserializationListener->IdentifierRead(ID, II);
8795 }
8796 
8797 /// Set the globally-visible declarations associated with the given
8798 /// identifier.
8799 ///
8800 /// If the AST reader is currently in a state where the given declaration IDs
8801 /// cannot safely be resolved, they are queued until it is safe to resolve
8802 /// them.
8803 ///
8804 /// \param II an IdentifierInfo that refers to one or more globally-visible
8805 /// declarations.
8806 ///
8807 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8808 /// visible at global scope.
8809 ///
8810 /// \param Decls if non-null, this vector will be populated with the set of
8811 /// deserialized declarations. These declarations will not be pushed into
8812 /// scope.
8813 void
8814 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8815                               const SmallVectorImpl<uint32_t> &DeclIDs,
8816                                    SmallVectorImpl<Decl *> *Decls) {
8817   if (NumCurrentElementsDeserializing && !Decls) {
8818     PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8819     return;
8820   }
8821 
8822   for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8823     if (!SemaObj) {
8824       // Queue this declaration so that it will be added to the
8825       // translation unit scope and identifier's declaration chain
8826       // once a Sema object is known.
8827       PreloadedDeclIDs.push_back(DeclIDs[I]);
8828       continue;
8829     }
8830 
8831     NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8832 
8833     // If we're simply supposed to record the declarations, do so now.
8834     if (Decls) {
8835       Decls->push_back(D);
8836       continue;
8837     }
8838 
8839     // Introduce this declaration into the translation-unit scope
8840     // and add it to the declaration chain for this identifier, so
8841     // that (unqualified) name lookup will find it.
8842     pushExternalDeclIntoScope(D, II);
8843   }
8844 }
8845 
8846 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8847   if (ID == 0)
8848     return nullptr;
8849 
8850   if (IdentifiersLoaded.empty()) {
8851     Error("no identifier table in AST file");
8852     return nullptr;
8853   }
8854 
8855   ID -= 1;
8856   if (!IdentifiersLoaded[ID]) {
8857     GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8858     assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8859     ModuleFile *M = I->second;
8860     unsigned Index = ID - M->BaseIdentifierID;
8861     const unsigned char *Data =
8862         M->IdentifierTableData + M->IdentifierOffsets[Index];
8863 
8864     ASTIdentifierLookupTrait Trait(*this, *M);
8865     auto KeyDataLen = Trait.ReadKeyDataLength(Data);
8866     auto Key = Trait.ReadKey(Data, KeyDataLen.first);
8867     auto &II = PP.getIdentifierTable().get(Key);
8868     IdentifiersLoaded[ID] = &II;
8869     markIdentifierFromAST(*this,  II);
8870     if (DeserializationListener)
8871       DeserializationListener->IdentifierRead(ID + 1, &II);
8872   }
8873 
8874   return IdentifiersLoaded[ID];
8875 }
8876 
8877 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8878   return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8879 }
8880 
8881 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8882   if (LocalID < NUM_PREDEF_IDENT_IDS)
8883     return LocalID;
8884 
8885   if (!M.ModuleOffsetMap.empty())
8886     ReadModuleOffsetMap(M);
8887 
8888   ContinuousRangeMap<uint32_t, int, 2>::iterator I
8889     = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8890   assert(I != M.IdentifierRemap.end()
8891          && "Invalid index into identifier index remap");
8892 
8893   return LocalID + I->second;
8894 }
8895 
8896 MacroInfo *ASTReader::getMacro(MacroID ID) {
8897   if (ID == 0)
8898     return nullptr;
8899 
8900   if (MacrosLoaded.empty()) {
8901     Error("no macro table in AST file");
8902     return nullptr;
8903   }
8904 
8905   ID -= NUM_PREDEF_MACRO_IDS;
8906   if (!MacrosLoaded[ID]) {
8907     GlobalMacroMapType::iterator I
8908       = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8909     assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8910     ModuleFile *M = I->second;
8911     unsigned Index = ID - M->BaseMacroID;
8912     MacrosLoaded[ID] =
8913         ReadMacroRecord(*M, M->MacroOffsetsBase + M->MacroOffsets[Index]);
8914 
8915     if (DeserializationListener)
8916       DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8917                                          MacrosLoaded[ID]);
8918   }
8919 
8920   return MacrosLoaded[ID];
8921 }
8922 
8923 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8924   if (LocalID < NUM_PREDEF_MACRO_IDS)
8925     return LocalID;
8926 
8927   if (!M.ModuleOffsetMap.empty())
8928     ReadModuleOffsetMap(M);
8929 
8930   ContinuousRangeMap<uint32_t, int, 2>::iterator I
8931     = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8932   assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8933 
8934   return LocalID + I->second;
8935 }
8936 
8937 serialization::SubmoduleID
8938 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8939   if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8940     return LocalID;
8941 
8942   if (!M.ModuleOffsetMap.empty())
8943     ReadModuleOffsetMap(M);
8944 
8945   ContinuousRangeMap<uint32_t, int, 2>::iterator I
8946     = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8947   assert(I != M.SubmoduleRemap.end()
8948          && "Invalid index into submodule index remap");
8949 
8950   return LocalID + I->second;
8951 }
8952 
8953 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8954   if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8955     assert(GlobalID == 0 && "Unhandled global submodule ID");
8956     return nullptr;
8957   }
8958 
8959   if (GlobalID > SubmodulesLoaded.size()) {
8960     Error("submodule ID out of range in AST file");
8961     return nullptr;
8962   }
8963 
8964   return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8965 }
8966 
8967 Module *ASTReader::getModule(unsigned ID) {
8968   return getSubmodule(ID);
8969 }
8970 
8971 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &M, unsigned ID) {
8972   if (ID & 1) {
8973     // It's a module, look it up by submodule ID.
8974     auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(M, ID >> 1));
8975     return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8976   } else {
8977     // It's a prefix (preamble, PCH, ...). Look it up by index.
8978     unsigned IndexFromEnd = ID >> 1;
8979     assert(IndexFromEnd && "got reference to unknown module file");
8980     return getModuleManager().pch_modules().end()[-IndexFromEnd];
8981   }
8982 }
8983 
8984 unsigned ASTReader::getModuleFileID(ModuleFile *M) {
8985   if (!M)
8986     return 1;
8987 
8988   // For a file representing a module, use the submodule ID of the top-level
8989   // module as the file ID. For any other kind of file, the number of such
8990   // files loaded beforehand will be the same on reload.
8991   // FIXME: Is this true even if we have an explicit module file and a PCH?
8992   if (M->isModule())
8993     return ((M->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8994 
8995   auto PCHModules = getModuleManager().pch_modules();
8996   auto I = llvm::find(PCHModules, M);
8997   assert(I != PCHModules.end() && "emitting reference to unknown file");
8998   return (I - PCHModules.end()) << 1;
8999 }
9000 
9001 std::optional<ASTSourceDescriptor> ASTReader::getSourceDescriptor(unsigned ID) {
9002   if (Module *M = getSubmodule(ID))
9003     return ASTSourceDescriptor(*M);
9004 
9005   // If there is only a single PCH, return it instead.
9006   // Chained PCH are not supported.
9007   const auto &PCHChain = ModuleMgr.pch_modules();
9008   if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
9009     ModuleFile &MF = ModuleMgr.getPrimaryModule();
9010     StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
9011     StringRef FileName = llvm::sys::path::filename(MF.FileName);
9012     return ASTSourceDescriptor(ModuleName,
9013                                llvm::sys::path::parent_path(MF.FileName),
9014                                FileName, MF.Signature);
9015   }
9016   return std::nullopt;
9017 }
9018 
9019 ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
9020   auto I = DefinitionSource.find(FD);
9021   if (I == DefinitionSource.end())
9022     return EK_ReplyHazy;
9023   return I->second ? EK_Never : EK_Always;
9024 }
9025 
9026 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
9027   return DecodeSelector(getGlobalSelectorID(M, LocalID));
9028 }
9029 
9030 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
9031   if (ID == 0)
9032     return Selector();
9033 
9034   if (ID > SelectorsLoaded.size()) {
9035     Error("selector ID out of range in AST file");
9036     return Selector();
9037   }
9038 
9039   if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
9040     // Load this selector from the selector table.
9041     GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
9042     assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
9043     ModuleFile &M = *I->second;
9044     ASTSelectorLookupTrait Trait(*this, M);
9045     unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
9046     SelectorsLoaded[ID - 1] =
9047       Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
9048     if (DeserializationListener)
9049       DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
9050   }
9051 
9052   return SelectorsLoaded[ID - 1];
9053 }
9054 
9055 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
9056   return DecodeSelector(ID);
9057 }
9058 
9059 uint32_t ASTReader::GetNumExternalSelectors() {
9060   // ID 0 (the null selector) is considered an external selector.
9061   return getTotalNumSelectors() + 1;
9062 }
9063 
9064 serialization::SelectorID
9065 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
9066   if (LocalID < NUM_PREDEF_SELECTOR_IDS)
9067     return LocalID;
9068 
9069   if (!M.ModuleOffsetMap.empty())
9070     ReadModuleOffsetMap(M);
9071 
9072   ContinuousRangeMap<uint32_t, int, 2>::iterator I
9073     = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
9074   assert(I != M.SelectorRemap.end()
9075          && "Invalid index into selector index remap");
9076 
9077   return LocalID + I->second;
9078 }
9079 
9080 DeclarationNameLoc
9081 ASTRecordReader::readDeclarationNameLoc(DeclarationName Name) {
9082   switch (Name.getNameKind()) {
9083   case DeclarationName::CXXConstructorName:
9084   case DeclarationName::CXXDestructorName:
9085   case DeclarationName::CXXConversionFunctionName:
9086     return DeclarationNameLoc::makeNamedTypeLoc(readTypeSourceInfo());
9087 
9088   case DeclarationName::CXXOperatorName:
9089     return DeclarationNameLoc::makeCXXOperatorNameLoc(readSourceRange());
9090 
9091   case DeclarationName::CXXLiteralOperatorName:
9092     return DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(
9093         readSourceLocation());
9094 
9095   case DeclarationName::Identifier:
9096   case DeclarationName::ObjCZeroArgSelector:
9097   case DeclarationName::ObjCOneArgSelector:
9098   case DeclarationName::ObjCMultiArgSelector:
9099   case DeclarationName::CXXUsingDirective:
9100   case DeclarationName::CXXDeductionGuideName:
9101     break;
9102   }
9103   return DeclarationNameLoc();
9104 }
9105 
9106 DeclarationNameInfo ASTRecordReader::readDeclarationNameInfo() {
9107   DeclarationNameInfo NameInfo;
9108   NameInfo.setName(readDeclarationName());
9109   NameInfo.setLoc(readSourceLocation());
9110   NameInfo.setInfo(readDeclarationNameLoc(NameInfo.getName()));
9111   return NameInfo;
9112 }
9113 
9114 void ASTRecordReader::readQualifierInfo(QualifierInfo &Info) {
9115   Info.QualifierLoc = readNestedNameSpecifierLoc();
9116   unsigned NumTPLists = readInt();
9117   Info.NumTemplParamLists = NumTPLists;
9118   if (NumTPLists) {
9119     Info.TemplParamLists =
9120         new (getContext()) TemplateParameterList *[NumTPLists];
9121     for (unsigned i = 0; i != NumTPLists; ++i)
9122       Info.TemplParamLists[i] = readTemplateParameterList();
9123   }
9124 }
9125 
9126 TemplateParameterList *
9127 ASTRecordReader::readTemplateParameterList() {
9128   SourceLocation TemplateLoc = readSourceLocation();
9129   SourceLocation LAngleLoc = readSourceLocation();
9130   SourceLocation RAngleLoc = readSourceLocation();
9131 
9132   unsigned NumParams = readInt();
9133   SmallVector<NamedDecl *, 16> Params;
9134   Params.reserve(NumParams);
9135   while (NumParams--)
9136     Params.push_back(readDeclAs<NamedDecl>());
9137 
9138   bool HasRequiresClause = readBool();
9139   Expr *RequiresClause = HasRequiresClause ? readExpr() : nullptr;
9140 
9141   TemplateParameterList *TemplateParams = TemplateParameterList::Create(
9142       getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
9143   return TemplateParams;
9144 }
9145 
9146 void ASTRecordReader::readTemplateArgumentList(
9147                         SmallVectorImpl<TemplateArgument> &TemplArgs,
9148                         bool Canonicalize) {
9149   unsigned NumTemplateArgs = readInt();
9150   TemplArgs.reserve(NumTemplateArgs);
9151   while (NumTemplateArgs--)
9152     TemplArgs.push_back(readTemplateArgument(Canonicalize));
9153 }
9154 
9155 /// Read a UnresolvedSet structure.
9156 void ASTRecordReader::readUnresolvedSet(LazyASTUnresolvedSet &Set) {
9157   unsigned NumDecls = readInt();
9158   Set.reserve(getContext(), NumDecls);
9159   while (NumDecls--) {
9160     DeclID ID = readDeclID();
9161     AccessSpecifier AS = (AccessSpecifier) readInt();
9162     Set.addLazyDecl(getContext(), ID, AS);
9163   }
9164 }
9165 
9166 CXXBaseSpecifier
9167 ASTRecordReader::readCXXBaseSpecifier() {
9168   bool isVirtual = readBool();
9169   bool isBaseOfClass = readBool();
9170   AccessSpecifier AS = static_cast<AccessSpecifier>(readInt());
9171   bool inheritConstructors = readBool();
9172   TypeSourceInfo *TInfo = readTypeSourceInfo();
9173   SourceRange Range = readSourceRange();
9174   SourceLocation EllipsisLoc = readSourceLocation();
9175   CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
9176                           EllipsisLoc);
9177   Result.setInheritConstructors(inheritConstructors);
9178   return Result;
9179 }
9180 
9181 CXXCtorInitializer **
9182 ASTRecordReader::readCXXCtorInitializers() {
9183   ASTContext &Context = getContext();
9184   unsigned NumInitializers = readInt();
9185   assert(NumInitializers && "wrote ctor initializers but have no inits");
9186   auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
9187   for (unsigned i = 0; i != NumInitializers; ++i) {
9188     TypeSourceInfo *TInfo = nullptr;
9189     bool IsBaseVirtual = false;
9190     FieldDecl *Member = nullptr;
9191     IndirectFieldDecl *IndirectMember = nullptr;
9192 
9193     CtorInitializerType Type = (CtorInitializerType) readInt();
9194     switch (Type) {
9195     case CTOR_INITIALIZER_BASE:
9196       TInfo = readTypeSourceInfo();
9197       IsBaseVirtual = readBool();
9198       break;
9199 
9200     case CTOR_INITIALIZER_DELEGATING:
9201       TInfo = readTypeSourceInfo();
9202       break;
9203 
9204      case CTOR_INITIALIZER_MEMBER:
9205       Member = readDeclAs<FieldDecl>();
9206       break;
9207 
9208      case CTOR_INITIALIZER_INDIRECT_MEMBER:
9209       IndirectMember = readDeclAs<IndirectFieldDecl>();
9210       break;
9211     }
9212 
9213     SourceLocation MemberOrEllipsisLoc = readSourceLocation();
9214     Expr *Init = readExpr();
9215     SourceLocation LParenLoc = readSourceLocation();
9216     SourceLocation RParenLoc = readSourceLocation();
9217 
9218     CXXCtorInitializer *BOMInit;
9219     if (Type == CTOR_INITIALIZER_BASE)
9220       BOMInit = new (Context)
9221           CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
9222                              RParenLoc, MemberOrEllipsisLoc);
9223     else if (Type == CTOR_INITIALIZER_DELEGATING)
9224       BOMInit = new (Context)
9225           CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
9226     else if (Member)
9227       BOMInit = new (Context)
9228           CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
9229                              Init, RParenLoc);
9230     else
9231       BOMInit = new (Context)
9232           CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
9233                              LParenLoc, Init, RParenLoc);
9234 
9235     if (/*IsWritten*/readBool()) {
9236       unsigned SourceOrder = readInt();
9237       BOMInit->setSourceOrder(SourceOrder);
9238     }
9239 
9240     CtorInitializers[i] = BOMInit;
9241   }
9242 
9243   return CtorInitializers;
9244 }
9245 
9246 NestedNameSpecifierLoc
9247 ASTRecordReader::readNestedNameSpecifierLoc() {
9248   ASTContext &Context = getContext();
9249   unsigned N = readInt();
9250   NestedNameSpecifierLocBuilder Builder;
9251   for (unsigned I = 0; I != N; ++I) {
9252     auto Kind = readNestedNameSpecifierKind();
9253     switch (Kind) {
9254     case NestedNameSpecifier::Identifier: {
9255       IdentifierInfo *II = readIdentifier();
9256       SourceRange Range = readSourceRange();
9257       Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9258       break;
9259     }
9260 
9261     case NestedNameSpecifier::Namespace: {
9262       NamespaceDecl *NS = readDeclAs<NamespaceDecl>();
9263       SourceRange Range = readSourceRange();
9264       Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9265       break;
9266     }
9267 
9268     case NestedNameSpecifier::NamespaceAlias: {
9269       NamespaceAliasDecl *Alias = readDeclAs<NamespaceAliasDecl>();
9270       SourceRange Range = readSourceRange();
9271       Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9272       break;
9273     }
9274 
9275     case NestedNameSpecifier::TypeSpec:
9276     case NestedNameSpecifier::TypeSpecWithTemplate: {
9277       bool Template = readBool();
9278       TypeSourceInfo *T = readTypeSourceInfo();
9279       if (!T)
9280         return NestedNameSpecifierLoc();
9281       SourceLocation ColonColonLoc = readSourceLocation();
9282 
9283       // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9284       Builder.Extend(Context,
9285                      Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9286                      T->getTypeLoc(), ColonColonLoc);
9287       break;
9288     }
9289 
9290     case NestedNameSpecifier::Global: {
9291       SourceLocation ColonColonLoc = readSourceLocation();
9292       Builder.MakeGlobal(Context, ColonColonLoc);
9293       break;
9294     }
9295 
9296     case NestedNameSpecifier::Super: {
9297       CXXRecordDecl *RD = readDeclAs<CXXRecordDecl>();
9298       SourceRange Range = readSourceRange();
9299       Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9300       break;
9301     }
9302     }
9303   }
9304 
9305   return Builder.getWithLocInContext(Context);
9306 }
9307 
9308 SourceRange ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9309                                        unsigned &Idx, LocSeq *Seq) {
9310   SourceLocation beg = ReadSourceLocation(F, Record, Idx, Seq);
9311   SourceLocation end = ReadSourceLocation(F, Record, Idx, Seq);
9312   return SourceRange(beg, end);
9313 }
9314 
9315 /// Read a floating-point value
9316 llvm::APFloat ASTRecordReader::readAPFloat(const llvm::fltSemantics &Sem) {
9317   return llvm::APFloat(Sem, readAPInt());
9318 }
9319 
9320 // Read a string
9321 std::string ASTReader::ReadString(const RecordDataImpl &Record, unsigned &Idx) {
9322   unsigned Len = Record[Idx++];
9323   std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9324   Idx += Len;
9325   return Result;
9326 }
9327 
9328 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9329                                 unsigned &Idx) {
9330   std::string Filename = ReadString(Record, Idx);
9331   ResolveImportedPath(F, Filename);
9332   return Filename;
9333 }
9334 
9335 std::string ASTReader::ReadPath(StringRef BaseDirectory,
9336                                 const RecordData &Record, unsigned &Idx) {
9337   std::string Filename = ReadString(Record, Idx);
9338   if (!BaseDirectory.empty())
9339     ResolveImportedPath(Filename, BaseDirectory);
9340   return Filename;
9341 }
9342 
9343 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9344                                          unsigned &Idx) {
9345   unsigned Major = Record[Idx++];
9346   unsigned Minor = Record[Idx++];
9347   unsigned Subminor = Record[Idx++];
9348   if (Minor == 0)
9349     return VersionTuple(Major);
9350   if (Subminor == 0)
9351     return VersionTuple(Major, Minor - 1);
9352   return VersionTuple(Major, Minor - 1, Subminor - 1);
9353 }
9354 
9355 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9356                                           const RecordData &Record,
9357                                           unsigned &Idx) {
9358   CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9359   return CXXTemporary::Create(getContext(), Decl);
9360 }
9361 
9362 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9363   return Diag(CurrentImportLoc, DiagID);
9364 }
9365 
9366 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9367   return Diags.Report(Loc, DiagID);
9368 }
9369 
9370 /// Retrieve the identifier table associated with the
9371 /// preprocessor.
9372 IdentifierTable &ASTReader::getIdentifierTable() {
9373   return PP.getIdentifierTable();
9374 }
9375 
9376 /// Record that the given ID maps to the given switch-case
9377 /// statement.
9378 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9379   assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9380          "Already have a SwitchCase with this ID");
9381   (*CurrSwitchCaseStmts)[ID] = SC;
9382 }
9383 
9384 /// Retrieve the switch-case statement with the given ID.
9385 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9386   assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9387   return (*CurrSwitchCaseStmts)[ID];
9388 }
9389 
9390 void ASTReader::ClearSwitchCaseIDs() {
9391   CurrSwitchCaseStmts->clear();
9392 }
9393 
9394 void ASTReader::ReadComments() {
9395   ASTContext &Context = getContext();
9396   std::vector<RawComment *> Comments;
9397   for (SmallVectorImpl<std::pair<BitstreamCursor,
9398                                  serialization::ModuleFile *>>::iterator
9399        I = CommentsCursors.begin(),
9400        E = CommentsCursors.end();
9401        I != E; ++I) {
9402     Comments.clear();
9403     BitstreamCursor &Cursor = I->first;
9404     serialization::ModuleFile &F = *I->second;
9405     SavedStreamPosition SavedPosition(Cursor);
9406 
9407     RecordData Record;
9408     while (true) {
9409       Expected<llvm::BitstreamEntry> MaybeEntry =
9410           Cursor.advanceSkippingSubblocks(
9411               BitstreamCursor::AF_DontPopBlockAtEnd);
9412       if (!MaybeEntry) {
9413         Error(MaybeEntry.takeError());
9414         return;
9415       }
9416       llvm::BitstreamEntry Entry = MaybeEntry.get();
9417 
9418       switch (Entry.Kind) {
9419       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9420       case llvm::BitstreamEntry::Error:
9421         Error("malformed block record in AST file");
9422         return;
9423       case llvm::BitstreamEntry::EndBlock:
9424         goto NextCursor;
9425       case llvm::BitstreamEntry::Record:
9426         // The interesting case.
9427         break;
9428       }
9429 
9430       // Read a record.
9431       Record.clear();
9432       Expected<unsigned> MaybeComment = Cursor.readRecord(Entry.ID, Record);
9433       if (!MaybeComment) {
9434         Error(MaybeComment.takeError());
9435         return;
9436       }
9437       switch ((CommentRecordTypes)MaybeComment.get()) {
9438       case COMMENTS_RAW_COMMENT: {
9439         unsigned Idx = 0;
9440         SourceRange SR = ReadSourceRange(F, Record, Idx);
9441         RawComment::CommentKind Kind =
9442             (RawComment::CommentKind) Record[Idx++];
9443         bool IsTrailingComment = Record[Idx++];
9444         bool IsAlmostTrailingComment = Record[Idx++];
9445         Comments.push_back(new (Context) RawComment(
9446             SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9447         break;
9448       }
9449       }
9450     }
9451   NextCursor:
9452     llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9453         FileToOffsetToComment;
9454     for (RawComment *C : Comments) {
9455       SourceLocation CommentLoc = C->getBeginLoc();
9456       if (CommentLoc.isValid()) {
9457         std::pair<FileID, unsigned> Loc =
9458             SourceMgr.getDecomposedLoc(CommentLoc);
9459         if (Loc.first.isValid())
9460           Context.Comments.OrderedComments[Loc.first].emplace(Loc.second, C);
9461       }
9462     }
9463   }
9464 }
9465 
9466 void ASTReader::visitInputFileInfos(
9467     serialization::ModuleFile &MF, bool IncludeSystem,
9468     llvm::function_ref<void(const serialization::InputFileInfo &IFI,
9469                             bool IsSystem)>
9470         Visitor) {
9471   unsigned NumUserInputs = MF.NumUserInputFiles;
9472   unsigned NumInputs = MF.InputFilesLoaded.size();
9473   assert(NumUserInputs <= NumInputs);
9474   unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9475   for (unsigned I = 0; I < N; ++I) {
9476     bool IsSystem = I >= NumUserInputs;
9477     InputFileInfo IFI = getInputFileInfo(MF, I+1);
9478     Visitor(IFI, IsSystem);
9479   }
9480 }
9481 
9482 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9483                                 bool IncludeSystem, bool Complain,
9484                     llvm::function_ref<void(const serialization::InputFile &IF,
9485                                             bool isSystem)> Visitor) {
9486   unsigned NumUserInputs = MF.NumUserInputFiles;
9487   unsigned NumInputs = MF.InputFilesLoaded.size();
9488   assert(NumUserInputs <= NumInputs);
9489   unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9490   for (unsigned I = 0; I < N; ++I) {
9491     bool IsSystem = I >= NumUserInputs;
9492     InputFile IF = getInputFile(MF, I+1, Complain);
9493     Visitor(IF, IsSystem);
9494   }
9495 }
9496 
9497 void ASTReader::visitTopLevelModuleMaps(
9498     serialization::ModuleFile &MF,
9499     llvm::function_ref<void(FileEntryRef FE)> Visitor) {
9500   unsigned NumInputs = MF.InputFilesLoaded.size();
9501   for (unsigned I = 0; I < NumInputs; ++I) {
9502     InputFileInfo IFI = getInputFileInfo(MF, I + 1);
9503     if (IFI.TopLevel && IFI.ModuleMap)
9504       if (auto FE = getInputFile(MF, I + 1).getFile())
9505         Visitor(*FE);
9506   }
9507 }
9508 
9509 void ASTReader::finishPendingActions() {
9510   while (
9511       !PendingIdentifierInfos.empty() || !PendingDeducedFunctionTypes.empty() ||
9512       !PendingDeducedVarTypes.empty() || !PendingIncompleteDeclChains.empty() ||
9513       !PendingDeclChains.empty() || !PendingMacroIDs.empty() ||
9514       !PendingDeclContextInfos.empty() || !PendingUpdateRecords.empty() ||
9515       !PendingObjCExtensionIvarRedeclarations.empty()) {
9516     // If any identifiers with corresponding top-level declarations have
9517     // been loaded, load those declarations now.
9518     using TopLevelDeclsMap =
9519         llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9520     TopLevelDeclsMap TopLevelDecls;
9521 
9522     while (!PendingIdentifierInfos.empty()) {
9523       IdentifierInfo *II = PendingIdentifierInfos.back().first;
9524       SmallVector<uint32_t, 4> DeclIDs =
9525           std::move(PendingIdentifierInfos.back().second);
9526       PendingIdentifierInfos.pop_back();
9527 
9528       SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9529     }
9530 
9531     // Load each function type that we deferred loading because it was a
9532     // deduced type that might refer to a local type declared within itself.
9533     for (unsigned I = 0; I != PendingDeducedFunctionTypes.size(); ++I) {
9534       auto *FD = PendingDeducedFunctionTypes[I].first;
9535       FD->setType(GetType(PendingDeducedFunctionTypes[I].second));
9536 
9537       if (auto *DT = FD->getReturnType()->getContainedDeducedType()) {
9538         // If we gave a function a deduced return type, remember that we need to
9539         // propagate that along the redeclaration chain.
9540         if (DT->isDeduced()) {
9541           PendingDeducedTypeUpdates.insert(
9542               {FD->getCanonicalDecl(), FD->getReturnType()});
9543           continue;
9544         }
9545 
9546         // The function has undeduced DeduceType return type. We hope we can
9547         // find the deduced type by iterating the redecls in other modules
9548         // later.
9549         PendingUndeducedFunctionDecls.push_back(FD);
9550         continue;
9551       }
9552     }
9553     PendingDeducedFunctionTypes.clear();
9554 
9555     // Load each variable type that we deferred loading because it was a
9556     // deduced type that might refer to a local type declared within itself.
9557     for (unsigned I = 0; I != PendingDeducedVarTypes.size(); ++I) {
9558       auto *VD = PendingDeducedVarTypes[I].first;
9559       VD->setType(GetType(PendingDeducedVarTypes[I].second));
9560     }
9561     PendingDeducedVarTypes.clear();
9562 
9563     // For each decl chain that we wanted to complete while deserializing, mark
9564     // it as "still needs to be completed".
9565     for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9566       markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9567     }
9568     PendingIncompleteDeclChains.clear();
9569 
9570     // Load pending declaration chains.
9571     for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9572       loadPendingDeclChain(PendingDeclChains[I].first,
9573                            PendingDeclChains[I].second);
9574     PendingDeclChains.clear();
9575 
9576     // Make the most recent of the top-level declarations visible.
9577     for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9578            TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9579       IdentifierInfo *II = TLD->first;
9580       for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9581         pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9582       }
9583     }
9584 
9585     // Load any pending macro definitions.
9586     for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9587       IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9588       SmallVector<PendingMacroInfo, 2> GlobalIDs;
9589       GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9590       // Initialize the macro history from chained-PCHs ahead of module imports.
9591       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9592            ++IDIdx) {
9593         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9594         if (!Info.M->isModule())
9595           resolvePendingMacro(II, Info);
9596       }
9597       // Handle module imports.
9598       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9599            ++IDIdx) {
9600         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9601         if (Info.M->isModule())
9602           resolvePendingMacro(II, Info);
9603       }
9604     }
9605     PendingMacroIDs.clear();
9606 
9607     // Wire up the DeclContexts for Decls that we delayed setting until
9608     // recursive loading is completed.
9609     while (!PendingDeclContextInfos.empty()) {
9610       PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9611       PendingDeclContextInfos.pop_front();
9612       DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9613       DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9614       Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9615     }
9616 
9617     // Perform any pending declaration updates.
9618     while (!PendingUpdateRecords.empty()) {
9619       auto Update = PendingUpdateRecords.pop_back_val();
9620       ReadingKindTracker ReadingKind(Read_Decl, *this);
9621       loadDeclUpdateRecords(Update);
9622     }
9623 
9624     while (!PendingObjCExtensionIvarRedeclarations.empty()) {
9625       auto ExtensionsPair = PendingObjCExtensionIvarRedeclarations.back().first;
9626       auto DuplicateIvars =
9627           PendingObjCExtensionIvarRedeclarations.back().second;
9628       llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
9629       StructuralEquivalenceContext Ctx(
9630           ExtensionsPair.first->getASTContext(),
9631           ExtensionsPair.second->getASTContext(), NonEquivalentDecls,
9632           StructuralEquivalenceKind::Default, /*StrictTypeSpelling =*/false,
9633           /*Complain =*/false,
9634           /*ErrorOnTagTypeMismatch =*/true);
9635       if (Ctx.IsEquivalent(ExtensionsPair.first, ExtensionsPair.second)) {
9636         // Merge redeclared ivars with their predecessors.
9637         for (auto IvarPair : DuplicateIvars) {
9638           ObjCIvarDecl *Ivar = IvarPair.first, *PrevIvar = IvarPair.second;
9639           // Change semantic DeclContext but keep the lexical one.
9640           Ivar->setDeclContextsImpl(PrevIvar->getDeclContext(),
9641                                     Ivar->getLexicalDeclContext(),
9642                                     getContext());
9643           getContext().setPrimaryMergedDecl(Ivar, PrevIvar->getCanonicalDecl());
9644         }
9645         // Invalidate duplicate extension and the cached ivar list.
9646         ExtensionsPair.first->setInvalidDecl();
9647         ExtensionsPair.second->getClassInterface()
9648             ->getDefinition()
9649             ->setIvarList(nullptr);
9650       } else {
9651         for (auto IvarPair : DuplicateIvars) {
9652           Diag(IvarPair.first->getLocation(),
9653                diag::err_duplicate_ivar_declaration)
9654               << IvarPair.first->getIdentifier();
9655           Diag(IvarPair.second->getLocation(), diag::note_previous_definition);
9656         }
9657       }
9658       PendingObjCExtensionIvarRedeclarations.pop_back();
9659     }
9660   }
9661 
9662   // At this point, all update records for loaded decls are in place, so any
9663   // fake class definitions should have become real.
9664   assert(PendingFakeDefinitionData.empty() &&
9665          "faked up a class definition but never saw the real one");
9666 
9667   // If we deserialized any C++ or Objective-C class definitions, any
9668   // Objective-C protocol definitions, or any redeclarable templates, make sure
9669   // that all redeclarations point to the definitions. Note that this can only
9670   // happen now, after the redeclaration chains have been fully wired.
9671   for (Decl *D : PendingDefinitions) {
9672     if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9673       if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9674         // Make sure that the TagType points at the definition.
9675         const_cast<TagType*>(TagT)->decl = TD;
9676       }
9677 
9678       if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9679         for (auto *R = getMostRecentExistingDecl(RD); R;
9680              R = R->getPreviousDecl()) {
9681           assert((R == D) ==
9682                      cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9683                  "declaration thinks it's the definition but it isn't");
9684           cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9685         }
9686       }
9687 
9688       continue;
9689     }
9690 
9691     if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9692       // Make sure that the ObjCInterfaceType points at the definition.
9693       const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9694         ->Decl = ID;
9695 
9696       for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9697         cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9698 
9699       continue;
9700     }
9701 
9702     if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9703       for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9704         cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9705 
9706       continue;
9707     }
9708 
9709     auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9710     for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9711       cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9712   }
9713   PendingDefinitions.clear();
9714 
9715   // Load the bodies of any functions or methods we've encountered. We do
9716   // this now (delayed) so that we can be sure that the declaration chains
9717   // have been fully wired up (hasBody relies on this).
9718   // FIXME: We shouldn't require complete redeclaration chains here.
9719   for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9720                                PBEnd = PendingBodies.end();
9721        PB != PBEnd; ++PB) {
9722     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9723       // For a function defined inline within a class template, force the
9724       // canonical definition to be the one inside the canonical definition of
9725       // the template. This ensures that we instantiate from a correct view
9726       // of the template.
9727       //
9728       // Sadly we can't do this more generally: we can't be sure that all
9729       // copies of an arbitrary class definition will have the same members
9730       // defined (eg, some member functions may not be instantiated, and some
9731       // special members may or may not have been implicitly defined).
9732       if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9733         if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9734           continue;
9735 
9736       // FIXME: Check for =delete/=default?
9737       const FunctionDecl *Defn = nullptr;
9738       if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9739         FD->setLazyBody(PB->second);
9740       } else {
9741         auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9742         mergeDefinitionVisibility(NonConstDefn, FD);
9743 
9744         if (!FD->isLateTemplateParsed() &&
9745             !NonConstDefn->isLateTemplateParsed() &&
9746             // We only perform ODR checks for decls not in the explicit
9747             // global module fragment.
9748             !FD->shouldSkipCheckingODR() &&
9749             FD->getODRHash() != NonConstDefn->getODRHash()) {
9750           if (!isa<CXXMethodDecl>(FD)) {
9751             PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9752           } else if (FD->getLexicalParent()->isFileContext() &&
9753                      NonConstDefn->getLexicalParent()->isFileContext()) {
9754             // Only diagnose out-of-line method definitions.  If they are
9755             // in class definitions, then an error will be generated when
9756             // processing the class bodies.
9757             PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9758           }
9759         }
9760       }
9761       continue;
9762     }
9763 
9764     ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9765     if (!getContext().getLangOpts().Modules || !MD->hasBody())
9766       MD->setLazyBody(PB->second);
9767   }
9768   PendingBodies.clear();
9769 
9770   // Inform any classes that had members added that they now have more members.
9771   for (auto [RD, MD] : PendingAddedClassMembers) {
9772     RD->addedMember(MD);
9773   }
9774   PendingAddedClassMembers.clear();
9775 
9776   // Do some cleanup.
9777   for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9778     getContext().deduplicateMergedDefinitonsFor(ND);
9779   PendingMergedDefinitionsToDeduplicate.clear();
9780 }
9781 
9782 void ASTReader::diagnoseOdrViolations() {
9783   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9784       PendingRecordOdrMergeFailures.empty() &&
9785       PendingFunctionOdrMergeFailures.empty() &&
9786       PendingEnumOdrMergeFailures.empty() &&
9787       PendingObjCInterfaceOdrMergeFailures.empty() &&
9788       PendingObjCProtocolOdrMergeFailures.empty())
9789     return;
9790 
9791   // Trigger the import of the full definition of each class that had any
9792   // odr-merging problems, so we can produce better diagnostics for them.
9793   // These updates may in turn find and diagnose some ODR failures, so take
9794   // ownership of the set first.
9795   auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9796   PendingOdrMergeFailures.clear();
9797   for (auto &Merge : OdrMergeFailures) {
9798     Merge.first->buildLookup();
9799     Merge.first->decls_begin();
9800     Merge.first->bases_begin();
9801     Merge.first->vbases_begin();
9802     for (auto &RecordPair : Merge.second) {
9803       auto *RD = RecordPair.first;
9804       RD->decls_begin();
9805       RD->bases_begin();
9806       RD->vbases_begin();
9807     }
9808   }
9809 
9810   // Trigger the import of the full definition of each record in C/ObjC.
9811   auto RecordOdrMergeFailures = std::move(PendingRecordOdrMergeFailures);
9812   PendingRecordOdrMergeFailures.clear();
9813   for (auto &Merge : RecordOdrMergeFailures) {
9814     Merge.first->decls_begin();
9815     for (auto &D : Merge.second)
9816       D->decls_begin();
9817   }
9818 
9819   // Trigger the import of the full interface definition.
9820   auto ObjCInterfaceOdrMergeFailures =
9821       std::move(PendingObjCInterfaceOdrMergeFailures);
9822   PendingObjCInterfaceOdrMergeFailures.clear();
9823   for (auto &Merge : ObjCInterfaceOdrMergeFailures) {
9824     Merge.first->decls_begin();
9825     for (auto &InterfacePair : Merge.second)
9826       InterfacePair.first->decls_begin();
9827   }
9828 
9829   // Trigger the import of functions.
9830   auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9831   PendingFunctionOdrMergeFailures.clear();
9832   for (auto &Merge : FunctionOdrMergeFailures) {
9833     Merge.first->buildLookup();
9834     Merge.first->decls_begin();
9835     Merge.first->getBody();
9836     for (auto &FD : Merge.second) {
9837       FD->buildLookup();
9838       FD->decls_begin();
9839       FD->getBody();
9840     }
9841   }
9842 
9843   // Trigger the import of enums.
9844   auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9845   PendingEnumOdrMergeFailures.clear();
9846   for (auto &Merge : EnumOdrMergeFailures) {
9847     Merge.first->decls_begin();
9848     for (auto &Enum : Merge.second) {
9849       Enum->decls_begin();
9850     }
9851   }
9852 
9853   // Trigger the import of the full protocol definition.
9854   auto ObjCProtocolOdrMergeFailures =
9855       std::move(PendingObjCProtocolOdrMergeFailures);
9856   PendingObjCProtocolOdrMergeFailures.clear();
9857   for (auto &Merge : ObjCProtocolOdrMergeFailures) {
9858     Merge.first->decls_begin();
9859     for (auto &ProtocolPair : Merge.second)
9860       ProtocolPair.first->decls_begin();
9861   }
9862 
9863   // For each declaration from a merged context, check that the canonical
9864   // definition of that context also contains a declaration of the same
9865   // entity.
9866   //
9867   // Caution: this loop does things that might invalidate iterators into
9868   // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9869   while (!PendingOdrMergeChecks.empty()) {
9870     NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9871 
9872     // FIXME: Skip over implicit declarations for now. This matters for things
9873     // like implicitly-declared special member functions. This isn't entirely
9874     // correct; we can end up with multiple unmerged declarations of the same
9875     // implicit entity.
9876     if (D->isImplicit())
9877       continue;
9878 
9879     DeclContext *CanonDef = D->getDeclContext();
9880 
9881     bool Found = false;
9882     const Decl *DCanon = D->getCanonicalDecl();
9883 
9884     for (auto *RI : D->redecls()) {
9885       if (RI->getLexicalDeclContext() == CanonDef) {
9886         Found = true;
9887         break;
9888       }
9889     }
9890     if (Found)
9891       continue;
9892 
9893     // Quick check failed, time to do the slow thing. Note, we can't just
9894     // look up the name of D in CanonDef here, because the member that is
9895     // in CanonDef might not be found by name lookup (it might have been
9896     // replaced by a more recent declaration in the lookup table), and we
9897     // can't necessarily find it in the redeclaration chain because it might
9898     // be merely mergeable, not redeclarable.
9899     llvm::SmallVector<const NamedDecl*, 4> Candidates;
9900     for (auto *CanonMember : CanonDef->decls()) {
9901       if (CanonMember->getCanonicalDecl() == DCanon) {
9902         // This can happen if the declaration is merely mergeable and not
9903         // actually redeclarable (we looked for redeclarations earlier).
9904         //
9905         // FIXME: We should be able to detect this more efficiently, without
9906         // pulling in all of the members of CanonDef.
9907         Found = true;
9908         break;
9909       }
9910       if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9911         if (ND->getDeclName() == D->getDeclName())
9912           Candidates.push_back(ND);
9913     }
9914 
9915     if (!Found) {
9916       // The AST doesn't like TagDecls becoming invalid after they've been
9917       // completed. We only really need to mark FieldDecls as invalid here.
9918       if (!isa<TagDecl>(D))
9919         D->setInvalidDecl();
9920 
9921       // Ensure we don't accidentally recursively enter deserialization while
9922       // we're producing our diagnostic.
9923       Deserializing RecursionGuard(this);
9924 
9925       std::string CanonDefModule =
9926           ODRDiagsEmitter::getOwningModuleNameForDiagnostic(
9927               cast<Decl>(CanonDef));
9928       Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9929         << D << ODRDiagsEmitter::getOwningModuleNameForDiagnostic(D)
9930         << CanonDef << CanonDefModule.empty() << CanonDefModule;
9931 
9932       if (Candidates.empty())
9933         Diag(cast<Decl>(CanonDef)->getLocation(),
9934              diag::note_module_odr_violation_no_possible_decls) << D;
9935       else {
9936         for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9937           Diag(Candidates[I]->getLocation(),
9938                diag::note_module_odr_violation_possible_decl)
9939             << Candidates[I];
9940       }
9941 
9942       DiagnosedOdrMergeFailures.insert(CanonDef);
9943     }
9944   }
9945 
9946   if (OdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
9947       FunctionOdrMergeFailures.empty() && EnumOdrMergeFailures.empty() &&
9948       ObjCInterfaceOdrMergeFailures.empty() &&
9949       ObjCProtocolOdrMergeFailures.empty())
9950     return;
9951 
9952   ODRDiagsEmitter DiagsEmitter(Diags, getContext(),
9953                                getPreprocessor().getLangOpts());
9954 
9955   // Issue any pending ODR-failure diagnostics.
9956   for (auto &Merge : OdrMergeFailures) {
9957     // If we've already pointed out a specific problem with this class, don't
9958     // bother issuing a general "something's different" diagnostic.
9959     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9960       continue;
9961 
9962     bool Diagnosed = false;
9963     CXXRecordDecl *FirstRecord = Merge.first;
9964     for (auto &RecordPair : Merge.second) {
9965       if (DiagsEmitter.diagnoseMismatch(FirstRecord, RecordPair.first,
9966                                         RecordPair.second)) {
9967         Diagnosed = true;
9968         break;
9969       }
9970     }
9971 
9972     if (!Diagnosed) {
9973       // All definitions are updates to the same declaration. This happens if a
9974       // module instantiates the declaration of a class template specialization
9975       // and two or more other modules instantiate its definition.
9976       //
9977       // FIXME: Indicate which modules had instantiations of this definition.
9978       // FIXME: How can this even happen?
9979       Diag(Merge.first->getLocation(),
9980            diag::err_module_odr_violation_different_instantiations)
9981           << Merge.first;
9982     }
9983   }
9984 
9985   // Issue any pending ODR-failure diagnostics for RecordDecl in C/ObjC. Note
9986   // that in C++ this is done as a part of CXXRecordDecl ODR checking.
9987   for (auto &Merge : RecordOdrMergeFailures) {
9988     // If we've already pointed out a specific problem with this class, don't
9989     // bother issuing a general "something's different" diagnostic.
9990     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9991       continue;
9992 
9993     RecordDecl *FirstRecord = Merge.first;
9994     bool Diagnosed = false;
9995     for (auto *SecondRecord : Merge.second) {
9996       if (DiagsEmitter.diagnoseMismatch(FirstRecord, SecondRecord)) {
9997         Diagnosed = true;
9998         break;
9999       }
10000     }
10001     (void)Diagnosed;
10002     assert(Diagnosed && "Unable to emit ODR diagnostic.");
10003   }
10004 
10005   // Issue ODR failures diagnostics for functions.
10006   for (auto &Merge : FunctionOdrMergeFailures) {
10007     FunctionDecl *FirstFunction = Merge.first;
10008     bool Diagnosed = false;
10009     for (auto &SecondFunction : Merge.second) {
10010       if (DiagsEmitter.diagnoseMismatch(FirstFunction, SecondFunction)) {
10011         Diagnosed = true;
10012         break;
10013       }
10014     }
10015     (void)Diagnosed;
10016     assert(Diagnosed && "Unable to emit ODR diagnostic.");
10017   }
10018 
10019   // Issue ODR failures diagnostics for enums.
10020   for (auto &Merge : EnumOdrMergeFailures) {
10021     // If we've already pointed out a specific problem with this enum, don't
10022     // bother issuing a general "something's different" diagnostic.
10023     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10024       continue;
10025 
10026     EnumDecl *FirstEnum = Merge.first;
10027     bool Diagnosed = false;
10028     for (auto &SecondEnum : Merge.second) {
10029       if (DiagsEmitter.diagnoseMismatch(FirstEnum, SecondEnum)) {
10030         Diagnosed = true;
10031         break;
10032       }
10033     }
10034     (void)Diagnosed;
10035     assert(Diagnosed && "Unable to emit ODR diagnostic.");
10036   }
10037 
10038   for (auto &Merge : ObjCInterfaceOdrMergeFailures) {
10039     // If we've already pointed out a specific problem with this interface,
10040     // don't bother issuing a general "something's different" diagnostic.
10041     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10042       continue;
10043 
10044     bool Diagnosed = false;
10045     ObjCInterfaceDecl *FirstID = Merge.first;
10046     for (auto &InterfacePair : Merge.second) {
10047       if (DiagsEmitter.diagnoseMismatch(FirstID, InterfacePair.first,
10048                                         InterfacePair.second)) {
10049         Diagnosed = true;
10050         break;
10051       }
10052     }
10053     (void)Diagnosed;
10054     assert(Diagnosed && "Unable to emit ODR diagnostic.");
10055   }
10056 
10057   for (auto &Merge : ObjCProtocolOdrMergeFailures) {
10058     // If we've already pointed out a specific problem with this protocol,
10059     // don't bother issuing a general "something's different" diagnostic.
10060     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10061       continue;
10062 
10063     ObjCProtocolDecl *FirstProtocol = Merge.first;
10064     bool Diagnosed = false;
10065     for (auto &ProtocolPair : Merge.second) {
10066       if (DiagsEmitter.diagnoseMismatch(FirstProtocol, ProtocolPair.first,
10067                                         ProtocolPair.second)) {
10068         Diagnosed = true;
10069         break;
10070       }
10071     }
10072     (void)Diagnosed;
10073     assert(Diagnosed && "Unable to emit ODR diagnostic.");
10074   }
10075 }
10076 
10077 void ASTReader::StartedDeserializing() {
10078   if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10079     ReadTimer->startTimer();
10080 }
10081 
10082 void ASTReader::FinishedDeserializing() {
10083   assert(NumCurrentElementsDeserializing &&
10084          "FinishedDeserializing not paired with StartedDeserializing");
10085   if (NumCurrentElementsDeserializing == 1) {
10086     // We decrease NumCurrentElementsDeserializing only after pending actions
10087     // are finished, to avoid recursively re-calling finishPendingActions().
10088     finishPendingActions();
10089   }
10090   --NumCurrentElementsDeserializing;
10091 
10092   if (NumCurrentElementsDeserializing == 0) {
10093     // Propagate exception specification and deduced type updates along
10094     // redeclaration chains.
10095     //
10096     // We do this now rather than in finishPendingActions because we want to
10097     // be able to walk the complete redeclaration chains of the updated decls.
10098     while (!PendingExceptionSpecUpdates.empty() ||
10099            !PendingDeducedTypeUpdates.empty()) {
10100       auto ESUpdates = std::move(PendingExceptionSpecUpdates);
10101       PendingExceptionSpecUpdates.clear();
10102       for (auto Update : ESUpdates) {
10103         ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
10104         auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
10105         auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
10106         if (auto *Listener = getContext().getASTMutationListener())
10107           Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
10108         for (auto *Redecl : Update.second->redecls())
10109           getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
10110       }
10111 
10112       auto DTUpdates = std::move(PendingDeducedTypeUpdates);
10113       PendingDeducedTypeUpdates.clear();
10114       for (auto Update : DTUpdates) {
10115         ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
10116         // FIXME: If the return type is already deduced, check that it matches.
10117         getContext().adjustDeducedFunctionResultType(Update.first,
10118                                                      Update.second);
10119       }
10120 
10121       auto UDTUpdates = std::move(PendingUndeducedFunctionDecls);
10122       PendingUndeducedFunctionDecls.clear();
10123       // We hope we can find the deduced type for the functions by iterating
10124       // redeclarations in other modules.
10125       for (FunctionDecl *UndeducedFD : UDTUpdates)
10126         (void)UndeducedFD->getMostRecentDecl();
10127     }
10128 
10129     if (ReadTimer)
10130       ReadTimer->stopTimer();
10131 
10132     diagnoseOdrViolations();
10133 
10134     // We are not in recursive loading, so it's safe to pass the "interesting"
10135     // decls to the consumer.
10136     if (Consumer)
10137       PassInterestingDeclsToConsumer();
10138   }
10139 }
10140 
10141 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
10142   if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
10143     // Remove any fake results before adding any real ones.
10144     auto It = PendingFakeLookupResults.find(II);
10145     if (It != PendingFakeLookupResults.end()) {
10146       for (auto *ND : It->second)
10147         SemaObj->IdResolver.RemoveDecl(ND);
10148       // FIXME: this works around module+PCH performance issue.
10149       // Rather than erase the result from the map, which is O(n), just clear
10150       // the vector of NamedDecls.
10151       It->second.clear();
10152     }
10153   }
10154 
10155   if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
10156     SemaObj->TUScope->AddDecl(D);
10157   } else if (SemaObj->TUScope) {
10158     // Adding the decl to IdResolver may have failed because it was already in
10159     // (even though it was not added in scope). If it is already in, make sure
10160     // it gets in the scope as well.
10161     if (llvm::is_contained(SemaObj->IdResolver.decls(Name), D))
10162       SemaObj->TUScope->AddDecl(D);
10163   }
10164 }
10165 
10166 ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
10167                      ASTContext *Context,
10168                      const PCHContainerReader &PCHContainerRdr,
10169                      ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10170                      StringRef isysroot,
10171                      DisableValidationForModuleKind DisableValidationKind,
10172                      bool AllowASTWithCompilerErrors,
10173                      bool AllowConfigurationMismatch, bool ValidateSystemInputs,
10174                      bool ValidateASTInputFilesContent, bool UseGlobalIndex,
10175                      std::unique_ptr<llvm::Timer> ReadTimer)
10176     : Listener(bool(DisableValidationKind &DisableValidationForModuleKind::PCH)
10177                    ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
10178                    : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
10179       SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10180       PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10181       ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
10182                                      PCHContainerRdr, PP.getHeaderSearchInfo()),
10183       DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
10184       DisableValidationKind(DisableValidationKind),
10185       AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10186       AllowConfigurationMismatch(AllowConfigurationMismatch),
10187       ValidateSystemInputs(ValidateSystemInputs),
10188       ValidateASTInputFilesContent(ValidateASTInputFilesContent),
10189       UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10190   SourceMgr.setExternalSLocEntrySource(this);
10191 
10192   for (const auto &Ext : Extensions) {
10193     auto BlockName = Ext->getExtensionMetadata().BlockName;
10194     auto Known = ModuleFileExtensions.find(BlockName);
10195     if (Known != ModuleFileExtensions.end()) {
10196       Diags.Report(diag::warn_duplicate_module_file_extension)
10197         << BlockName;
10198       continue;
10199     }
10200 
10201     ModuleFileExtensions.insert({BlockName, Ext});
10202   }
10203 }
10204 
10205 ASTReader::~ASTReader() {
10206   if (OwnsDeserializationListener)
10207     delete DeserializationListener;
10208 }
10209 
10210 IdentifierResolver &ASTReader::getIdResolver() {
10211   return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
10212 }
10213 
10214 Expected<unsigned> ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
10215                                                unsigned AbbrevID) {
10216   Idx = 0;
10217   Record.clear();
10218   return Cursor.readRecord(AbbrevID, Record);
10219 }
10220 //===----------------------------------------------------------------------===//
10221 //// OMPClauseReader implementation
10222 ////===----------------------------------------------------------------------===//
10223 
10224 // This has to be in namespace clang because it's friended by all
10225 // of the OMP clauses.
10226 namespace clang {
10227 
10228 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
10229   ASTRecordReader &Record;
10230   ASTContext &Context;
10231 
10232 public:
10233   OMPClauseReader(ASTRecordReader &Record)
10234       : Record(Record), Context(Record.getContext()) {}
10235 #define GEN_CLANG_CLAUSE_CLASS
10236 #define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
10237 #include "llvm/Frontend/OpenMP/OMP.inc"
10238   OMPClause *readClause();
10239   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
10240   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
10241 };
10242 
10243 } // end namespace clang
10244 
10245 OMPClause *ASTRecordReader::readOMPClause() {
10246   return OMPClauseReader(*this).readClause();
10247 }
10248 
10249 OMPClause *OMPClauseReader::readClause() {
10250   OMPClause *C = nullptr;
10251   switch (llvm::omp::Clause(Record.readInt())) {
10252   case llvm::omp::OMPC_if:
10253     C = new (Context) OMPIfClause();
10254     break;
10255   case llvm::omp::OMPC_final:
10256     C = new (Context) OMPFinalClause();
10257     break;
10258   case llvm::omp::OMPC_num_threads:
10259     C = new (Context) OMPNumThreadsClause();
10260     break;
10261   case llvm::omp::OMPC_safelen:
10262     C = new (Context) OMPSafelenClause();
10263     break;
10264   case llvm::omp::OMPC_simdlen:
10265     C = new (Context) OMPSimdlenClause();
10266     break;
10267   case llvm::omp::OMPC_sizes: {
10268     unsigned NumSizes = Record.readInt();
10269     C = OMPSizesClause::CreateEmpty(Context, NumSizes);
10270     break;
10271   }
10272   case llvm::omp::OMPC_full:
10273     C = OMPFullClause::CreateEmpty(Context);
10274     break;
10275   case llvm::omp::OMPC_partial:
10276     C = OMPPartialClause::CreateEmpty(Context);
10277     break;
10278   case llvm::omp::OMPC_allocator:
10279     C = new (Context) OMPAllocatorClause();
10280     break;
10281   case llvm::omp::OMPC_collapse:
10282     C = new (Context) OMPCollapseClause();
10283     break;
10284   case llvm::omp::OMPC_default:
10285     C = new (Context) OMPDefaultClause();
10286     break;
10287   case llvm::omp::OMPC_proc_bind:
10288     C = new (Context) OMPProcBindClause();
10289     break;
10290   case llvm::omp::OMPC_schedule:
10291     C = new (Context) OMPScheduleClause();
10292     break;
10293   case llvm::omp::OMPC_ordered:
10294     C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
10295     break;
10296   case llvm::omp::OMPC_nowait:
10297     C = new (Context) OMPNowaitClause();
10298     break;
10299   case llvm::omp::OMPC_untied:
10300     C = new (Context) OMPUntiedClause();
10301     break;
10302   case llvm::omp::OMPC_mergeable:
10303     C = new (Context) OMPMergeableClause();
10304     break;
10305   case llvm::omp::OMPC_read:
10306     C = new (Context) OMPReadClause();
10307     break;
10308   case llvm::omp::OMPC_write:
10309     C = new (Context) OMPWriteClause();
10310     break;
10311   case llvm::omp::OMPC_update:
10312     C = OMPUpdateClause::CreateEmpty(Context, Record.readInt());
10313     break;
10314   case llvm::omp::OMPC_capture:
10315     C = new (Context) OMPCaptureClause();
10316     break;
10317   case llvm::omp::OMPC_compare:
10318     C = new (Context) OMPCompareClause();
10319     break;
10320   case llvm::omp::OMPC_fail:
10321     C = new (Context) OMPFailClause();
10322     break;
10323   case llvm::omp::OMPC_seq_cst:
10324     C = new (Context) OMPSeqCstClause();
10325     break;
10326   case llvm::omp::OMPC_acq_rel:
10327     C = new (Context) OMPAcqRelClause();
10328     break;
10329   case llvm::omp::OMPC_acquire:
10330     C = new (Context) OMPAcquireClause();
10331     break;
10332   case llvm::omp::OMPC_release:
10333     C = new (Context) OMPReleaseClause();
10334     break;
10335   case llvm::omp::OMPC_relaxed:
10336     C = new (Context) OMPRelaxedClause();
10337     break;
10338   case llvm::omp::OMPC_threads:
10339     C = new (Context) OMPThreadsClause();
10340     break;
10341   case llvm::omp::OMPC_simd:
10342     C = new (Context) OMPSIMDClause();
10343     break;
10344   case llvm::omp::OMPC_nogroup:
10345     C = new (Context) OMPNogroupClause();
10346     break;
10347   case llvm::omp::OMPC_unified_address:
10348     C = new (Context) OMPUnifiedAddressClause();
10349     break;
10350   case llvm::omp::OMPC_unified_shared_memory:
10351     C = new (Context) OMPUnifiedSharedMemoryClause();
10352     break;
10353   case llvm::omp::OMPC_reverse_offload:
10354     C = new (Context) OMPReverseOffloadClause();
10355     break;
10356   case llvm::omp::OMPC_dynamic_allocators:
10357     C = new (Context) OMPDynamicAllocatorsClause();
10358     break;
10359   case llvm::omp::OMPC_atomic_default_mem_order:
10360     C = new (Context) OMPAtomicDefaultMemOrderClause();
10361     break;
10362   case llvm::omp::OMPC_at:
10363     C = new (Context) OMPAtClause();
10364     break;
10365   case llvm::omp::OMPC_severity:
10366     C = new (Context) OMPSeverityClause();
10367     break;
10368   case llvm::omp::OMPC_message:
10369     C = new (Context) OMPMessageClause();
10370     break;
10371   case llvm::omp::OMPC_private:
10372     C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
10373     break;
10374   case llvm::omp::OMPC_firstprivate:
10375     C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
10376     break;
10377   case llvm::omp::OMPC_lastprivate:
10378     C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
10379     break;
10380   case llvm::omp::OMPC_shared:
10381     C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
10382     break;
10383   case llvm::omp::OMPC_reduction: {
10384     unsigned N = Record.readInt();
10385     auto Modifier = Record.readEnum<OpenMPReductionClauseModifier>();
10386     C = OMPReductionClause::CreateEmpty(Context, N, Modifier);
10387     break;
10388   }
10389   case llvm::omp::OMPC_task_reduction:
10390     C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
10391     break;
10392   case llvm::omp::OMPC_in_reduction:
10393     C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
10394     break;
10395   case llvm::omp::OMPC_linear:
10396     C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
10397     break;
10398   case llvm::omp::OMPC_aligned:
10399     C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
10400     break;
10401   case llvm::omp::OMPC_copyin:
10402     C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
10403     break;
10404   case llvm::omp::OMPC_copyprivate:
10405     C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
10406     break;
10407   case llvm::omp::OMPC_flush:
10408     C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
10409     break;
10410   case llvm::omp::OMPC_depobj:
10411     C = OMPDepobjClause::CreateEmpty(Context);
10412     break;
10413   case llvm::omp::OMPC_depend: {
10414     unsigned NumVars = Record.readInt();
10415     unsigned NumLoops = Record.readInt();
10416     C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
10417     break;
10418   }
10419   case llvm::omp::OMPC_device:
10420     C = new (Context) OMPDeviceClause();
10421     break;
10422   case llvm::omp::OMPC_map: {
10423     OMPMappableExprListSizeTy Sizes;
10424     Sizes.NumVars = Record.readInt();
10425     Sizes.NumUniqueDeclarations = Record.readInt();
10426     Sizes.NumComponentLists = Record.readInt();
10427     Sizes.NumComponents = Record.readInt();
10428     C = OMPMapClause::CreateEmpty(Context, Sizes);
10429     break;
10430   }
10431   case llvm::omp::OMPC_num_teams:
10432     C = new (Context) OMPNumTeamsClause();
10433     break;
10434   case llvm::omp::OMPC_thread_limit:
10435     C = new (Context) OMPThreadLimitClause();
10436     break;
10437   case llvm::omp::OMPC_priority:
10438     C = new (Context) OMPPriorityClause();
10439     break;
10440   case llvm::omp::OMPC_grainsize:
10441     C = new (Context) OMPGrainsizeClause();
10442     break;
10443   case llvm::omp::OMPC_num_tasks:
10444     C = new (Context) OMPNumTasksClause();
10445     break;
10446   case llvm::omp::OMPC_hint:
10447     C = new (Context) OMPHintClause();
10448     break;
10449   case llvm::omp::OMPC_dist_schedule:
10450     C = new (Context) OMPDistScheduleClause();
10451     break;
10452   case llvm::omp::OMPC_defaultmap:
10453     C = new (Context) OMPDefaultmapClause();
10454     break;
10455   case llvm::omp::OMPC_to: {
10456     OMPMappableExprListSizeTy Sizes;
10457     Sizes.NumVars = Record.readInt();
10458     Sizes.NumUniqueDeclarations = Record.readInt();
10459     Sizes.NumComponentLists = Record.readInt();
10460     Sizes.NumComponents = Record.readInt();
10461     C = OMPToClause::CreateEmpty(Context, Sizes);
10462     break;
10463   }
10464   case llvm::omp::OMPC_from: {
10465     OMPMappableExprListSizeTy Sizes;
10466     Sizes.NumVars = Record.readInt();
10467     Sizes.NumUniqueDeclarations = Record.readInt();
10468     Sizes.NumComponentLists = Record.readInt();
10469     Sizes.NumComponents = Record.readInt();
10470     C = OMPFromClause::CreateEmpty(Context, Sizes);
10471     break;
10472   }
10473   case llvm::omp::OMPC_use_device_ptr: {
10474     OMPMappableExprListSizeTy Sizes;
10475     Sizes.NumVars = Record.readInt();
10476     Sizes.NumUniqueDeclarations = Record.readInt();
10477     Sizes.NumComponentLists = Record.readInt();
10478     Sizes.NumComponents = Record.readInt();
10479     C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
10480     break;
10481   }
10482   case llvm::omp::OMPC_use_device_addr: {
10483     OMPMappableExprListSizeTy Sizes;
10484     Sizes.NumVars = Record.readInt();
10485     Sizes.NumUniqueDeclarations = Record.readInt();
10486     Sizes.NumComponentLists = Record.readInt();
10487     Sizes.NumComponents = Record.readInt();
10488     C = OMPUseDeviceAddrClause::CreateEmpty(Context, Sizes);
10489     break;
10490   }
10491   case llvm::omp::OMPC_is_device_ptr: {
10492     OMPMappableExprListSizeTy Sizes;
10493     Sizes.NumVars = Record.readInt();
10494     Sizes.NumUniqueDeclarations = Record.readInt();
10495     Sizes.NumComponentLists = Record.readInt();
10496     Sizes.NumComponents = Record.readInt();
10497     C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
10498     break;
10499   }
10500   case llvm::omp::OMPC_has_device_addr: {
10501     OMPMappableExprListSizeTy Sizes;
10502     Sizes.NumVars = Record.readInt();
10503     Sizes.NumUniqueDeclarations = Record.readInt();
10504     Sizes.NumComponentLists = Record.readInt();
10505     Sizes.NumComponents = Record.readInt();
10506     C = OMPHasDeviceAddrClause::CreateEmpty(Context, Sizes);
10507     break;
10508   }
10509   case llvm::omp::OMPC_allocate:
10510     C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
10511     break;
10512   case llvm::omp::OMPC_nontemporal:
10513     C = OMPNontemporalClause::CreateEmpty(Context, Record.readInt());
10514     break;
10515   case llvm::omp::OMPC_inclusive:
10516     C = OMPInclusiveClause::CreateEmpty(Context, Record.readInt());
10517     break;
10518   case llvm::omp::OMPC_exclusive:
10519     C = OMPExclusiveClause::CreateEmpty(Context, Record.readInt());
10520     break;
10521   case llvm::omp::OMPC_order:
10522     C = new (Context) OMPOrderClause();
10523     break;
10524   case llvm::omp::OMPC_init:
10525     C = OMPInitClause::CreateEmpty(Context, Record.readInt());
10526     break;
10527   case llvm::omp::OMPC_use:
10528     C = new (Context) OMPUseClause();
10529     break;
10530   case llvm::omp::OMPC_destroy:
10531     C = new (Context) OMPDestroyClause();
10532     break;
10533   case llvm::omp::OMPC_novariants:
10534     C = new (Context) OMPNovariantsClause();
10535     break;
10536   case llvm::omp::OMPC_nocontext:
10537     C = new (Context) OMPNocontextClause();
10538     break;
10539   case llvm::omp::OMPC_detach:
10540     C = new (Context) OMPDetachClause();
10541     break;
10542   case llvm::omp::OMPC_uses_allocators:
10543     C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
10544     break;
10545   case llvm::omp::OMPC_affinity:
10546     C = OMPAffinityClause::CreateEmpty(Context, Record.readInt());
10547     break;
10548   case llvm::omp::OMPC_filter:
10549     C = new (Context) OMPFilterClause();
10550     break;
10551   case llvm::omp::OMPC_bind:
10552     C = OMPBindClause::CreateEmpty(Context);
10553     break;
10554   case llvm::omp::OMPC_align:
10555     C = new (Context) OMPAlignClause();
10556     break;
10557   case llvm::omp::OMPC_ompx_dyn_cgroup_mem:
10558     C = new (Context) OMPXDynCGroupMemClause();
10559     break;
10560   case llvm::omp::OMPC_doacross: {
10561     unsigned NumVars = Record.readInt();
10562     unsigned NumLoops = Record.readInt();
10563     C = OMPDoacrossClause::CreateEmpty(Context, NumVars, NumLoops);
10564     break;
10565   }
10566   case llvm::omp::OMPC_ompx_attribute:
10567     C = new (Context) OMPXAttributeClause();
10568     break;
10569   case llvm::omp::OMPC_ompx_bare:
10570     C = new (Context) OMPXBareClause();
10571     break;
10572 #define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
10573   case llvm::omp::Enum:                                                        \
10574     break;
10575 #include "llvm/Frontend/OpenMP/OMPKinds.def"
10576   default:
10577     break;
10578   }
10579   assert(C && "Unknown OMPClause type");
10580 
10581   Visit(C);
10582   C->setLocStart(Record.readSourceLocation());
10583   C->setLocEnd(Record.readSourceLocation());
10584 
10585   return C;
10586 }
10587 
10588 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
10589   C->setPreInitStmt(Record.readSubStmt(),
10590                     static_cast<OpenMPDirectiveKind>(Record.readInt()));
10591 }
10592 
10593 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
10594   VisitOMPClauseWithPreInit(C);
10595   C->setPostUpdateExpr(Record.readSubExpr());
10596 }
10597 
10598 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
10599   VisitOMPClauseWithPreInit(C);
10600   C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
10601   C->setNameModifierLoc(Record.readSourceLocation());
10602   C->setColonLoc(Record.readSourceLocation());
10603   C->setCondition(Record.readSubExpr());
10604   C->setLParenLoc(Record.readSourceLocation());
10605 }
10606 
10607 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
10608   VisitOMPClauseWithPreInit(C);
10609   C->setCondition(Record.readSubExpr());
10610   C->setLParenLoc(Record.readSourceLocation());
10611 }
10612 
10613 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
10614   VisitOMPClauseWithPreInit(C);
10615   C->setNumThreads(Record.readSubExpr());
10616   C->setLParenLoc(Record.readSourceLocation());
10617 }
10618 
10619 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
10620   C->setSafelen(Record.readSubExpr());
10621   C->setLParenLoc(Record.readSourceLocation());
10622 }
10623 
10624 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
10625   C->setSimdlen(Record.readSubExpr());
10626   C->setLParenLoc(Record.readSourceLocation());
10627 }
10628 
10629 void OMPClauseReader::VisitOMPSizesClause(OMPSizesClause *C) {
10630   for (Expr *&E : C->getSizesRefs())
10631     E = Record.readSubExpr();
10632   C->setLParenLoc(Record.readSourceLocation());
10633 }
10634 
10635 void OMPClauseReader::VisitOMPFullClause(OMPFullClause *C) {}
10636 
10637 void OMPClauseReader::VisitOMPPartialClause(OMPPartialClause *C) {
10638   C->setFactor(Record.readSubExpr());
10639   C->setLParenLoc(Record.readSourceLocation());
10640 }
10641 
10642 void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
10643   C->setAllocator(Record.readExpr());
10644   C->setLParenLoc(Record.readSourceLocation());
10645 }
10646 
10647 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
10648   C->setNumForLoops(Record.readSubExpr());
10649   C->setLParenLoc(Record.readSourceLocation());
10650 }
10651 
10652 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
10653   C->setDefaultKind(static_cast<llvm::omp::DefaultKind>(Record.readInt()));
10654   C->setLParenLoc(Record.readSourceLocation());
10655   C->setDefaultKindKwLoc(Record.readSourceLocation());
10656 }
10657 
10658 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
10659   C->setProcBindKind(static_cast<llvm::omp::ProcBindKind>(Record.readInt()));
10660   C->setLParenLoc(Record.readSourceLocation());
10661   C->setProcBindKindKwLoc(Record.readSourceLocation());
10662 }
10663 
10664 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
10665   VisitOMPClauseWithPreInit(C);
10666   C->setScheduleKind(
10667        static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
10668   C->setFirstScheduleModifier(
10669       static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
10670   C->setSecondScheduleModifier(
10671       static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
10672   C->setChunkSize(Record.readSubExpr());
10673   C->setLParenLoc(Record.readSourceLocation());
10674   C->setFirstScheduleModifierLoc(Record.readSourceLocation());
10675   C->setSecondScheduleModifierLoc(Record.readSourceLocation());
10676   C->setScheduleKindLoc(Record.readSourceLocation());
10677   C->setCommaLoc(Record.readSourceLocation());
10678 }
10679 
10680 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
10681   C->setNumForLoops(Record.readSubExpr());
10682   for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
10683     C->setLoopNumIterations(I, Record.readSubExpr());
10684   for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
10685     C->setLoopCounter(I, Record.readSubExpr());
10686   C->setLParenLoc(Record.readSourceLocation());
10687 }
10688 
10689 void OMPClauseReader::VisitOMPDetachClause(OMPDetachClause *C) {
10690   C->setEventHandler(Record.readSubExpr());
10691   C->setLParenLoc(Record.readSourceLocation());
10692 }
10693 
10694 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
10695 
10696 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
10697 
10698 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
10699 
10700 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
10701 
10702 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
10703 
10704 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *C) {
10705   if (C->isExtended()) {
10706     C->setLParenLoc(Record.readSourceLocation());
10707     C->setArgumentLoc(Record.readSourceLocation());
10708     C->setDependencyKind(Record.readEnum<OpenMPDependClauseKind>());
10709   }
10710 }
10711 
10712 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
10713 
10714 void OMPClauseReader::VisitOMPCompareClause(OMPCompareClause *) {}
10715 
10716 // Read the parameter of fail clause. This will have been saved when
10717 // OMPClauseWriter is called.
10718 void OMPClauseReader::VisitOMPFailClause(OMPFailClause *C) {
10719   C->setLParenLoc(Record.readSourceLocation());
10720   SourceLocation FailParameterLoc = Record.readSourceLocation();
10721   C->setFailParameterLoc(FailParameterLoc);
10722   OpenMPClauseKind CKind = Record.readEnum<OpenMPClauseKind>();
10723   C->setFailParameter(CKind);
10724 }
10725 
10726 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
10727 
10728 void OMPClauseReader::VisitOMPAcqRelClause(OMPAcqRelClause *) {}
10729 
10730 void OMPClauseReader::VisitOMPAcquireClause(OMPAcquireClause *) {}
10731 
10732 void OMPClauseReader::VisitOMPReleaseClause(OMPReleaseClause *) {}
10733 
10734 void OMPClauseReader::VisitOMPRelaxedClause(OMPRelaxedClause *) {}
10735 
10736 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
10737 
10738 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
10739 
10740 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
10741 
10742 void OMPClauseReader::VisitOMPInitClause(OMPInitClause *C) {
10743   unsigned NumVars = C->varlist_size();
10744   SmallVector<Expr *, 16> Vars;
10745   Vars.reserve(NumVars);
10746   for (unsigned I = 0; I != NumVars; ++I)
10747     Vars.push_back(Record.readSubExpr());
10748   C->setVarRefs(Vars);
10749   C->setIsTarget(Record.readBool());
10750   C->setIsTargetSync(Record.readBool());
10751   C->setLParenLoc(Record.readSourceLocation());
10752   C->setVarLoc(Record.readSourceLocation());
10753 }
10754 
10755 void OMPClauseReader::VisitOMPUseClause(OMPUseClause *C) {
10756   C->setInteropVar(Record.readSubExpr());
10757   C->setLParenLoc(Record.readSourceLocation());
10758   C->setVarLoc(Record.readSourceLocation());
10759 }
10760 
10761 void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *C) {
10762   C->setInteropVar(Record.readSubExpr());
10763   C->setLParenLoc(Record.readSourceLocation());
10764   C->setVarLoc(Record.readSourceLocation());
10765 }
10766 
10767 void OMPClauseReader::VisitOMPNovariantsClause(OMPNovariantsClause *C) {
10768   VisitOMPClauseWithPreInit(C);
10769   C->setCondition(Record.readSubExpr());
10770   C->setLParenLoc(Record.readSourceLocation());
10771 }
10772 
10773 void OMPClauseReader::VisitOMPNocontextClause(OMPNocontextClause *C) {
10774   VisitOMPClauseWithPreInit(C);
10775   C->setCondition(Record.readSubExpr());
10776   C->setLParenLoc(Record.readSourceLocation());
10777 }
10778 
10779 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
10780 
10781 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
10782     OMPUnifiedSharedMemoryClause *) {}
10783 
10784 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
10785 
10786 void
10787 OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
10788 }
10789 
10790 void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
10791     OMPAtomicDefaultMemOrderClause *C) {
10792   C->setAtomicDefaultMemOrderKind(
10793       static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
10794   C->setLParenLoc(Record.readSourceLocation());
10795   C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
10796 }
10797 
10798 void OMPClauseReader::VisitOMPAtClause(OMPAtClause *C) {
10799   C->setAtKind(static_cast<OpenMPAtClauseKind>(Record.readInt()));
10800   C->setLParenLoc(Record.readSourceLocation());
10801   C->setAtKindKwLoc(Record.readSourceLocation());
10802 }
10803 
10804 void OMPClauseReader::VisitOMPSeverityClause(OMPSeverityClause *C) {
10805   C->setSeverityKind(static_cast<OpenMPSeverityClauseKind>(Record.readInt()));
10806   C->setLParenLoc(Record.readSourceLocation());
10807   C->setSeverityKindKwLoc(Record.readSourceLocation());
10808 }
10809 
10810 void OMPClauseReader::VisitOMPMessageClause(OMPMessageClause *C) {
10811   C->setMessageString(Record.readSubExpr());
10812   C->setLParenLoc(Record.readSourceLocation());
10813 }
10814 
10815 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
10816   C->setLParenLoc(Record.readSourceLocation());
10817   unsigned NumVars = C->varlist_size();
10818   SmallVector<Expr *, 16> Vars;
10819   Vars.reserve(NumVars);
10820   for (unsigned i = 0; i != NumVars; ++i)
10821     Vars.push_back(Record.readSubExpr());
10822   C->setVarRefs(Vars);
10823   Vars.clear();
10824   for (unsigned i = 0; i != NumVars; ++i)
10825     Vars.push_back(Record.readSubExpr());
10826   C->setPrivateCopies(Vars);
10827 }
10828 
10829 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
10830   VisitOMPClauseWithPreInit(C);
10831   C->setLParenLoc(Record.readSourceLocation());
10832   unsigned NumVars = C->varlist_size();
10833   SmallVector<Expr *, 16> Vars;
10834   Vars.reserve(NumVars);
10835   for (unsigned i = 0; i != NumVars; ++i)
10836     Vars.push_back(Record.readSubExpr());
10837   C->setVarRefs(Vars);
10838   Vars.clear();
10839   for (unsigned i = 0; i != NumVars; ++i)
10840     Vars.push_back(Record.readSubExpr());
10841   C->setPrivateCopies(Vars);
10842   Vars.clear();
10843   for (unsigned i = 0; i != NumVars; ++i)
10844     Vars.push_back(Record.readSubExpr());
10845   C->setInits(Vars);
10846 }
10847 
10848 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
10849   VisitOMPClauseWithPostUpdate(C);
10850   C->setLParenLoc(Record.readSourceLocation());
10851   C->setKind(Record.readEnum<OpenMPLastprivateModifier>());
10852   C->setKindLoc(Record.readSourceLocation());
10853   C->setColonLoc(Record.readSourceLocation());
10854   unsigned NumVars = C->varlist_size();
10855   SmallVector<Expr *, 16> Vars;
10856   Vars.reserve(NumVars);
10857   for (unsigned i = 0; i != NumVars; ++i)
10858     Vars.push_back(Record.readSubExpr());
10859   C->setVarRefs(Vars);
10860   Vars.clear();
10861   for (unsigned i = 0; i != NumVars; ++i)
10862     Vars.push_back(Record.readSubExpr());
10863   C->setPrivateCopies(Vars);
10864   Vars.clear();
10865   for (unsigned i = 0; i != NumVars; ++i)
10866     Vars.push_back(Record.readSubExpr());
10867   C->setSourceExprs(Vars);
10868   Vars.clear();
10869   for (unsigned i = 0; i != NumVars; ++i)
10870     Vars.push_back(Record.readSubExpr());
10871   C->setDestinationExprs(Vars);
10872   Vars.clear();
10873   for (unsigned i = 0; i != NumVars; ++i)
10874     Vars.push_back(Record.readSubExpr());
10875   C->setAssignmentOps(Vars);
10876 }
10877 
10878 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
10879   C->setLParenLoc(Record.readSourceLocation());
10880   unsigned NumVars = C->varlist_size();
10881   SmallVector<Expr *, 16> Vars;
10882   Vars.reserve(NumVars);
10883   for (unsigned i = 0; i != NumVars; ++i)
10884     Vars.push_back(Record.readSubExpr());
10885   C->setVarRefs(Vars);
10886 }
10887 
10888 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
10889   VisitOMPClauseWithPostUpdate(C);
10890   C->setLParenLoc(Record.readSourceLocation());
10891   C->setModifierLoc(Record.readSourceLocation());
10892   C->setColonLoc(Record.readSourceLocation());
10893   NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
10894   DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
10895   C->setQualifierLoc(NNSL);
10896   C->setNameInfo(DNI);
10897 
10898   unsigned NumVars = C->varlist_size();
10899   SmallVector<Expr *, 16> Vars;
10900   Vars.reserve(NumVars);
10901   for (unsigned i = 0; i != NumVars; ++i)
10902     Vars.push_back(Record.readSubExpr());
10903   C->setVarRefs(Vars);
10904   Vars.clear();
10905   for (unsigned i = 0; i != NumVars; ++i)
10906     Vars.push_back(Record.readSubExpr());
10907   C->setPrivates(Vars);
10908   Vars.clear();
10909   for (unsigned i = 0; i != NumVars; ++i)
10910     Vars.push_back(Record.readSubExpr());
10911   C->setLHSExprs(Vars);
10912   Vars.clear();
10913   for (unsigned i = 0; i != NumVars; ++i)
10914     Vars.push_back(Record.readSubExpr());
10915   C->setRHSExprs(Vars);
10916   Vars.clear();
10917   for (unsigned i = 0; i != NumVars; ++i)
10918     Vars.push_back(Record.readSubExpr());
10919   C->setReductionOps(Vars);
10920   if (C->getModifier() == OMPC_REDUCTION_inscan) {
10921     Vars.clear();
10922     for (unsigned i = 0; i != NumVars; ++i)
10923       Vars.push_back(Record.readSubExpr());
10924     C->setInscanCopyOps(Vars);
10925     Vars.clear();
10926     for (unsigned i = 0; i != NumVars; ++i)
10927       Vars.push_back(Record.readSubExpr());
10928     C->setInscanCopyArrayTemps(Vars);
10929     Vars.clear();
10930     for (unsigned i = 0; i != NumVars; ++i)
10931       Vars.push_back(Record.readSubExpr());
10932     C->setInscanCopyArrayElems(Vars);
10933   }
10934 }
10935 
10936 void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
10937   VisitOMPClauseWithPostUpdate(C);
10938   C->setLParenLoc(Record.readSourceLocation());
10939   C->setColonLoc(Record.readSourceLocation());
10940   NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
10941   DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
10942   C->setQualifierLoc(NNSL);
10943   C->setNameInfo(DNI);
10944 
10945   unsigned NumVars = C->varlist_size();
10946   SmallVector<Expr *, 16> Vars;
10947   Vars.reserve(NumVars);
10948   for (unsigned I = 0; I != NumVars; ++I)
10949     Vars.push_back(Record.readSubExpr());
10950   C->setVarRefs(Vars);
10951   Vars.clear();
10952   for (unsigned I = 0; I != NumVars; ++I)
10953     Vars.push_back(Record.readSubExpr());
10954   C->setPrivates(Vars);
10955   Vars.clear();
10956   for (unsigned I = 0; I != NumVars; ++I)
10957     Vars.push_back(Record.readSubExpr());
10958   C->setLHSExprs(Vars);
10959   Vars.clear();
10960   for (unsigned I = 0; I != NumVars; ++I)
10961     Vars.push_back(Record.readSubExpr());
10962   C->setRHSExprs(Vars);
10963   Vars.clear();
10964   for (unsigned I = 0; I != NumVars; ++I)
10965     Vars.push_back(Record.readSubExpr());
10966   C->setReductionOps(Vars);
10967 }
10968 
10969 void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
10970   VisitOMPClauseWithPostUpdate(C);
10971   C->setLParenLoc(Record.readSourceLocation());
10972   C->setColonLoc(Record.readSourceLocation());
10973   NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
10974   DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
10975   C->setQualifierLoc(NNSL);
10976   C->setNameInfo(DNI);
10977 
10978   unsigned NumVars = C->varlist_size();
10979   SmallVector<Expr *, 16> Vars;
10980   Vars.reserve(NumVars);
10981   for (unsigned I = 0; I != NumVars; ++I)
10982     Vars.push_back(Record.readSubExpr());
10983   C->setVarRefs(Vars);
10984   Vars.clear();
10985   for (unsigned I = 0; I != NumVars; ++I)
10986     Vars.push_back(Record.readSubExpr());
10987   C->setPrivates(Vars);
10988   Vars.clear();
10989   for (unsigned I = 0; I != NumVars; ++I)
10990     Vars.push_back(Record.readSubExpr());
10991   C->setLHSExprs(Vars);
10992   Vars.clear();
10993   for (unsigned I = 0; I != NumVars; ++I)
10994     Vars.push_back(Record.readSubExpr());
10995   C->setRHSExprs(Vars);
10996   Vars.clear();
10997   for (unsigned I = 0; I != NumVars; ++I)
10998     Vars.push_back(Record.readSubExpr());
10999   C->setReductionOps(Vars);
11000   Vars.clear();
11001   for (unsigned I = 0; I != NumVars; ++I)
11002     Vars.push_back(Record.readSubExpr());
11003   C->setTaskgroupDescriptors(Vars);
11004 }
11005 
11006 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
11007   VisitOMPClauseWithPostUpdate(C);
11008   C->setLParenLoc(Record.readSourceLocation());
11009   C->setColonLoc(Record.readSourceLocation());
11010   C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
11011   C->setModifierLoc(Record.readSourceLocation());
11012   unsigned NumVars = C->varlist_size();
11013   SmallVector<Expr *, 16> Vars;
11014   Vars.reserve(NumVars);
11015   for (unsigned i = 0; i != NumVars; ++i)
11016     Vars.push_back(Record.readSubExpr());
11017   C->setVarRefs(Vars);
11018   Vars.clear();
11019   for (unsigned i = 0; i != NumVars; ++i)
11020     Vars.push_back(Record.readSubExpr());
11021   C->setPrivates(Vars);
11022   Vars.clear();
11023   for (unsigned i = 0; i != NumVars; ++i)
11024     Vars.push_back(Record.readSubExpr());
11025   C->setInits(Vars);
11026   Vars.clear();
11027   for (unsigned i = 0; i != NumVars; ++i)
11028     Vars.push_back(Record.readSubExpr());
11029   C->setUpdates(Vars);
11030   Vars.clear();
11031   for (unsigned i = 0; i != NumVars; ++i)
11032     Vars.push_back(Record.readSubExpr());
11033   C->setFinals(Vars);
11034   C->setStep(Record.readSubExpr());
11035   C->setCalcStep(Record.readSubExpr());
11036   Vars.clear();
11037   for (unsigned I = 0; I != NumVars + 1; ++I)
11038     Vars.push_back(Record.readSubExpr());
11039   C->setUsedExprs(Vars);
11040 }
11041 
11042 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
11043   C->setLParenLoc(Record.readSourceLocation());
11044   C->setColonLoc(Record.readSourceLocation());
11045   unsigned NumVars = C->varlist_size();
11046   SmallVector<Expr *, 16> Vars;
11047   Vars.reserve(NumVars);
11048   for (unsigned i = 0; i != NumVars; ++i)
11049     Vars.push_back(Record.readSubExpr());
11050   C->setVarRefs(Vars);
11051   C->setAlignment(Record.readSubExpr());
11052 }
11053 
11054 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
11055   C->setLParenLoc(Record.readSourceLocation());
11056   unsigned NumVars = C->varlist_size();
11057   SmallVector<Expr *, 16> Exprs;
11058   Exprs.reserve(NumVars);
11059   for (unsigned i = 0; i != NumVars; ++i)
11060     Exprs.push_back(Record.readSubExpr());
11061   C->setVarRefs(Exprs);
11062   Exprs.clear();
11063   for (unsigned i = 0; i != NumVars; ++i)
11064     Exprs.push_back(Record.readSubExpr());
11065   C->setSourceExprs(Exprs);
11066   Exprs.clear();
11067   for (unsigned i = 0; i != NumVars; ++i)
11068     Exprs.push_back(Record.readSubExpr());
11069   C->setDestinationExprs(Exprs);
11070   Exprs.clear();
11071   for (unsigned i = 0; i != NumVars; ++i)
11072     Exprs.push_back(Record.readSubExpr());
11073   C->setAssignmentOps(Exprs);
11074 }
11075 
11076 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
11077   C->setLParenLoc(Record.readSourceLocation());
11078   unsigned NumVars = C->varlist_size();
11079   SmallVector<Expr *, 16> Exprs;
11080   Exprs.reserve(NumVars);
11081   for (unsigned i = 0; i != NumVars; ++i)
11082     Exprs.push_back(Record.readSubExpr());
11083   C->setVarRefs(Exprs);
11084   Exprs.clear();
11085   for (unsigned i = 0; i != NumVars; ++i)
11086     Exprs.push_back(Record.readSubExpr());
11087   C->setSourceExprs(Exprs);
11088   Exprs.clear();
11089   for (unsigned i = 0; i != NumVars; ++i)
11090     Exprs.push_back(Record.readSubExpr());
11091   C->setDestinationExprs(Exprs);
11092   Exprs.clear();
11093   for (unsigned i = 0; i != NumVars; ++i)
11094     Exprs.push_back(Record.readSubExpr());
11095   C->setAssignmentOps(Exprs);
11096 }
11097 
11098 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
11099   C->setLParenLoc(Record.readSourceLocation());
11100   unsigned NumVars = C->varlist_size();
11101   SmallVector<Expr *, 16> Vars;
11102   Vars.reserve(NumVars);
11103   for (unsigned i = 0; i != NumVars; ++i)
11104     Vars.push_back(Record.readSubExpr());
11105   C->setVarRefs(Vars);
11106 }
11107 
11108 void OMPClauseReader::VisitOMPDepobjClause(OMPDepobjClause *C) {
11109   C->setDepobj(Record.readSubExpr());
11110   C->setLParenLoc(Record.readSourceLocation());
11111 }
11112 
11113 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
11114   C->setLParenLoc(Record.readSourceLocation());
11115   C->setModifier(Record.readSubExpr());
11116   C->setDependencyKind(
11117       static_cast<OpenMPDependClauseKind>(Record.readInt()));
11118   C->setDependencyLoc(Record.readSourceLocation());
11119   C->setColonLoc(Record.readSourceLocation());
11120   C->setOmpAllMemoryLoc(Record.readSourceLocation());
11121   unsigned NumVars = C->varlist_size();
11122   SmallVector<Expr *, 16> Vars;
11123   Vars.reserve(NumVars);
11124   for (unsigned I = 0; I != NumVars; ++I)
11125     Vars.push_back(Record.readSubExpr());
11126   C->setVarRefs(Vars);
11127   for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
11128     C->setLoopData(I, Record.readSubExpr());
11129 }
11130 
11131 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
11132   VisitOMPClauseWithPreInit(C);
11133   C->setModifier(Record.readEnum<OpenMPDeviceClauseModifier>());
11134   C->setDevice(Record.readSubExpr());
11135   C->setModifierLoc(Record.readSourceLocation());
11136   C->setLParenLoc(Record.readSourceLocation());
11137 }
11138 
11139 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
11140   C->setLParenLoc(Record.readSourceLocation());
11141   bool HasIteratorModifier = false;
11142   for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) {
11143     C->setMapTypeModifier(
11144         I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
11145     C->setMapTypeModifierLoc(I, Record.readSourceLocation());
11146     if (C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
11147       HasIteratorModifier = true;
11148   }
11149   C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
11150   C->setMapperIdInfo(Record.readDeclarationNameInfo());
11151   C->setMapType(
11152      static_cast<OpenMPMapClauseKind>(Record.readInt()));
11153   C->setMapLoc(Record.readSourceLocation());
11154   C->setColonLoc(Record.readSourceLocation());
11155   auto NumVars = C->varlist_size();
11156   auto UniqueDecls = C->getUniqueDeclarationsNum();
11157   auto TotalLists = C->getTotalComponentListNum();
11158   auto TotalComponents = C->getTotalComponentsNum();
11159 
11160   SmallVector<Expr *, 16> Vars;
11161   Vars.reserve(NumVars);
11162   for (unsigned i = 0; i != NumVars; ++i)
11163     Vars.push_back(Record.readExpr());
11164   C->setVarRefs(Vars);
11165 
11166   SmallVector<Expr *, 16> UDMappers;
11167   UDMappers.reserve(NumVars);
11168   for (unsigned I = 0; I < NumVars; ++I)
11169     UDMappers.push_back(Record.readExpr());
11170   C->setUDMapperRefs(UDMappers);
11171 
11172   if (HasIteratorModifier)
11173     C->setIteratorModifier(Record.readExpr());
11174 
11175   SmallVector<ValueDecl *, 16> Decls;
11176   Decls.reserve(UniqueDecls);
11177   for (unsigned i = 0; i < UniqueDecls; ++i)
11178     Decls.push_back(Record.readDeclAs<ValueDecl>());
11179   C->setUniqueDecls(Decls);
11180 
11181   SmallVector<unsigned, 16> ListsPerDecl;
11182   ListsPerDecl.reserve(UniqueDecls);
11183   for (unsigned i = 0; i < UniqueDecls; ++i)
11184     ListsPerDecl.push_back(Record.readInt());
11185   C->setDeclNumLists(ListsPerDecl);
11186 
11187   SmallVector<unsigned, 32> ListSizes;
11188   ListSizes.reserve(TotalLists);
11189   for (unsigned i = 0; i < TotalLists; ++i)
11190     ListSizes.push_back(Record.readInt());
11191   C->setComponentListSizes(ListSizes);
11192 
11193   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11194   Components.reserve(TotalComponents);
11195   for (unsigned i = 0; i < TotalComponents; ++i) {
11196     Expr *AssociatedExprPr = Record.readExpr();
11197     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11198     Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11199                             /*IsNonContiguous=*/false);
11200   }
11201   C->setComponents(Components, ListSizes);
11202 }
11203 
11204 void OMPClauseReader::VisitOMPAllocateClause(OMPAllocateClause *C) {
11205   C->setLParenLoc(Record.readSourceLocation());
11206   C->setColonLoc(Record.readSourceLocation());
11207   C->setAllocator(Record.readSubExpr());
11208   unsigned NumVars = C->varlist_size();
11209   SmallVector<Expr *, 16> Vars;
11210   Vars.reserve(NumVars);
11211   for (unsigned i = 0; i != NumVars; ++i)
11212     Vars.push_back(Record.readSubExpr());
11213   C->setVarRefs(Vars);
11214 }
11215 
11216 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
11217   VisitOMPClauseWithPreInit(C);
11218   C->setNumTeams(Record.readSubExpr());
11219   C->setLParenLoc(Record.readSourceLocation());
11220 }
11221 
11222 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
11223   VisitOMPClauseWithPreInit(C);
11224   C->setThreadLimit(Record.readSubExpr());
11225   C->setLParenLoc(Record.readSourceLocation());
11226 }
11227 
11228 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
11229   VisitOMPClauseWithPreInit(C);
11230   C->setPriority(Record.readSubExpr());
11231   C->setLParenLoc(Record.readSourceLocation());
11232 }
11233 
11234 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
11235   VisitOMPClauseWithPreInit(C);
11236   C->setModifier(Record.readEnum<OpenMPGrainsizeClauseModifier>());
11237   C->setGrainsize(Record.readSubExpr());
11238   C->setModifierLoc(Record.readSourceLocation());
11239   C->setLParenLoc(Record.readSourceLocation());
11240 }
11241 
11242 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
11243   VisitOMPClauseWithPreInit(C);
11244   C->setModifier(Record.readEnum<OpenMPNumTasksClauseModifier>());
11245   C->setNumTasks(Record.readSubExpr());
11246   C->setModifierLoc(Record.readSourceLocation());
11247   C->setLParenLoc(Record.readSourceLocation());
11248 }
11249 
11250 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
11251   C->setHint(Record.readSubExpr());
11252   C->setLParenLoc(Record.readSourceLocation());
11253 }
11254 
11255 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
11256   VisitOMPClauseWithPreInit(C);
11257   C->setDistScheduleKind(
11258       static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
11259   C->setChunkSize(Record.readSubExpr());
11260   C->setLParenLoc(Record.readSourceLocation());
11261   C->setDistScheduleKindLoc(Record.readSourceLocation());
11262   C->setCommaLoc(Record.readSourceLocation());
11263 }
11264 
11265 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
11266   C->setDefaultmapKind(
11267        static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
11268   C->setDefaultmapModifier(
11269       static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
11270   C->setLParenLoc(Record.readSourceLocation());
11271   C->setDefaultmapModifierLoc(Record.readSourceLocation());
11272   C->setDefaultmapKindLoc(Record.readSourceLocation());
11273 }
11274 
11275 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
11276   C->setLParenLoc(Record.readSourceLocation());
11277   for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
11278     C->setMotionModifier(
11279         I, static_cast<OpenMPMotionModifierKind>(Record.readInt()));
11280     C->setMotionModifierLoc(I, Record.readSourceLocation());
11281   }
11282   C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
11283   C->setMapperIdInfo(Record.readDeclarationNameInfo());
11284   C->setColonLoc(Record.readSourceLocation());
11285   auto NumVars = C->varlist_size();
11286   auto UniqueDecls = C->getUniqueDeclarationsNum();
11287   auto TotalLists = C->getTotalComponentListNum();
11288   auto TotalComponents = C->getTotalComponentsNum();
11289 
11290   SmallVector<Expr *, 16> Vars;
11291   Vars.reserve(NumVars);
11292   for (unsigned i = 0; i != NumVars; ++i)
11293     Vars.push_back(Record.readSubExpr());
11294   C->setVarRefs(Vars);
11295 
11296   SmallVector<Expr *, 16> UDMappers;
11297   UDMappers.reserve(NumVars);
11298   for (unsigned I = 0; I < NumVars; ++I)
11299     UDMappers.push_back(Record.readSubExpr());
11300   C->setUDMapperRefs(UDMappers);
11301 
11302   SmallVector<ValueDecl *, 16> Decls;
11303   Decls.reserve(UniqueDecls);
11304   for (unsigned i = 0; i < UniqueDecls; ++i)
11305     Decls.push_back(Record.readDeclAs<ValueDecl>());
11306   C->setUniqueDecls(Decls);
11307 
11308   SmallVector<unsigned, 16> ListsPerDecl;
11309   ListsPerDecl.reserve(UniqueDecls);
11310   for (unsigned i = 0; i < UniqueDecls; ++i)
11311     ListsPerDecl.push_back(Record.readInt());
11312   C->setDeclNumLists(ListsPerDecl);
11313 
11314   SmallVector<unsigned, 32> ListSizes;
11315   ListSizes.reserve(TotalLists);
11316   for (unsigned i = 0; i < TotalLists; ++i)
11317     ListSizes.push_back(Record.readInt());
11318   C->setComponentListSizes(ListSizes);
11319 
11320   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11321   Components.reserve(TotalComponents);
11322   for (unsigned i = 0; i < TotalComponents; ++i) {
11323     Expr *AssociatedExprPr = Record.readSubExpr();
11324     bool IsNonContiguous = Record.readBool();
11325     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11326     Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11327   }
11328   C->setComponents(Components, ListSizes);
11329 }
11330 
11331 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
11332   C->setLParenLoc(Record.readSourceLocation());
11333   for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
11334     C->setMotionModifier(
11335         I, static_cast<OpenMPMotionModifierKind>(Record.readInt()));
11336     C->setMotionModifierLoc(I, Record.readSourceLocation());
11337   }
11338   C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
11339   C->setMapperIdInfo(Record.readDeclarationNameInfo());
11340   C->setColonLoc(Record.readSourceLocation());
11341   auto NumVars = C->varlist_size();
11342   auto UniqueDecls = C->getUniqueDeclarationsNum();
11343   auto TotalLists = C->getTotalComponentListNum();
11344   auto TotalComponents = C->getTotalComponentsNum();
11345 
11346   SmallVector<Expr *, 16> Vars;
11347   Vars.reserve(NumVars);
11348   for (unsigned i = 0; i != NumVars; ++i)
11349     Vars.push_back(Record.readSubExpr());
11350   C->setVarRefs(Vars);
11351 
11352   SmallVector<Expr *, 16> UDMappers;
11353   UDMappers.reserve(NumVars);
11354   for (unsigned I = 0; I < NumVars; ++I)
11355     UDMappers.push_back(Record.readSubExpr());
11356   C->setUDMapperRefs(UDMappers);
11357 
11358   SmallVector<ValueDecl *, 16> Decls;
11359   Decls.reserve(UniqueDecls);
11360   for (unsigned i = 0; i < UniqueDecls; ++i)
11361     Decls.push_back(Record.readDeclAs<ValueDecl>());
11362   C->setUniqueDecls(Decls);
11363 
11364   SmallVector<unsigned, 16> ListsPerDecl;
11365   ListsPerDecl.reserve(UniqueDecls);
11366   for (unsigned i = 0; i < UniqueDecls; ++i)
11367     ListsPerDecl.push_back(Record.readInt());
11368   C->setDeclNumLists(ListsPerDecl);
11369 
11370   SmallVector<unsigned, 32> ListSizes;
11371   ListSizes.reserve(TotalLists);
11372   for (unsigned i = 0; i < TotalLists; ++i)
11373     ListSizes.push_back(Record.readInt());
11374   C->setComponentListSizes(ListSizes);
11375 
11376   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11377   Components.reserve(TotalComponents);
11378   for (unsigned i = 0; i < TotalComponents; ++i) {
11379     Expr *AssociatedExprPr = Record.readSubExpr();
11380     bool IsNonContiguous = Record.readBool();
11381     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11382     Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11383   }
11384   C->setComponents(Components, ListSizes);
11385 }
11386 
11387 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
11388   C->setLParenLoc(Record.readSourceLocation());
11389   auto NumVars = C->varlist_size();
11390   auto UniqueDecls = C->getUniqueDeclarationsNum();
11391   auto TotalLists = C->getTotalComponentListNum();
11392   auto TotalComponents = C->getTotalComponentsNum();
11393 
11394   SmallVector<Expr *, 16> Vars;
11395   Vars.reserve(NumVars);
11396   for (unsigned i = 0; i != NumVars; ++i)
11397     Vars.push_back(Record.readSubExpr());
11398   C->setVarRefs(Vars);
11399   Vars.clear();
11400   for (unsigned i = 0; i != NumVars; ++i)
11401     Vars.push_back(Record.readSubExpr());
11402   C->setPrivateCopies(Vars);
11403   Vars.clear();
11404   for (unsigned i = 0; i != NumVars; ++i)
11405     Vars.push_back(Record.readSubExpr());
11406   C->setInits(Vars);
11407 
11408   SmallVector<ValueDecl *, 16> Decls;
11409   Decls.reserve(UniqueDecls);
11410   for (unsigned i = 0; i < UniqueDecls; ++i)
11411     Decls.push_back(Record.readDeclAs<ValueDecl>());
11412   C->setUniqueDecls(Decls);
11413 
11414   SmallVector<unsigned, 16> ListsPerDecl;
11415   ListsPerDecl.reserve(UniqueDecls);
11416   for (unsigned i = 0; i < UniqueDecls; ++i)
11417     ListsPerDecl.push_back(Record.readInt());
11418   C->setDeclNumLists(ListsPerDecl);
11419 
11420   SmallVector<unsigned, 32> ListSizes;
11421   ListSizes.reserve(TotalLists);
11422   for (unsigned i = 0; i < TotalLists; ++i)
11423     ListSizes.push_back(Record.readInt());
11424   C->setComponentListSizes(ListSizes);
11425 
11426   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11427   Components.reserve(TotalComponents);
11428   for (unsigned i = 0; i < TotalComponents; ++i) {
11429     auto *AssociatedExprPr = Record.readSubExpr();
11430     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11431     Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11432                             /*IsNonContiguous=*/false);
11433   }
11434   C->setComponents(Components, ListSizes);
11435 }
11436 
11437 void OMPClauseReader::VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C) {
11438   C->setLParenLoc(Record.readSourceLocation());
11439   auto NumVars = C->varlist_size();
11440   auto UniqueDecls = C->getUniqueDeclarationsNum();
11441   auto TotalLists = C->getTotalComponentListNum();
11442   auto TotalComponents = C->getTotalComponentsNum();
11443 
11444   SmallVector<Expr *, 16> Vars;
11445   Vars.reserve(NumVars);
11446   for (unsigned i = 0; i != NumVars; ++i)
11447     Vars.push_back(Record.readSubExpr());
11448   C->setVarRefs(Vars);
11449 
11450   SmallVector<ValueDecl *, 16> Decls;
11451   Decls.reserve(UniqueDecls);
11452   for (unsigned i = 0; i < UniqueDecls; ++i)
11453     Decls.push_back(Record.readDeclAs<ValueDecl>());
11454   C->setUniqueDecls(Decls);
11455 
11456   SmallVector<unsigned, 16> ListsPerDecl;
11457   ListsPerDecl.reserve(UniqueDecls);
11458   for (unsigned i = 0; i < UniqueDecls; ++i)
11459     ListsPerDecl.push_back(Record.readInt());
11460   C->setDeclNumLists(ListsPerDecl);
11461 
11462   SmallVector<unsigned, 32> ListSizes;
11463   ListSizes.reserve(TotalLists);
11464   for (unsigned i = 0; i < TotalLists; ++i)
11465     ListSizes.push_back(Record.readInt());
11466   C->setComponentListSizes(ListSizes);
11467 
11468   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11469   Components.reserve(TotalComponents);
11470   for (unsigned i = 0; i < TotalComponents; ++i) {
11471     Expr *AssociatedExpr = Record.readSubExpr();
11472     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11473     Components.emplace_back(AssociatedExpr, AssociatedDecl,
11474                             /*IsNonContiguous*/ false);
11475   }
11476   C->setComponents(Components, ListSizes);
11477 }
11478 
11479 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
11480   C->setLParenLoc(Record.readSourceLocation());
11481   auto NumVars = C->varlist_size();
11482   auto UniqueDecls = C->getUniqueDeclarationsNum();
11483   auto TotalLists = C->getTotalComponentListNum();
11484   auto TotalComponents = C->getTotalComponentsNum();
11485 
11486   SmallVector<Expr *, 16> Vars;
11487   Vars.reserve(NumVars);
11488   for (unsigned i = 0; i != NumVars; ++i)
11489     Vars.push_back(Record.readSubExpr());
11490   C->setVarRefs(Vars);
11491   Vars.clear();
11492 
11493   SmallVector<ValueDecl *, 16> Decls;
11494   Decls.reserve(UniqueDecls);
11495   for (unsigned i = 0; i < UniqueDecls; ++i)
11496     Decls.push_back(Record.readDeclAs<ValueDecl>());
11497   C->setUniqueDecls(Decls);
11498 
11499   SmallVector<unsigned, 16> ListsPerDecl;
11500   ListsPerDecl.reserve(UniqueDecls);
11501   for (unsigned i = 0; i < UniqueDecls; ++i)
11502     ListsPerDecl.push_back(Record.readInt());
11503   C->setDeclNumLists(ListsPerDecl);
11504 
11505   SmallVector<unsigned, 32> ListSizes;
11506   ListSizes.reserve(TotalLists);
11507   for (unsigned i = 0; i < TotalLists; ++i)
11508     ListSizes.push_back(Record.readInt());
11509   C->setComponentListSizes(ListSizes);
11510 
11511   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11512   Components.reserve(TotalComponents);
11513   for (unsigned i = 0; i < TotalComponents; ++i) {
11514     Expr *AssociatedExpr = Record.readSubExpr();
11515     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11516     Components.emplace_back(AssociatedExpr, AssociatedDecl,
11517                             /*IsNonContiguous=*/false);
11518   }
11519   C->setComponents(Components, ListSizes);
11520 }
11521 
11522 void OMPClauseReader::VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause *C) {
11523   C->setLParenLoc(Record.readSourceLocation());
11524   auto NumVars = C->varlist_size();
11525   auto UniqueDecls = C->getUniqueDeclarationsNum();
11526   auto TotalLists = C->getTotalComponentListNum();
11527   auto TotalComponents = C->getTotalComponentsNum();
11528 
11529   SmallVector<Expr *, 16> Vars;
11530   Vars.reserve(NumVars);
11531   for (unsigned I = 0; I != NumVars; ++I)
11532     Vars.push_back(Record.readSubExpr());
11533   C->setVarRefs(Vars);
11534   Vars.clear();
11535 
11536   SmallVector<ValueDecl *, 16> Decls;
11537   Decls.reserve(UniqueDecls);
11538   for (unsigned I = 0; I < UniqueDecls; ++I)
11539     Decls.push_back(Record.readDeclAs<ValueDecl>());
11540   C->setUniqueDecls(Decls);
11541 
11542   SmallVector<unsigned, 16> ListsPerDecl;
11543   ListsPerDecl.reserve(UniqueDecls);
11544   for (unsigned I = 0; I < UniqueDecls; ++I)
11545     ListsPerDecl.push_back(Record.readInt());
11546   C->setDeclNumLists(ListsPerDecl);
11547 
11548   SmallVector<unsigned, 32> ListSizes;
11549   ListSizes.reserve(TotalLists);
11550   for (unsigned i = 0; i < TotalLists; ++i)
11551     ListSizes.push_back(Record.readInt());
11552   C->setComponentListSizes(ListSizes);
11553 
11554   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
11555   Components.reserve(TotalComponents);
11556   for (unsigned I = 0; I < TotalComponents; ++I) {
11557     Expr *AssociatedExpr = Record.readSubExpr();
11558     auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
11559     Components.emplace_back(AssociatedExpr, AssociatedDecl,
11560                             /*IsNonContiguous=*/false);
11561   }
11562   C->setComponents(Components, ListSizes);
11563 }
11564 
11565 void OMPClauseReader::VisitOMPNontemporalClause(OMPNontemporalClause *C) {
11566   C->setLParenLoc(Record.readSourceLocation());
11567   unsigned NumVars = C->varlist_size();
11568   SmallVector<Expr *, 16> Vars;
11569   Vars.reserve(NumVars);
11570   for (unsigned i = 0; i != NumVars; ++i)
11571     Vars.push_back(Record.readSubExpr());
11572   C->setVarRefs(Vars);
11573   Vars.clear();
11574   Vars.reserve(NumVars);
11575   for (unsigned i = 0; i != NumVars; ++i)
11576     Vars.push_back(Record.readSubExpr());
11577   C->setPrivateRefs(Vars);
11578 }
11579 
11580 void OMPClauseReader::VisitOMPInclusiveClause(OMPInclusiveClause *C) {
11581   C->setLParenLoc(Record.readSourceLocation());
11582   unsigned NumVars = C->varlist_size();
11583   SmallVector<Expr *, 16> Vars;
11584   Vars.reserve(NumVars);
11585   for (unsigned i = 0; i != NumVars; ++i)
11586     Vars.push_back(Record.readSubExpr());
11587   C->setVarRefs(Vars);
11588 }
11589 
11590 void OMPClauseReader::VisitOMPExclusiveClause(OMPExclusiveClause *C) {
11591   C->setLParenLoc(Record.readSourceLocation());
11592   unsigned NumVars = C->varlist_size();
11593   SmallVector<Expr *, 16> Vars;
11594   Vars.reserve(NumVars);
11595   for (unsigned i = 0; i != NumVars; ++i)
11596     Vars.push_back(Record.readSubExpr());
11597   C->setVarRefs(Vars);
11598 }
11599 
11600 void OMPClauseReader::VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C) {
11601   C->setLParenLoc(Record.readSourceLocation());
11602   unsigned NumOfAllocators = C->getNumberOfAllocators();
11603   SmallVector<OMPUsesAllocatorsClause::Data, 4> Data;
11604   Data.reserve(NumOfAllocators);
11605   for (unsigned I = 0; I != NumOfAllocators; ++I) {
11606     OMPUsesAllocatorsClause::Data &D = Data.emplace_back();
11607     D.Allocator = Record.readSubExpr();
11608     D.AllocatorTraits = Record.readSubExpr();
11609     D.LParenLoc = Record.readSourceLocation();
11610     D.RParenLoc = Record.readSourceLocation();
11611   }
11612   C->setAllocatorsData(Data);
11613 }
11614 
11615 void OMPClauseReader::VisitOMPAffinityClause(OMPAffinityClause *C) {
11616   C->setLParenLoc(Record.readSourceLocation());
11617   C->setModifier(Record.readSubExpr());
11618   C->setColonLoc(Record.readSourceLocation());
11619   unsigned NumOfLocators = C->varlist_size();
11620   SmallVector<Expr *, 4> Locators;
11621   Locators.reserve(NumOfLocators);
11622   for (unsigned I = 0; I != NumOfLocators; ++I)
11623     Locators.push_back(Record.readSubExpr());
11624   C->setVarRefs(Locators);
11625 }
11626 
11627 void OMPClauseReader::VisitOMPOrderClause(OMPOrderClause *C) {
11628   C->setKind(Record.readEnum<OpenMPOrderClauseKind>());
11629   C->setModifier(Record.readEnum<OpenMPOrderClauseModifier>());
11630   C->setLParenLoc(Record.readSourceLocation());
11631   C->setKindKwLoc(Record.readSourceLocation());
11632   C->setModifierKwLoc(Record.readSourceLocation());
11633 }
11634 
11635 void OMPClauseReader::VisitOMPFilterClause(OMPFilterClause *C) {
11636   VisitOMPClauseWithPreInit(C);
11637   C->setThreadID(Record.readSubExpr());
11638   C->setLParenLoc(Record.readSourceLocation());
11639 }
11640 
11641 void OMPClauseReader::VisitOMPBindClause(OMPBindClause *C) {
11642   C->setBindKind(Record.readEnum<OpenMPBindClauseKind>());
11643   C->setLParenLoc(Record.readSourceLocation());
11644   C->setBindKindLoc(Record.readSourceLocation());
11645 }
11646 
11647 void OMPClauseReader::VisitOMPAlignClause(OMPAlignClause *C) {
11648   C->setAlignment(Record.readExpr());
11649   C->setLParenLoc(Record.readSourceLocation());
11650 }
11651 
11652 void OMPClauseReader::VisitOMPXDynCGroupMemClause(OMPXDynCGroupMemClause *C) {
11653   VisitOMPClauseWithPreInit(C);
11654   C->setSize(Record.readSubExpr());
11655   C->setLParenLoc(Record.readSourceLocation());
11656 }
11657 
11658 void OMPClauseReader::VisitOMPDoacrossClause(OMPDoacrossClause *C) {
11659   C->setLParenLoc(Record.readSourceLocation());
11660   C->setDependenceType(
11661       static_cast<OpenMPDoacrossClauseModifier>(Record.readInt()));
11662   C->setDependenceLoc(Record.readSourceLocation());
11663   C->setColonLoc(Record.readSourceLocation());
11664   unsigned NumVars = C->varlist_size();
11665   SmallVector<Expr *, 16> Vars;
11666   Vars.reserve(NumVars);
11667   for (unsigned I = 0; I != NumVars; ++I)
11668     Vars.push_back(Record.readSubExpr());
11669   C->setVarRefs(Vars);
11670   for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
11671     C->setLoopData(I, Record.readSubExpr());
11672 }
11673 
11674 void OMPClauseReader::VisitOMPXAttributeClause(OMPXAttributeClause *C) {
11675   AttrVec Attrs;
11676   Record.readAttributes(Attrs);
11677   C->setAttrs(Attrs);
11678   C->setLocStart(Record.readSourceLocation());
11679   C->setLParenLoc(Record.readSourceLocation());
11680   C->setLocEnd(Record.readSourceLocation());
11681 }
11682 
11683 void OMPClauseReader::VisitOMPXBareClause(OMPXBareClause *C) {}
11684 
11685 OMPTraitInfo *ASTRecordReader::readOMPTraitInfo() {
11686   OMPTraitInfo &TI = getContext().getNewOMPTraitInfo();
11687   TI.Sets.resize(readUInt32());
11688   for (auto &Set : TI.Sets) {
11689     Set.Kind = readEnum<llvm::omp::TraitSet>();
11690     Set.Selectors.resize(readUInt32());
11691     for (auto &Selector : Set.Selectors) {
11692       Selector.Kind = readEnum<llvm::omp::TraitSelector>();
11693       Selector.ScoreOrCondition = nullptr;
11694       if (readBool())
11695         Selector.ScoreOrCondition = readExprRef();
11696       Selector.Properties.resize(readUInt32());
11697       for (auto &Property : Selector.Properties)
11698         Property.Kind = readEnum<llvm::omp::TraitProperty>();
11699     }
11700   }
11701   return &TI;
11702 }
11703 
11704 void ASTRecordReader::readOMPChildren(OMPChildren *Data) {
11705   if (!Data)
11706     return;
11707   if (Reader->ReadingKind == ASTReader::Read_Stmt) {
11708     // Skip NumClauses, NumChildren and HasAssociatedStmt fields.
11709     skipInts(3);
11710   }
11711   SmallVector<OMPClause *, 4> Clauses(Data->getNumClauses());
11712   for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
11713     Clauses[I] = readOMPClause();
11714   Data->setClauses(Clauses);
11715   if (Data->hasAssociatedStmt())
11716     Data->setAssociatedStmt(readStmt());
11717   for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
11718     Data->getChildren()[I] = readStmt();
11719 }
11720